예제 #1
0
int fn_print_loop_stack(_kforth_context *context)
{
    int *p1;
    for(p1=context->loop_stack; p1!=context->loop_stack_ptr; p1++)
    {
        platform_printf("%d ", *p1);
    }
    platform_printf("\r\n");
    return 0;
}
예제 #2
0
int fn_print_top(_kforth_context *context)
{
    if (context->stack==context->stack_ptr)
    {
        platform_printf("EOS\r\n");
    }
    else
    {
        platform_printf("%d ", context->stack_ptr[-1]);
        context->stack_ptr--;
    }
    return 0;
}
예제 #3
0
int platform_mutex_unlock(Mutex* m)
{
    if (!m)
    {
        platform_printf("%s: invalid mutex %p\n", __func__, m);
        return -1;
    }

    wiced_result_t rc = wiced_rtos_unlock_mutex(&m->mutex);
    if (rc != WICED_SUCCESS)
        platform_printf("%s: FAILED to unlock %p: %d\n", __func__, &m->mutex, rc);
    return 0;
}
예제 #4
0
int fn_read(_kforth_context *context)
{
    platform_printf("Reading From 0x%08X\r\n", STACK(0));
    STACK_POP();
    STACK_PUSH(0);
    return 0;
}
예제 #5
0
int platform_semaphore_post(Semaphore* s)
{
    if (!s)
    {
        platform_printf("%s: invalid semaphore %p\n", __func__, s);
        return -1;
    }

    wiced_result_t rc = wiced_rtos_set_semaphore(&s->sem);
    if (rc != WICED_SUCCESS)
    {
        platform_printf("%s: FAILED to post semaphore %p: %d\n", __func__, &s->sem, rc);
        return -1;
    }

    return 0;
}
예제 #6
0
void platform_network_securedinit(Network* n, const char* ca_buf, size_t ca_size)
{
    if (!n || !ca_buf || !ca_size)
    {
        platform_printf("%s: bad args\n", __func__);
        return;
    }

    wiced_result_t rc = wiced_tls_init_root_ca_certificates(ca_buf);
    if (rc != WICED_SUCCESS)
    {
        platform_printf("%s: root CA certificate failed to initialize: %u\n", __func__, rc);
        return;
    }

    n->tls_enabled = WICED_TRUE;
}
예제 #7
0
void platform_semaphore_deinit(Semaphore* s)
{
    if (!s)
    {
        platform_printf("%s: invalid semaphore %p\n", __func__, s);
        return;
    }

    wiced_rtos_deinit_semaphore(&s->sem);
}
예제 #8
0
void platform_mutex_deinit(Mutex* m)
{
    if (!m)
    {
        platform_printf("%s: invalid mutex %p\n", __func__, m);
        return;
    }

    wiced_rtos_deinit_mutex(&m->mutex);
}
예제 #9
0
int platform_network_write(Network* n, unsigned char* buffer, int length, int timeout)
{
    wiced_result_t rc = wiced_tcp_stream_write(&n->stream, buffer, length);
    if (rc != WICED_SUCCESS)
    {
        platform_printf("unable to write data to tcp stream, rc = %d\n", rc);
        return -1;
    }

    rc = wiced_tcp_stream_flush(&n->stream);
    if (rc != WICED_SUCCESS)
    {
        platform_printf("unable to flush tcp stream, rc = %d\n", rc);
        return -1;
    }

    //platform_printf("%s: successfully sent %d bytes to tcp stream\n", __func__, length);

    return length;
}
예제 #10
0
int platform_thread_join(Thread* t, int timeout_ms)
{
    if (!t) return -1;

    if (platform_semaphore_wait(&t->join_sem, timeout_ms) != 0)
    {
        platform_printf("%s: timeout waiting for join\n", __func__);
        return -1;
    }

    return 0;
}
예제 #11
0
int platform_network_connect(Network* n, char* hostname, int port)
{
    wiced_ip_address_t ip_address;
    wiced_result_t rc = -1;

    int attempt = 1;

    do
    {
        platform_printf("trying to resolve hostname (attempt %d)\n", attempt);
        if ((rc = wiced_hostname_lookup(hostname, &ip_address, 10000)) == WICED_SUCCESS)
        {
            platform_printf("hostname resolved\n");
            break;
        }
    }
    while (++attempt <= 5);

    if (rc != WICED_SUCCESS)
    {
        platform_printf("failed to resolve ip address of %s, rc = %d\n", hostname, rc);
        return rc;
    }

    if (n->tls_enabled)
        wiced_tls_init_simple_context(&n->tls_context, hostname);

    /* Create a TCP socket */
    rc = wiced_tcp_create_socket(&n->socket, WICED_STA_INTERFACE);
    if (rc != WICED_SUCCESS)
    {
        platform_printf("tcp socket creation failed, rc = %d\n", rc);
        return rc;
    }

    if (n->tls_enabled)
        wiced_tcp_enable_tls(&n->socket, &n->tls_context);

    rc = wiced_tcp_connect(&n->socket, &ip_address, port, 5000);
    if (rc != WICED_SUCCESS)
    {
        platform_printf("unable to establish connection to %s:%d, rc = %d\n", hostname, port, rc);
        goto exit;
    }

    rc = wiced_tcp_stream_init(&n->stream, &n->socket);
    if (rc != WICED_SUCCESS)
    {
        platform_printf("unable to init tcp stream, rc = %d\n", rc);
        goto exit;
    }

    rc = WICED_SUCCESS;
exit:
    if (rc != WICED_SUCCESS)
        platform_network_disconnect(n);
    return rc;
}
예제 #12
0
int fn_print_dictionary(_kforth_context *context)
{
    char format_str[10];
    _word_entry_const *entry;
    _word_list_item *word_list;
    int name_length;
    int names_per_line;
    int name_index;
    int i;

    // first calculate the max name length
    name_length=0;
    for(entry=(_word_entry_const*)context->dictionary; entry!=NULL; entry=(_word_entry_const*)entry->next)
    {
        i=platform_strlen(entry->name);
        if (i>name_length)name_length=i;
    }

    // now calculate the max number of names to print per line
    names_per_line=((platform_get_print_width())/(name_length+2)); // +2 for 2 spaces between names

    platform_sprintf(format_str, "%%-%ds", name_length+2); // "%x-s"

    platform_printf("Print Dictionary\r\n");
    for(entry=(_word_entry_const*)context->dictionary, name_index=1; entry!=NULL; entry=(_word_entry_const*)entry->next, name_index++)
    {
        if ((name_index>0)&&((name_index%names_per_line)==0))
        {
            platform_printf("%s\r\n", entry->name);
        }
        else
        {
            platform_printf(format_str, entry->name);
        }
    }
    platform_printf("\r\n\r\n");
    return 0;
}
예제 #13
0
void log_callback(evrythng_log_level_t level, const char* fmt, va_list vl)
{
    char msg[512];

    unsigned n = vsnprintf(msg, sizeof msg, fmt, vl);
    if (n >= sizeof msg)
        msg[sizeof msg - 1] = '\0';

    switch (level)
    {
        case EVRYTHNG_LOG_ERROR:
            platform_printf("ERROR: ");
            break;
        case EVRYTHNG_LOG_WARNING:
            platform_printf("WARNING: ");
            break;
        default:
        case EVRYTHNG_LOG_DEBUG:
            platform_printf("DEBUG: ");
            break;
    }
    platform_printf("%s\n", msg);
}
예제 #14
0
int keepalive(MQTTClient* c)
{
    int rc = MQTT_FAILURE;

    if (c->keepAliveInterval == 0 || !c->isconnected)
    {
        rc = MQTT_SUCCESS;
        goto exit;
    }

    //printf("%s: %d, ping time left: %d, tick count = %u\n", __func__, __LINE__, TimerLeftMS(&c->ping_timer), xTaskGetTickCount());

    if (platform_timer_isexpired(&c->ping_timer))
    {
        if (!c->ping_outstanding)
        {
            Timer timer;
            platform_timer_init(&timer);
            platform_timer_countdown(&timer, 1000);
            int len = MQTTSerialize_pingreq(c->buf, c->buf_size);
            if (len > 0 && (rc = sendPacket(c, len, &timer)) == MQTT_SUCCESS) // send the ping packet
            {
                platform_timer_countdown(&c->pingresp_timer, c->command_timeout_ms);
                c->ping_outstanding = 1;
                platform_printf("sent ping request\n");
            }

            if (len > 0 && rc != MQTT_SUCCESS)
            {
                platform_printf("%s: %d failed to send ping request, rc = %d\n", __func__, __LINE__, rc);
            }
        }
    }

exit:
    return rc;
}
예제 #15
0
void RunAllTests()
{
    platform_semaphore_init(&sub_sem);

	CuString *output = CuStringNew();
    CuSuite* suite = CuGetSuite();

	CuSuiteRun(suite);
	CuSuiteSummary(suite, output);
	CuSuiteDetails(suite, output);
    platform_printf("%s\n", output->buffer);
    CuStringDelete(output);
    CuSuiteDelete(suite);

    platform_semaphore_deinit(&sub_sem);
}
예제 #16
0
int platform_semaphore_wait(Semaphore* s, int timeout_ms)
{
    if (!s)
    {
        platform_printf("%s: invalid semaphore %p\n", __func__, s);
        return -1;
    }

    wiced_result_t rc = wiced_rtos_get_semaphore(&s->sem, timeout_ms);
    if (rc != WICED_SUCCESS)
    {
        //platform_printf("%s: FAILED to wait semaphore %p: %d\n", __func__, &s->sem, rc);
        return -1;
    }

    return 0;
}
예제 #17
0
int platform_network_read(Network* n, unsigned char* buffer, int length, int timeout)
{
    wiced_result_t rc = wiced_tcp_stream_read(&n->stream, buffer, length, timeout);
    if (rc != WICED_SUCCESS)
    {
        if (rc == WICED_TIMEOUT)
        {
            return -1;
        }
        else
        {
            platform_printf("failed to read data from tcp stream, rc = %d\n", rc);
            return 0;
        }
    }

    //platform_printf("successfully read %d bytes from tcp stream\n", length);

    return length;
}
예제 #18
0
int fn_print_dictionary_full(_kforth_context *context)
{
    _word_entry_const *entry;
    _word_list_item *word_list;
    platform_printf("Print Dictionary\r\n");
    platform_printf("dictionary at 0x%08X\r\n", (unsigned int)context->dictionary);

    platform_printf("ADDRESS     NEXT        NAME     WORD_FN     WORD_LIST\r\n");

    for(entry=(_word_entry_const*)context->dictionary; entry!=NULL; entry=(_word_entry_const*)entry->next)
    {
        platform_printf("%08X    %08X    %5s    %08X    ", (unsigned int)entry, (unsigned int)entry->next,entry->name, (unsigned int)entry->word_fn);
        if (entry->word_list!=NULL)
        {
            for(word_list=(_word_list_item*)entry->word_list; word_list->type!=END_TYPE; word_list++)
            {
                platform_printf("%X:%08X ", word_list->type, (unsigned int)word_list->data);
            }
        }
        platform_printf("\r\n");
    }
    return 0;
}
예제 #19
0
static void test_sub_callback(const char* str_json, size_t len)
{
    char msg[len+1]; snprintf(msg, sizeof msg, "%s", str_json);
    platform_printf("%s: %s\n\r", __func__, msg);
    platform_semaphore_post(&sub_sem);
}
예제 #20
0
int fn_cr(_kforth_context *context)
{
	platform_printf("\r\n");
    return 0;
}
예제 #21
0
int cycle(MQTTClient* c, Timer* timer)
{
    Timer t;
    platform_timer_init(&t);

    int len = 0, packet_type, rc = MQTT_SUCCESS;

    // read the socket, see what work is due
    if ((packet_type = readPacket(c, timer)) == MQTT_CONNECTION_LOST)
	{
		rc = MQTT_CONNECTION_LOST;
		goto exit;
	}
    
    switch (packet_type)
    {
        case CONNACK:
        case PUBACK:
        case SUBACK:
            break;
        case PUBLISH:
        {
            MQTTString topicName;
            MQTTMessage msg = {0};
            int intQoS;
            if (MQTTDeserialize_publish(&msg.dup, &intQoS, &msg.retained, &msg.id, &topicName,
               (unsigned char**)&msg.payload, &msg.payloadlen, c->readbuf, c->readbuf_size) != 1)
                goto exit;
            msg.qos = (enum QoS)intQoS;
            deliverMessage(c, &topicName, &msg);
            if (msg.qos != QOS0)
            {
                if (msg.qos == QOS1)
                    len = MQTTSerialize_ack(c->buf, c->buf_size, PUBACK, 0, msg.id);
                else if (msg.qos == QOS2)
                    len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREC, 0, msg.id);
                if (len <= 0)
                    rc = MQTT_FAILURE;
                else
                {
                    platform_timer_countdown(&t, c->command_timeout_ms);
                    rc = sendPacket(c, len, &t);
                }
                if (rc == MQTT_FAILURE)
                    goto exit; // there was a problem
            }
            break;
        }
        case PUBREC:
        {
            unsigned short mypacketid;
            unsigned char dup, type;
            platform_timer_countdown(&t, c->command_timeout_ms);
            if (MQTTDeserialize_ack(&type, &dup, &mypacketid, c->readbuf, c->readbuf_size) != 1)
                rc = MQTT_FAILURE;
            else if ((len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREL, 0, mypacketid)) <= 0)
                rc = MQTT_FAILURE;
            else if ((rc = sendPacket(c, len, &t)) != MQTT_SUCCESS) // send the PUBREL packet
                rc = MQTT_FAILURE; // there was a problem
            if (rc == MQTT_FAILURE)
                goto exit; // there was a problem
            break;
        }
        case PUBCOMP:
            break;
        case PINGRESP:
            c->ping_outstanding = 0;
            platform_printf("received ping response\n");
            break;
    }

    keepalive(c);

    if (c->ping_outstanding && platform_timer_isexpired(&c->pingresp_timer))
    {
        c->ping_outstanding = 0;
		platform_printf("ping response was not received within keepalive timeout of %d\n", 
                c->keepAliveInterval);
        rc = MQTT_CONNECTION_LOST;
    }

