// Main application thread which is started by the RTOS after boot void application_start(void) { wiced_init( ); dbStart(); WPRINT_APP_INFO(("Starting WWEP Server\n")); while(wiced_network_up( INTERFACE, DHCP_MODE, &ip_settings ) != WICED_SUCCESS); // Keep trying until you get hooked up // I created all of the server code in a separate thread to make it easier to put the server // and client together in one application. wiced_rtos_create_thread(&tcp_thread, TCP_SERVER_NONSECURE_THREAD_PRIORITY, "Server TCP Server", tcp_server_nonsecure_thread_main, TCP_SERVER_NONSECURE_STACK_SIZE, 0); wiced_rtos_create_thread(&ping_thread, PING_THREAD_PRIORITY, "Ping", pingAP, 1024, 0); // Setup Display WPRINT_APP_INFO(("#\t IP\t\tPort\tMessage\n")); WPRINT_APP_INFO(("----------------------------------------------------------------------\n")); // just blink the led while the whole thing is running while(1) { wiced_gpio_output_low( WICED_LED1 ); wiced_rtos_delay_milliseconds( 250 ); wiced_gpio_output_high( WICED_LED1 ); wiced_rtos_delay_milliseconds( 250 ); } }
/* Define the thread function that will blink the LED on/off every 500ms */ void ledThread(wiced_thread_arg_t arg) { while(1) { /* LED OFF for the shield (LED ON if using the baseboard by itself) */ wiced_gpio_output_low( WICED_LED1 ); wiced_rtos_delay_milliseconds( 250 ); /* LED ON for the shield (LED OFF if using the baseboard by itself) */ wiced_gpio_output_high( WICED_LED1 ); wiced_rtos_delay_milliseconds( 250 ); } }
void application_start( ) { uint8_t led_state = 0; wiced_bool_t button_pressed; /* Initialise the WICED device */ wiced_init(); // The RGB and setup button are initialized in platform.c WPRINT_APP_INFO( ( "The RGB are flashing R-G-B alternately. Holding the setup button will force it flashing white.\n" ) ); while ( 1 ) { /* Read the state of setup button */ button_pressed = wiced_gpio_input_get( SETUP_BUTTON ) ? WICED_FALSE : WICED_TRUE; /* The button has inverse logic */ if ( button_pressed == WICED_TRUE ) { /* Flashing white */ if( (led_state%2) == 0 ) { wiced_gpio_output_low( RGB_R ); wiced_gpio_output_low( RGB_G ); wiced_gpio_output_low( RGB_B ); } else { wiced_gpio_output_high( RGB_R ); wiced_gpio_output_high( RGB_G ); wiced_gpio_output_high( RGB_B ); } } else { /* Flashing R-G-B alternately */ if ( (led_state%3) == 0 ) { wiced_gpio_output_low( RGB_R ); wiced_gpio_output_high( RGB_G ); wiced_gpio_output_high( RGB_B ); } else if ( (led_state%3) == 1 ) { wiced_gpio_output_high( RGB_R ); wiced_gpio_output_low( RGB_G ); wiced_gpio_output_high( RGB_B ); } else { wiced_gpio_output_high( RGB_R ); wiced_gpio_output_high( RGB_G ); wiced_gpio_output_low( RGB_B ); } } wiced_rtos_delay_milliseconds( 300 ); led_state++; } }
/* * Main AMQP thread. * * The thread will create a connection and then loop over the following: * * - Open a connection * - Open a channel * - Create (declare) a "WICED_QUEUE" queue * - Bind the queue to "amq.direct" exchange * - Send data through to the exchange ( using publish and send string) * - Receive data from the queue ( using consume and receive string ) * - Close the channel * - Close the connection */ void application_start( void ) { wiced_result_t ret = WICED_SUCCESS; wiced_init( ); wiced_rtos_init_semaphore( &semaphore ); /* Bringup the network interface */ wiced_network_up( WICED_STA_INTERFACE, WICED_USE_EXTERNAL_DHCP_SERVER, NULL ); WPRINT_APP_INFO(("[AMQP] Connecting to broker %u.%u.%u.%u ...", (uint8_t)(GET_IPV4_ADDRESS(broker_address) >> 24), (uint8_t)(GET_IPV4_ADDRESS(broker_address) >> 16), (uint8_t)(GET_IPV4_ADDRESS(broker_address) >> 8), (uint8_t)(GET_IPV4_ADDRESS(broker_address) >> 0))); ret = amqp_connection_init( &broker_address, WICED_STA_INTERFACE, &callbacks, &connection, NULL ); amqp_print_status( ret, NULL, NULL ); while( ret == WICED_SUCCESS ) { WPRINT_APP_INFO(("[AMQP] Opening connection...")); RUN_COMMAND_PRINT_STATUS_AND_BREAK_ON_ERROR( amqp_conn_open( &connection ), NULL, "Did you configure you broker IP address?\n" ); WPRINT_APP_INFO(("[AMQP] Opening channel...")); RUN_COMMAND_PRINT_STATUS_AND_BREAK_ON_ERROR( amqp_ch_open( &connection, 1 ), NULL, NULL ); WPRINT_APP_INFO(("[AMQP] Declaring queue...")); RUN_COMMAND_PRINT_STATUS_AND_BREAK_ON_ERROR( amqp_ch_queue_declare( &connection, 1, AMQP_RECEIVE_QUEUE_NAME ), NULL, NULL ); WPRINT_APP_INFO(("[AMQP] Binding queue...")); RUN_COMMAND_PRINT_STATUS_AND_BREAK_ON_ERROR( amqp_ch_queue_bind( &connection, 1, AMQP_RECEIVE_QUEUE_NAME, AMQP_ROUTING_KEY_NAME ), NULL, NULL ); WPRINT_APP_INFO(("[AMQP] Consuming...")); RUN_COMMAND_PRINT_STATUS_AND_BREAK_ON_ERROR( amqp_ch_consume( &connection, 1, AMQP_RECEIVE_QUEUE_NAME ), NULL, NULL ); WPRINT_APP_INFO(("[AMQP] Publishing...")); RUN_COMMAND_PRINT_STATUS_AND_BREAK_ON_ERROR( amqp_ch_publish( &connection, 1, AMQP_ROUTING_KEY_NAME ), NULL, NULL ); WPRINT_APP_INFO(("[AMQP] Sending message...")); RUN_COMMAND_PRINT_STATUS_AND_BREAK_ON_ERROR( amqp_ch_send_string( &connection, 1, AMQP_MESSAGE_STR ), AMQP_MESSAGE_STR, NULL ); WPRINT_APP_INFO(("[AMQP] Receiving message...")); RUN_COMMAND_PRINT_STATUS_AND_BREAK_ON_ERROR( amqp_ch_recv_string( &connection, 1 ), str, NULL ); WPRINT_APP_INFO(("[AMQP] Closing channel...")); RUN_COMMAND_PRINT_STATUS_AND_BREAK_ON_ERROR( amqp_ch_close( &connection, 1 ), NULL, NULL); WPRINT_APP_INFO(("[AMQP] Closing connection...")); RUN_COMMAND_PRINT_STATUS_AND_BREAK_ON_ERROR( amqp_conn_close( &connection ), NULL, NULL ); wiced_rtos_delay_milliseconds( 2000 ); } WPRINT_APP_INFO(("[AMQP] Deinit connection...")); ret = amqp_connection_deinit( &connection ); amqp_print_status( ret, NULL, NULL ); }
/****************************************************** * Function Definitions ******************************************************/ wiced_result_t aws_app_init( aws_app_info_t *app_info ) { wiced_result_t ret = WICED_SUCCESS; aws_config_dct_t *aws_app_dct = NULL; aws_app_info = app_info; wiced_init( ); /* Disable roaming to other access points */ wiced_wifi_set_roam_trigger( -99 ); /* -99dBm ie. extremely low signal level */ WPRINT_APP_INFO((" Please wait, connecting to network...\n")); WPRINT_APP_INFO(("(To return to SSID console screen, hold USER switch for 5 seconds during RESET to clear DCT configuration)\n")); wiced_rtos_delay_milliseconds( 1000 ); for ( int i = 0; i < 25; i++ ) { wiced_gpio_output_high( WICED_LED2 ); wiced_rtos_delay_milliseconds( 100 ); wiced_gpio_output_low( WICED_LED2 ); wiced_rtos_delay_milliseconds( 100 ); if ( !wiced_gpio_input_get( WICED_BUTTON1 ) ) { wiced_rtos_delay_milliseconds( 5000 ); if ( !wiced_gpio_input_get( WICED_BUTTON1 ) ) { aws_config_dct_t aws_dct = { .is_configured = WICED_FALSE, .thing_name = AWS_DEFAULT_THING_NAME }; wiced_gpio_output_high( WICED_LED1 ); WPRINT_APP_INFO(( "DCT clearing start\n" )); wiced_dct_write( &aws_dct, DCT_APP_SECTION, 0, sizeof( aws_config_dct_t ) ); wiced_rtos_delay_milliseconds( 1000 ); wiced_gpio_output_low( WICED_LED1 ); WPRINT_APP_INFO(( "DCT clearing end\n" )); break; } }
void application_start( ) { /* Initialise the WICED device */ wiced_init(); WPRINT_APP_INFO( ( "The color of the RGB is changing every second.\n" ) ); RGB_Init( D0 ); while ( 1 ) { RGB_Show(0xFF, 0x00, 0x00); wiced_rtos_delay_milliseconds( 500 ); RGB_Show(0x00, 0xFF, 0x00); wiced_rtos_delay_milliseconds( 500 ); RGB_Show(0x00, 0x00, 0xFF); wiced_rtos_delay_milliseconds( 500 ); RGB_Show(0xFF, 0x00, 0xFF); wiced_rtos_delay_milliseconds( 500 ); RGB_Show(0xFF, 0xFF, 0x00); wiced_rtos_delay_milliseconds( 500 ); RGB_Show(0x00, 0xFF, 0xFF); wiced_rtos_delay_milliseconds( 500 ); } }
void application_start( ) { float temp = 100; float duty = 100; float cnt = 0; wiced_bool_t rise = WICED_FALSE; /* Initialise the WICED device */ wiced_init(); // The RGB and setup button are initialized in platform.c WPRINT_APP_INFO( ( "The RGB is breathing green.\n" ) ); while ( 1 ) { wiced_pwm_init( RGB_G_PWM, 1000, duty ); wiced_pwm_start( RGB_G_PWM ); wiced_rtos_delay_milliseconds( 10 ); if(rise) { temp += cnt; cnt -= 0.005; if(temp >= 100.0) { duty = 100; cnt = 0; rise = WICED_FALSE; } else { duty = temp; } } else { cnt += 0.005; temp -= cnt; if(temp <= 0.0) { duty = 0; rise = WICED_TRUE; } else { duty = temp; } } } }
// executed on tx worker thread static wiced_result_t h4_tx_worker_send_packet(void * arg){ #ifdef WICED_BT_UART_MANUAL_CTS_RTS while (platform_gpio_input_get(wiced_bt_uart_pins[WICED_BT_PIN_UART_CTS]) == WICED_TRUE){ printf("."); wiced_rtos_delay_milliseconds(10); } printf("\n"); #endif // blocking send platform_uart_transmit_bytes(wiced_bt_uart_driver, tx_worker_data_buffer, tx_worker_data_size); // let stack know btstack_run_loop_wiced_execute_code_on_main_thread(&h4_main_notify_packet_send, NULL); return WICED_SUCCESS; }
// Some APs will not stay attached if you don't talk periodically. // This thread will ping every 60 seconds void pingAP (wiced_thread_arg_t arg) { uint32_t time_elapsed; wiced_ip_address_t routerAddress; wiced_result_t result; while(1) { SET_IPV4_ADDRESS(routerAddress,MAKE_IPV4_ADDRESS( 198, 51, 100, 1 )); result = wiced_ping (INTERFACE, &routerAddress, 500, &time_elapsed); if(result != WICED_SUCCESS) { WPRINT_APP_INFO(("Ping Failed\n")); } wiced_rtos_delay_milliseconds(60000); } }
void application_start( ) { Network mqtt_network; Client mqtt_client; unsigned char buf[ 100 ]; unsigned char readbuf[ 100 ]; wiced_ip_address_t INITIALISER_IPV4_ADDRESS( ip_address, MQTT_TARGET_IP ); wiced_init( ); /* Initialize MQTT */ wiced_mqtt_init( &mqtt_network ); wiced_mqtt_buffer_init( &mqtt_client, &mqtt_network, buf, 100, readbuf, 100 ); mqtt_network.hostname = "broker.mqttdashboard.com"; mqtt_network.ip_address = &ip_address; mqtt_network.port = MQTT_BROKER_PORT; /* Bring up the network interface */ wiced_network_up( WICED_STA_INTERFACE, WICED_USE_EXTERNAL_DHCP_SERVER, NULL ); if ( wiced_connectnetwork( &mqtt_network, WICED_STA_INTERFACE ) != WICED_SUCCESS ) { WPRINT_APP_INFO( ("connection failed\n") ); return; } wiced_mqtt_connect( &mqtt_client, MQTT_CLIENT_ID, NULL, NULL ); wiced_mqtt_subscribe( &mqtt_client, MQTT_TOPIC_NAME, messageArrived ); while ( 1 ) { wiced_subscribe( &mqtt_client ); wiced_rtos_delay_milliseconds( 500 ); } }
void application_start( ) { /* Initialise the WICED device */ wiced_init(); while ( 1 ) { WPRINT_APP_INFO( ( "Analog input voltage measurement:\n" ) ); for(uint8_t i=0; i<8; i++) { wiced_adc_init( analog_channel[i], 480 ); // This function only takes sample for the channel that selected by the last time invoking wiced_adc_init(). // So if you change to take sample for another channel, you need to invoke wiced_adc_init() to select this channel first. wiced_adc_take_sample( analog_channel[i], &analog_value[i] ); WPRINT_APP_INFO( ( "Channel %d input voltage: %d\n", i, analog_value[i] ) ); } wiced_rtos_delay_milliseconds( 3000 ); WPRINT_APP_INFO( ( "\n\n" ) ); } }
void performtest_all(void) { u8 m=0,n=0,d=0; u8 tree_num[3] = {1,2,3}; u8 request_num[4] = {1,16,32,64}; u32 delay_tm[5] = {0,50,100,250,500}; performtest_titile_printf(); for(d=0; d<2; d++) { for(n=0; n<4; n++) { for(m=0; m<3; m++) { performtest_handle(delay_tm[d],tree_num[m],request_num[n]); #ifdef WILDDOG_PORT_TYPE_WICED wiced_rtos_delay_milliseconds(2000); #endif } } } performtest_end_printf(); }
void WD_SYSTEM performtest_handle ( u32 delay_tm, const u8 *p_url, u32 tree_num, u8 request_num ) { u8 m = 0; Wilddog_T wilddog = 0; performtest_init(delay_tm,tree_num,request_num); performtest_setSysState(SYS_HSK); wilddog = wilddog_initWithUrl((Wilddog_Str_T*)p_url); if(0 == wilddog) { return; } perform_count = 0; performtest_setSysState(SYS_AUTHRECV); performtest_timeReset(); while(1) { wilddog_trySync(); if(SYS_ISIN(SYS_APPLICATIONSENDING)) break; } performtest_timeReset(); for(m=0; m < request_num; m++) { performtest_timeReset(); /*printf("g_performtest.d_tm_star = %ul\n", g_performtest.d_tm_star);*/ int res = wilddog_getValue(wilddog, test_onQueryFunc, NULL); performtest_getSendTime(); /*printf("g_performtest.d_tm_send = %ul\n", g_performtest.d_tm_send);*/ if(0 == res) perform_count++; else g_performtest.d_send_fault++; /*printf("send =%d;res =%d \n",perform_count,res);*/ } performtest_timeReset(); performtest_setSysState(SYS_APPLICATIONRECV); while(1) { if(perform_count == 0) { //printf("break\n"); performtest_printf(&g_performtest); break; } #ifdef WILDDOG_PORT_TYPE_WICED wiced_rtos_delay_milliseconds(g_performtest.d_tm_trysync_delay); #else #if defined WILDDOG_PORT_TYPE_ESP os_delay_us(1000 * g_performtest.d_tm_trysync_delay); #else usleep(g_performtest.d_tm_trysync_delay); #endif #endif wilddog_increaseTime(g_performtest.d_tm_trysync_delay); wilddog_trySync(); } wilddog_destroy(&wilddog); return; }
wiced_result_t bluetooth_wiced_init_platform( void ) { if ( wiced_bt_control_pins[ WICED_BT_PIN_HOST_WAKE ] != NULL ) { RETURN_IF_FAILURE( platform_gpio_init( wiced_bt_control_pins[WICED_BT_PIN_HOST_WAKE], INPUT_HIGH_IMPEDANCE ) ); } if ( wiced_bt_control_pins[ WICED_BT_PIN_DEVICE_WAKE ] != NULL ) { RETURN_IF_FAILURE( platform_gpio_init( wiced_bt_control_pins[ WICED_BT_PIN_DEVICE_WAKE ], OUTPUT_PUSH_PULL ) ); RETURN_IF_FAILURE( platform_gpio_output_low( wiced_bt_control_pins[ WICED_BT_PIN_DEVICE_WAKE ] ) ); wiced_rtos_delay_milliseconds( 100 ); } /* Configure Reg Enable pin to output. Set to HIGH */ if ( wiced_bt_control_pins[ WICED_BT_PIN_POWER ] != NULL ) { RETURN_IF_FAILURE( platform_gpio_init( wiced_bt_control_pins[ WICED_BT_PIN_POWER ], OUTPUT_OPEN_DRAIN_PULL_UP ) ); RETURN_IF_FAILURE( platform_gpio_output_high( wiced_bt_control_pins[ WICED_BT_PIN_POWER ] ) ); } if ( wiced_bt_uart_config.flow_control == FLOW_CONTROL_DISABLED ) { /* Configure RTS pin to output. Set to HIGH */ RETURN_IF_FAILURE( platform_gpio_init( wiced_bt_uart_pins[WICED_BT_PIN_UART_RTS], OUTPUT_OPEN_DRAIN_PULL_UP ) ); RETURN_IF_FAILURE( platform_gpio_output_high( wiced_bt_uart_pins[WICED_BT_PIN_UART_RTS] ) ); /* Configure CTS pin to input pull-up */ RETURN_IF_FAILURE( platform_gpio_init( wiced_bt_uart_pins[WICED_BT_PIN_UART_CTS], INPUT_PULL_UP ) ); } if ( wiced_bt_control_pins[ WICED_BT_PIN_RESET ] != NULL ) { RETURN_IF_FAILURE( platform_gpio_init( wiced_bt_control_pins[ WICED_BT_PIN_RESET ], OUTPUT_PUSH_PULL ) ); RETURN_IF_FAILURE( platform_gpio_output_high( wiced_bt_control_pins[ WICED_BT_PIN_RESET ] ) ); /* Configure USART comms */ RETURN_IF_FAILURE( bluetooth_wiced_init_config_uart( &wiced_bt_uart_config ) ); /* Reset bluetooth chip */ RETURN_IF_FAILURE( platform_gpio_output_low( wiced_bt_control_pins[ WICED_BT_PIN_RESET ] ) ); wiced_rtos_delay_milliseconds( 10 ); RETURN_IF_FAILURE( platform_gpio_output_high( wiced_bt_control_pins[ WICED_BT_PIN_RESET ] ) ); } else { /* Configure USART comms */ RETURN_IF_FAILURE( bluetooth_wiced_init_config_uart( &wiced_bt_uart_config ) ); } wiced_rtos_delay_milliseconds( BLUETOOTH_CHIP_STABILIZATION_DELAY ); if ( wiced_bt_uart_config.flow_control == FLOW_CONTROL_DISABLED ) { /* Bluetooth chip is ready. Pull host's RTS low */ RETURN_IF_FAILURE( platform_gpio_output_low( wiced_bt_uart_pins[WICED_BT_PIN_UART_RTS] ) ); } /* Wait for Bluetooth chip to pull its RTS (host's CTS) low. From observation using CRO, it takes the bluetooth chip > 170ms to pull its RTS low after CTS low */ while ( platform_gpio_input_get( wiced_bt_uart_pins[ WICED_BT_PIN_UART_CTS ] ) == WICED_TRUE ) { wiced_rtos_delay_milliseconds( 10 ); } return WICED_SUCCESS; }
void performtest_handle( u32 delay_tm,u8 tree_num, u8 request_num) { u8 m = 0; Wilddog_T wilddog = 0; u8 url[64]={0}; sprintf((char*)url, "coaps://c_test.wilddogio.com/performtest/tree_%d", tree2len[tree_num]); performtest_init(delay_tm,tree_num,request_num); performtest_setSysState(SYS_HSK); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { return; } perform_count = 0; performtest_setSysState(SYS_AUTHRECV); performtest_star_tm(); while(1) { wilddog_trySync(); if(SYS_ISIN(SYS_APPLICATIONSENDING)) break; } performtest_star_tm(); for(m=0; m < request_num; m++) { performtest_star_tm(); /*printf("g_performtest.d_tm_star = %ul\n", g_performtest.d_tm_star);*/ int res = wilddog_getValue(wilddog, test_onQueryFunc, NULL); performtest_tm_getSend(); /*printf("g_performtest.d_tm_send = %ul\n", g_performtest.d_tm_send);*/ if(0 == res) perform_count++; else g_performtest.d_send_fault++; /*printf("send =%d;res =%d \n",perform_count,res);*/ } performtest_star_tm(); performtest_setSysState(SYS_APPLICATIONRECV); while(1) { if(perform_count == 0) { //printf("break\n"); performtest_printf(&g_performtest); break; } #ifdef WILDDOG_PORT_TYPE_WICED wiced_rtos_delay_milliseconds(g_performtest.d_tm_trysync_delay); #else usleep(g_performtest.d_tm_trysync_delay); #endif wilddog_increaseTime(g_performtest.d_tm_trysync_delay); wilddog_trySync(); } wilddog_destroy(&wilddog); return; }
/****************************************************** * Function Definitions ******************************************************/ void application_start( void ) { wiced_result_t ret = WICED_SUCCESS; uint32_t connection_retries = 0; uint32_t retries = 0; ret = aws_app_init( &app_info ); wiced_gpio_input_irq_enable( WICED_BUTTON1, IRQ_TRIGGER_RISING_EDGE, publish_callback, NULL ); do { ret = aws_mqtt_conn_open( app_info.mqtt_object, mqtt_connection_event_cb ); connection_retries++ ; } while ( ( ret != WICED_SUCCESS ) && ( connection_retries < WICED_MQTT_CONNECTION_NUMBER_OF_RETRIES ) ); aws_mqtt_app_publish( app_info.mqtt_object, WICED_MQTT_QOS_DELIVER_AT_LEAST_ONCE, (uint8_t*) app_info.shadow_state_topic, (uint8_t*) SHADOW_PUBLISH_MESSAGE_STR_OFF_DESIRED_AND_REPORTED, sizeof( SHADOW_PUBLISH_MESSAGE_STR_OFF_DESIRED_AND_REPORTED ) ); wiced_rtos_delay_milliseconds( MQTT_DELAY_IN_MILLISECONDS * 2 ); aws_mqtt_app_subscribe( app_info.mqtt_object, app_info.shadow_delta_topic, WICED_MQTT_QOS_DELIVER_AT_LEAST_ONCE ); do { ret = aws_mqtt_app_subscribe( app_info.mqtt_object, app_info.thing_name, WICED_MQTT_QOS_DELIVER_AT_MOST_ONCE ); retries++ ; } while ( ( ret != WICED_SUCCESS ) && ( retries < WICED_MQTT_SUBSCRIBE_RETRY_COUNT ) ); if ( ret != WICED_SUCCESS ) { return; } while ( 1 ) { /* Wait forever on wake semaphore until the LED status is changed */ wiced_rtos_get_semaphore( &app_info.wake_semaphore, WICED_NEVER_TIMEOUT ); /* Toggle the LED */ if ( ( strncasecmp( led_status, "OFF", 3 ) == 0 ) && smart_control == 1 ) { wiced_gpio_output_low( WICED_LED1 ); led_status = "OFF"; WPRINT_APP_INFO(("[MQTT] Publishing to Thing state topic\n")); aws_mqtt_app_publish( app_info.mqtt_object, WICED_MQTT_QOS_DELIVER_AT_LEAST_ONCE, (uint8_t*) app_info.shadow_state_topic, (uint8_t*) SHADOW_PUBLISH_MESSAGE_STR_OFF_DESIRED_AND_REPORTED_STATUS_ON, sizeof( SHADOW_PUBLISH_MESSAGE_STR_OFF_DESIRED_AND_REPORTED_STATUS_ON ) ); } else if ( ( strncasecmp( led_status, "ON", 2 ) == 0 ) && smart_control == 0 ) { wiced_gpio_output_high( WICED_LED1 ); led_status = "ON"; WPRINT_APP_INFO(("[MQTT] Publishing to Thing state topic\n")); aws_mqtt_app_publish( app_info.mqtt_object, WICED_MQTT_QOS_DELIVER_AT_LEAST_ONCE, (uint8_t*) app_info.shadow_state_topic, (uint8_t*) SHADOW_PUBLISH_MESSAGE_STR_ON_DESIRED_AND_REPORTED_STATUS_OFF, sizeof( SHADOW_PUBLISH_MESSAGE_STR_ON_DESIRED_AND_REPORTED_STATUS_OFF ) ); } else if ( ( strncasecmp( led_status, "ON", 2 ) == 0 ) && smart_control == 1 ) { wiced_gpio_output_high( WICED_LED1 ); led_status = "ON"; WPRINT_APP_INFO(("[MQTT] Publishing to Thing state topic\n")); aws_mqtt_app_publish( app_info.mqtt_object, WICED_MQTT_QOS_DELIVER_AT_LEAST_ONCE, (uint8_t*) app_info.shadow_state_topic, (uint8_t*) SHADOW_PUBLISH_MESSAGE_STR_ON_DESIRED_AND_REPORTED, sizeof( SHADOW_PUBLISH_MESSAGE_STR_ON_DESIRED_AND_REPORTED ) ); } else { wiced_gpio_output_low( WICED_LED1 ); led_status = "OFF"; WPRINT_APP_INFO(("[MQTT] Publishing to Thing state topic\n")); aws_mqtt_app_publish( app_info.mqtt_object, WICED_MQTT_QOS_DELIVER_AT_LEAST_ONCE, (uint8_t*) app_info.shadow_state_topic, (uint8_t*) SHADOW_PUBLISH_MESSAGE_STR_OFF_DESIRED_AND_REPORTED, sizeof( SHADOW_PUBLISH_MESSAGE_STR_OFF_DESIRED_AND_REPORTED ) ); } } aws_mqtt_conn_close( app_info.mqtt_object ); wiced_rtos_deinit_semaphore( &app_info.msg_semaphore ); ret = wiced_mqtt_deinit( app_info.mqtt_object ); wiced_rtos_deinit_semaphore( &app_info.wake_semaphore ); free( app_info.mqtt_object ); app_info.mqtt_object = NULL; return; }
void platform_sleep(int ms) { wiced_rtos_delay_milliseconds(ms); }
void application_start( ) { int i; wiced_result_t status; wiced_mac_t my_mac_address; uint32_t my_ip_address; wiced_ip_address_t ipv4_address; wiced_keep_alive_packet_t keep_alive_packet_info; /* Initialize the device */ wiced_init( ); /* Bring up the network on the STA interface */ wiced_network_up( WICED_STA_INTERFACE, WICED_USE_EXTERNAL_DHCP_SERVER, NULL ); /* Setup the ARP keep alive packet to copy in my MAC & IP address */ wiced_wifi_get_mac_address( &my_mac_address ); wiced_ip_get_ipv4_address( WICED_STA_INTERFACE, &ipv4_address ); my_ip_address = htonl( GET_IPV4_ADDRESS(ipv4_address) ); memcpy( &arp_packet[ 6 ], &my_mac_address, 6 ); memcpy( &arp_packet[ 22 ], &my_mac_address, 6 ); memcpy( &arp_packet[ 28 ], &my_ip_address, 4 ); memcpy( &arp_packet[ 38 ], &my_ip_address, 4 ); /* Turn off print buffers, so print output occurs immediately */ setvbuf( stdout, NULL, _IONBF, 0 ); /* Setup a Null function data frame keep alive */ keep_alive_packet_info.keep_alive_id = KEEP_ALIVE_ID_NFD, keep_alive_packet_info.period_msec = KEEP_ALIVE_PERIOD_NFD_MSEC, keep_alive_packet_info.packet_length = 0; status = wiced_wifi_add_keep_alive( &keep_alive_packet_info ); switch ( status ) { case WICED_SUCCESS: { WPRINT_APP_INFO( ( "\r\nAdded:\n") ); WPRINT_APP_INFO( ( " - Null Function Data frame with repeat period of %d milliseconds \n", KEEP_ALIVE_PERIOD_NFD_MSEC ) ); break; } case WICED_TIMEOUT: { WPRINT_APP_INFO( ( "Timeout: Adding Null Function Data frame keep alive packet\n" ) ); break; } default: WPRINT_APP_INFO( ( "Error[%d]: Adding Null Function Data frame keep alive packet\n", status ) ); break; } /* Setup an ARP packet keep alive */ keep_alive_packet_info.keep_alive_id = KEEP_ALIVE_ID_ARP, keep_alive_packet_info.period_msec = KEEP_ALIVE_PERIOD_ARP_MSEC, keep_alive_packet_info.packet_length = sizeof(arp_packet)-1; keep_alive_packet_info.packet = (uint8_t*)arp_packet; status = wiced_wifi_add_keep_alive( &keep_alive_packet_info ); switch ( status ) { case WICED_SUCCESS: { WPRINT_APP_INFO( ( " - ARP packet with repeat period of %d milliseconds\n\n", KEEP_ALIVE_PERIOD_ARP_MSEC ) ); break; } case WICED_TIMEOUT: { WPRINT_APP_INFO( ( "Timeout: Adding ARP packet\n\n" ) ); break; } default: WPRINT_APP_INFO( ( "Error[%d]: Adding ARP packet\n\n", status ) ); break; } /* Get Null Function Data Frame keep alive packet info */ keep_alive_packet_info.keep_alive_id = KEEP_ALIVE_ID_NFD; keep_alive_packet_info.packet_length = MAX_KEEP_ALIVE_PACKET_SIZE; keep_alive_packet_info.packet = &keep_alive_packet_buffer[0]; status = wiced_wifi_get_keep_alive( &keep_alive_packet_info ); if ( status == WICED_SUCCESS ) { print_keep_alive_info( &keep_alive_packet_info ); } else { WPRINT_APP_INFO( ( "ERROR[%d]: Get keep alive packet failed for ID:%d\n", status, KEEP_ALIVE_ID_NFD) ); } /* Get ARP keep alive packet info */ keep_alive_packet_info.keep_alive_id = KEEP_ALIVE_ID_ARP; keep_alive_packet_info.packet_length = MAX_KEEP_ALIVE_PACKET_SIZE; keep_alive_packet_info.packet = &keep_alive_packet_buffer[0]; status = wiced_wifi_get_keep_alive( &keep_alive_packet_info ); if ( status == WICED_SUCCESS ) { print_keep_alive_info( &keep_alive_packet_info ); } else { WPRINT_APP_INFO( ( "ERROR[%d]: Get keep alive packet failed for ID:%d\n", status, KEEP_ALIVE_ID_ARP) ); } /* Wait 30 seconds, then disable all keep alive packets */ WPRINT_APP_INFO( ( "Sending keep alive packets " ) ); for ( i = 0; i < 30; i++ ) { WPRINT_APP_INFO( ( "." ) ); wiced_rtos_delay_milliseconds( 1000 ); } WPRINT_APP_INFO( ( " done\n\n" ) ); /* Disable Null Function Data Frame keep alive packet*/ status = wiced_wifi_disable_keep_alive( KEEP_ALIVE_ID_NFD ); if ( status == WICED_SUCCESS ) { WPRINT_APP_INFO( ( "Null Function data frame keep alive packet disabled\n" ) ); } else { WPRINT_APP_INFO( ( "ERROR[%d]: Failed to disable NFD keep alive packet\n", status) ); } /* Disable ARP keep alive packet*/ status = wiced_wifi_disable_keep_alive( KEEP_ALIVE_ID_ARP ); if ( status == WICED_SUCCESS ) { WPRINT_APP_INFO( ( "ARP keep alive packet disabled\n" ) ); } else { WPRINT_APP_INFO( ( "ERROR[%d]: Failed to disable ARP keep alive packet\n", status) ); } WPRINT_APP_INFO( ( "\r\nStop.\n") ); while ( 1 ) { } }
void application_start(void) { const your_security_t your_security_type = YOUR_SECURITY_WEP40_PSK; platform_dct_wifi_config_t* wifi_config_dct_local; /* Initialise the WICED device */ wiced_init(); /* Configure security for the device and join the AP */ if ( set_wifi_security( your_security_type ) != WICED_SUCCESS ) { WPRINT_APP_INFO( ( "Failed to update DCT with security type\r\n" ) ); return; } /* Try join the network */ if ( wiced_network_up( WICED_STA_INTERFACE, WICED_USE_EXTERNAL_DHCP_SERVER, NULL ) != WICED_SUCCESS ) { /* Check if we were using WEP. It is not possible to tell WEP Open from WEP Shared in a scan so we try Open first and Shared second */ if ( your_security_type == YOUR_SECURITY_WEP40_PSK || your_security_type == YOUR_SECURITY_WEP104_PSK ) { WPRINT_APP_INFO( ("WEP with open authentication failed, trying WEP with shared authentication...\r\n") ); /* Modify the Wi-Fi config to use Shared WEP */ wiced_dct_read_lock( (void**) &wifi_config_dct_local, WICED_TRUE, DCT_WIFI_CONFIG_SECTION, 0, sizeof( platform_dct_wifi_config_t ) ); wifi_config_dct_local->stored_ap_list[0].details.security = WICED_SECURITY_WEP_SHARED; wiced_dct_write ( (const void*)wifi_config_dct_local, DCT_WIFI_CONFIG_SECTION, 0, sizeof (platform_dct_wifi_config_t) ); wiced_dct_read_unlock( (void*)wifi_config_dct_local, WICED_TRUE ); /* Try join the network again */ if ( wiced_network_up( WICED_STA_INTERFACE, WICED_USE_EXTERNAL_DHCP_SERVER, NULL ) != WICED_SUCCESS ) { WPRINT_APP_INFO( ("WEP with Shared authentication failed as well\r\n") ); /* Restore the Wi-Fi config back to the default Open WEP */ wiced_dct_read_lock( (void**) &wifi_config_dct_local, WICED_TRUE, DCT_WIFI_CONFIG_SECTION, 0, sizeof( platform_dct_wifi_config_t ) ); wifi_config_dct_local->stored_ap_list[0].details.security = WICED_SECURITY_WEP_PSK; wiced_dct_write ( (const void*)wifi_config_dct_local, DCT_WIFI_CONFIG_SECTION, 0, sizeof (platform_dct_wifi_config_t) ); wiced_dct_read_unlock( (void*)wifi_config_dct_local, WICED_TRUE ); /* Nothing more we can do.. Give up */ WPRINT_APP_INFO(( "Unable to join AP\r\n" )); return; } } else { WPRINT_APP_INFO(( "Unable to join AP\r\n" )); return; } } while (1) { /* Send an ICMP ping to the gateway */ send_ping( ); /* Wait between pings */ wiced_rtos_delay_milliseconds( PING_INTERVAL ); } }
/******************************************************************************* * Function Name : Delay * Description : Inserts a delay time. * Input : nTime: specifies the delay time length, in milliseconds. * Output : None * Return : None *******************************************************************************/ void HAL_Delay_Milliseconds(uint32_t nTime) { wiced_rtos_delay_milliseconds(nTime); }
static void ota_server_thread_main(uint32_t arg) { ota_server_t* server = (ota_server_t*) arg; uint32_t total_body_size = 0; int i = 0; server->reboot_required = WICED_FALSE; while ( server->quit != WICED_TRUE ) { wiced_packet_t* temp_packet = NULL; /* Wait for a connection */ wiced_result_t result = wiced_tcp_accept( &server->socket ); if ( result == WICED_SUCCESS ) { for(;;) { if ( wiced_tcp_receive( &server->socket, &temp_packet, WICED_WAIT_FOREVER ) == WICED_SUCCESS ) { char* request_string; uint16_t request_length; uint16_t available_data_length; if( server->state == READING_HEADER ) { uint8_t temp = 0; wiced_result_t result = WICED_ERROR; if ( temp_packet == NULL ) { goto disconnect; } init_request(server); server->request.request_packets[server->request.current_packet_index] = temp_packet; wiced_packet_get_data(temp_packet, 0, (uint8_t**)&request_string, &request_length, &available_data_length); /* Check that this is a GET or POST request, abort everything else */ if ( ( strstr( request_string, "GET" ) == 0 ) && ( strstr( request_string, "POST") == 0 ) ) { result = WICED_ERROR; wiced_packet_delete(temp_packet); goto disconnect; } /* Get header pointer and header size */ server->request.header_ptr = (uint8_t*)request_string; server->request.header_size = ( (char*)strstr( (char*)request_string, crlfcrlf ) + strlen( crlfcrlf ) ) - (char*)request_string; if( server->request.header_size == strlen( crlfcrlf ) ) { goto disconnect; } /* Get content length */ server->request.content_length = 0; if( strstr( request_string, "Content-Length") != NULL ) { uint8_t* content_length_value = (uint8_t*)strstr( request_string, "Content-Length") + strlen("Content-Length:"); server->request.content_length = atoi((const char*)content_length_value); } temp = request_string[ server->request.header_size ]; request_string[ server->request.header_size ] ='\0'; request_string[ server->request.header_size ] = temp; /* Get request type and the url */ result = get_http_request_type_and_url( (uint8_t*)request_string, request_length, &server->request); if ( result == WICED_ERROR ) { goto disconnect; } server->state = READING_BODY; } if( server->state == READING_BODY ) { http_body_chunk_t* current_body_chunk = &server->request.body_chunks[server->request.current_packet_index]; if( server->request.current_packet_index != 0 ) { server->request.request_packets[server->request.current_packet_index] = temp_packet; } wiced_packet_get_data(temp_packet, 0, (uint8_t**)&request_string, &request_length, &available_data_length); if( server->request.current_packet_index == 0 ) { current_body_chunk->data = server->request.header_ptr + server->request.header_size; current_body_chunk->size = ( request_string + request_length ) - (char*)current_body_chunk->data; } else { current_body_chunk->data = (uint8_t*)request_string; current_body_chunk->size = request_length; } /* calculate total combined size of all body chunks which belongs to this message */ total_body_size = 0; for( i = 0; i < ( server->request.current_packet_index + 1 ) ; i++ ) { total_body_size+= server->request.body_chunks[i].size; } server->request.current_packet_index++; /* Check whether the combined size of the previous chunks and the current one is equal to the content length received in the first packet */ if( total_body_size == server->request.content_length ) { ota_server_process_request( server, &server->socket ); /* Delete all packets belonging to the message */ for( i = 0; i < server->request.current_packet_index; i++ ) { wiced_packet_delete(server->request.request_packets[i]); } server->state = READING_HEADER; break; } } } else { goto disconnect; } } } disconnect: wiced_tcp_disconnect( &server->socket ); } wiced_tcp_delete_socket( &server->socket ); if( server->reboot_required == WICED_TRUE ) { /* Give some for the response to be sent properly */ wiced_rtos_delay_milliseconds(2000); /* Perform a reboot!!! */ wiced_framework_reboot(); } WICED_END_OF_CURRENT_THREAD( ); }
/* * Main application */ void application_start( void ) { char *msg = MSG_OFF; wiced_result_t ret = WICED_SUCCESS; int retries; uint16_t light_value; ret = aws_app_init(&app_info); /* Initialise Light sensor */ WPRINT_APP_INFO( ("Initializing Light Sensor\n" )); wiced_adc_init( WICED_LIGHT, 5 ); do { ret = aws_mqtt_conn_open( app_info.mqtt_object, mqtt_connection_event_cb ); if ( ret != WICED_SUCCESS ) { WPRINT_APP_INFO(("Failed\n")); break; } while ( 1 ) { /* Read light sensor */ wiced_adc_take_sample( WICED_LIGHT, &light_value ); WPRINT_APP_INFO( ("Light value %u\n", light_value) ); if ( light_value >= LIGHT_THRESHOLD ) { msg = MSG_ON; } else { msg = MSG_OFF; } /* Controlling the LED by publishing to mqtt topic "WICED_BULB" */ retries = 0; do { ret = aws_mqtt_app_publish( app_info.mqtt_object, WICED_MQTT_QOS_DELIVER_AT_LEAST_ONCE, (uint8_t*) app_info.thing_name, (uint8_t*) msg, strlen( msg ) ); retries++ ; } while ( ( ret != WICED_SUCCESS ) && ( retries < MQTT_PUBLISH_RETRY_COUNT ) ); if ( ret != WICED_SUCCESS ) { break; } wiced_rtos_delay_milliseconds( 5000 ); } aws_mqtt_conn_close( app_info.mqtt_object ); wiced_rtos_delay_milliseconds( MQTT_DELAY_IN_MILLISECONDS * 2 ); } while ( 1 ); aws_mqtt_conn_close( app_info.mqtt_object ); wiced_rtos_deinit_semaphore( &app_info.msg_semaphore ); WPRINT_APP_INFO(("[MQTT] Deinit connection...\n")); ret = wiced_mqtt_deinit( app_info.mqtt_object ); free( app_info.mqtt_object ); app_info.mqtt_object = NULL; return; }