// 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;
}