exit:
	if (rc == MQTT_SUCCESS)
		rc = packet_type;

	return rc;
}
예제 #22
0
int MQTTPublish(MQTTClient* c, const char* topicName, MQTTMessage* message)
{
    int rc = MQTT_FAILURE;
    Timer timer;   
    MQTTString topic = MQTTString_initializer;
    topic.cstring = (char *)topicName;
    int len = 0;

	platform_mutex_lock(&c->mutex);
	if (!c->isconnected)
		goto exit;

    platform_timer_init(&timer);
    platform_timer_countdown(&timer, c->command_timeout_ms);

    if (message->qos == QOS1 || message->qos == QOS2)
        message->id = getNextPacketId(c);
    
    len = MQTTSerialize_publish(c->buf, c->buf_size, 0, message->qos, message->retained, message->id, 
              topic, (unsigned char*)message->payload, message->payloadlen);
    if (len <= 0)
        goto exit;
    if ((rc = sendPacket(c, len, &timer)) != MQTT_SUCCESS) // send the subscribe packet
    {
        goto exit; // there was a problem
    }

    if (message->qos == QOS1)
    {
        if (waitfor(c, PUBACK, &timer) == PUBACK)
        {
            unsigned short mypacketid;
            unsigned char dup, type;
            if (MQTTDeserialize_ack(&type, &dup, &mypacketid, c->readbuf, c->readbuf_size) != 1)
            {
                platform_printf("failed to deserialize ACK\n");
                rc = MQTT_FAILURE;
            }
        }
        else
        {
            rc = MQTT_CONNECTION_LOST;
        }
    }
    else if (message->qos == QOS2)
    {
        if (waitfor(c, PUBCOMP, &timer) == PUBCOMP)
        {
            unsigned short mypacketid;
            unsigned char dup, type;
            if (MQTTDeserialize_ack(&type, &dup, &mypacketid, c->readbuf, c->readbuf_size) != 1)
                rc = MQTT_FAILURE;
        }
        else 
        {
            rc = MQTT_CONNECTION_LOST;
		}
    }
    
exit:
	platform_mutex_unlock(&c->mutex);
    return rc;
}
예제 #23
0
void on_connection_lost()
{
    platform_printf("evt lib connection lost\n");
}
예제 #24
0
int fn_write(_kforth_context *context)
{
    platform_printf("Writing 0x%X to 0x%08X\r\n", STACK(0), STACK(-1));
    STACK_POP_X(2);
    return 0;
}
예제 #25
0
void on_connection_restored()
{
    platform_printf("evt lib connection restored\n");
}