void application_start( ) { wiced_ip_address_t ip_address; wiced_result_t result; wiced_init( ); wiced_network_up(WICED_STA_INTERFACE, WICED_USE_EXTERNAL_DHCP_SERVER, NULL); /* Configure the device */ /* wiced_configure_device( app_config ); */ /* Config bypassed in local makefile and wifi_config_dct.h */ WPRINT_APP_INFO( ( "Resolving IP address of HTTPS server\n" ) ); wiced_hostname_lookup("www.google.com", &ip_address, 10000); WPRINT_APP_INFO( ( "Server is at %u.%u.%u.%u\n", (uint8_t)(GET_IPV4_ADDRESS(ip_address) >> 24), (uint8_t)(GET_IPV4_ADDRESS(ip_address) >> 16), (uint8_t)(GET_IPV4_ADDRESS(ip_address) >> 8), (uint8_t)(GET_IPV4_ADDRESS(ip_address) >> 0) ) ); WPRINT_APP_INFO( ( "Getting '/'...\n" ) ); /* Initialize the root CA certificate */ wiced_tls_init_root_ca_certificates( google_root_ca_certificate ); result = wiced_https_get( &ip_address, SIMPLE_GET_REQUEST, buffer, BUFFER_LENGTH, "www.google.com" ); if ( result == WICED_SUCCESS ) { WPRINT_APP_INFO( ( "Server returned\n%s", buffer ) ); } else { WPRINT_APP_INFO( ( "Get failed: %u\n", result ) ); } wiced_deinit(); }
// 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 ); } }
/* * A simple result log function */ static void amqp_print_status ( wiced_result_t result, const char * ok_message, const char * error_message ) { if ( result == WICED_SUCCESS ) { if ( ok_message != NULL ) { WPRINT_APP_INFO(( "OK (%s)\n\n", (ok_message))); } else { WPRINT_APP_INFO(( "OK.\n\n" )); } } else { if ( error_message != NULL ) { WPRINT_APP_INFO(( "ERROR (%s)\n\n", (error_message))); } else { WPRINT_APP_INFO(( "ERROR.\n\n" )); } } }
static wiced_result_t send_ping( void ) { const uint32_t ping_timeout = 1000; uint32_t elapsed_ms; wiced_result_t status; wiced_ip_address_t ping_target_ip; wiced_ip_get_gateway_address( WICED_STA_INTERFACE, &ping_target_ip ); status = wiced_ping( WICED_STA_INTERFACE, &ping_target_ip, ping_timeout, &elapsed_ms ); if ( status == WICED_SUCCESS ) { WPRINT_APP_INFO(( "Ping Reply %lums\r\n", elapsed_ms )); } else if ( status == WICED_TIMEOUT ) { WPRINT_APP_INFO(( "Ping timeout\r\n" )); } else { WPRINT_APP_INFO(( "Ping error\r\n" )); } return WICED_SUCCESS; }
void application_start(void) { /* Initialise the device and WICED framework */ wiced_init( ); /* Bring up the network interface */ wiced_network_up( WICED_STA_INTERFACE, WICED_USE_EXTERNAL_DHCP_SERVER, NULL ); /* Create a TCP server socket */ if (wiced_tcp_create_socket(&tcp_server_handle.socket, WICED_STA_INTERFACE) != WICED_SUCCESS) { WPRINT_APP_INFO(("TCP socket creation failed\n")); } if (wiced_tcp_listen( &tcp_server_handle.socket, TCP_SERVER_LISTEN_PORT ) != WICED_SUCCESS) { WPRINT_APP_INFO(("TCP server socket initialization failed\n")); wiced_tcp_delete_socket(&tcp_server_handle.socket); return; } /* Start a tcp server thread */ WPRINT_APP_INFO(("Creating tcp server thread \n")); wiced_rtos_create_thread(&tcp_thread, TCP_SERVER_THREAD_PRIORITY, "Demo tcp server", tcp_server_thread_main, TCP_SERVER_STACK_SIZE, &tcp_server_handle); }
static void audio_state_handler( wiced_bt_avk_audio_state_t state, wiced_bt_bdaddr_t* device_address ) { switch ( state ) { case WICED_BT_AVK_AUDIO_STATE_STARTED: WPRINT_APP_INFO( ("Audio streaming started\n") ); break; case WICED_BT_AVK_AUDIO_STATE_REMOTE_SUSPEND: WPRINT_APP_INFO( ("Audio streaming suspended\n") ); break; case WICED_BT_AVK_AUDIO_STATE_STOPPED: WPRINT_APP_INFO( ("Audio streaming stopped\n") ); break; default: break; } }
/*! ****************************************************************************** * Prints partial details of a scan result on a single line * * @param[in] record A pointer to the wiced_scan_result_t record * */ void print_scan_result( wiced_scan_result_t* record ) { WPRINT_APP_INFO( ( "%5s ", ( record->bss_type == WICED_BSS_TYPE_ADHOC ) ? "Adhoc" : "Infra" ) ); WPRINT_APP_INFO( ( "%02X:%02X:%02X:%02X:%02X:%02X ", record->BSSID.octet[0], record->BSSID.octet[1], record->BSSID.octet[2], record->BSSID.octet[3], record->BSSID.octet[4], record->BSSID.octet[5] ) ); WPRINT_APP_INFO( ( " %d ", record->signal_strength ) ); if ( record->max_data_rate < 100000 ) { WPRINT_APP_INFO( ( " %.1f ", (double) (record->max_data_rate / 1000.0) ) ); } else { WPRINT_APP_INFO( ( "%.1f ", (double) (record->max_data_rate / 1000.0) ) ); } WPRINT_APP_INFO( ( " %3d ", record->channel ) ); WPRINT_APP_INFO( ( "%-10s ", ( record->security == WICED_SECURITY_OPEN ) ? "Open" : ( record->security == WICED_SECURITY_WEP_PSK ) ? "WEP" : ( record->security == WICED_SECURITY_WPA_TKIP_PSK ) ? "WPA TKIP" : ( record->security == WICED_SECURITY_WPA_AES_PSK ) ? "WPA AES" : ( record->security == WICED_SECURITY_WPA2_AES_PSK ) ? "WPA2 AES" : ( record->security == WICED_SECURITY_WPA2_TKIP_PSK ) ? "WPA2 TKIP" : ( record->security == WICED_SECURITY_WPA2_MIXED_PSK ) ? "WPA2 Mixed" : "Unknown" ) ); WPRINT_APP_INFO( ( " %-32s ", record->SSID.value ) ); WPRINT_APP_INFO( ( "\n" ) ); }
// This function formats all of the data and prints it out ... called by the tcp_server static void displayResult(wiced_ip_address_t peerAddress, uint16_t peerPort, char *returnMessage) { WPRINT_APP_INFO(("%d\t",nonsecureConnectionCount)); WPRINT_APP_INFO(("%u.%u.%u.%u", (uint8_t)(GET_IPV4_ADDRESS(peerAddress) >> 24), (uint8_t)(GET_IPV4_ADDRESS(peerAddress) >> 16), (uint8_t)(GET_IPV4_ADDRESS(peerAddress) >> 8), (uint8_t)(GET_IPV4_ADDRESS(peerAddress) >> 0) )); WPRINT_APP_INFO(("\t%d\t%s\n",peerPort,returnMessage)); }
int rwl_write_eth_port(void* hndle, char* write_buf, unsigned long size, unsigned long *numwritten) { uint16_t available_data_length; wiced_packet_t* tx_packet; char* tx_data; unsigned long temp_size = 0; unsigned long temp=0; if ( size == 0 ) { return SUCCESS; } while (size > 0) { if (wiced_packet_create_tcp(&tcp_client_socket, 128, &tx_packet, (uint8_t **)&tx_data, &available_data_length) != WICED_SUCCESS) { WPRINT_APP_INFO(("TCP packet creation failed\n")); return WICED_ERROR; } if (size > available_data_length) { temp_size = available_data_length; } else { temp_size =size; } /* Write the message into tx_data"*/ memcpy(tx_data, (write_buf + temp), temp_size); wiced_packet_set_data_end( tx_packet, (uint8_t*)tx_data + temp_size ); /* Send the TCP packet*/ if ( wiced_tcp_send_packet( &tcp_client_socket, tx_packet ) != WICED_SUCCESS ) { WPRINT_APP_INFO(("TCP packet send failed \n")); /*Delete packet, since the send failed*/ wiced_packet_delete(tx_packet); return WICED_ERROR; } wiced_packet_delete(tx_packet); size = size - temp_size; temp = temp+temp_size; } return available_data_length; }
/* This is the callback event for HTTP events */ static void event_handler( http_client_t* client, http_event_t event, http_response_t* response ) { static uint8_t count = 1; // Keep track of how many responses we have received switch( event ) { case HTTP_CONNECTED: /* This state is never called */ break; /* This is called when we are disconnected by the server */ case HTTP_DISCONNECTED: { connected = WICED_FALSE; http_client_disconnect( client ); /* Need to keep client connection state synchronized with the server */ WPRINT_APP_INFO(( "Disconnected from %s\n", SERVER_HOST )); break; } /* This is called when new data is received (header, or payload) */ case HTTP_DATA_RECEIVED: { WPRINT_APP_INFO( ( "------------------ Received response: %d ------------------\n", count ) ); /* Print Response Header */ if(response->response_hdr != NULL) { WPRINT_APP_INFO( ( "----- Response Header: -----\n " ) ); print_data( (char*) response->response_hdr, response->response_hdr_length ); } /* Print Response Payload */ WPRINT_APP_INFO( ("\n----- Response Payload: -----\n" ) ); print_data( (char*) response->payload, response->payload_data_length ); if(response->remaining_length == 0) { WPRINT_APP_INFO( ("\n------------------ End Response %d ------------------\n", count ) ); http_request_deinit( (http_request_t*) &(response->request) ); wiced_rtos_set_semaphore(&httpWait); // Set semaphore that allows the next request to start count++; } break; } default: break; } }
static void audio_connection_state_handler( wiced_bt_avk_connection_state_t state, wiced_bt_bdaddr_t* device_address ) { switch ( state ) { case WICED_BT_AVK_CONNECTION_STATE_CONNECTED: WPRINT_APP_INFO( ("Device connected [0x%x:0x%x:0x%x:0x%x:0x%x:0x%x]\n", device_address->address[0], device_address->address[1], device_address->address[2], device_address->address[3], device_address->address[4], device_address->address[5]) ); break; case WICED_BT_AVK_CONNECTION_STATE_DISCONNECTED: WPRINT_APP_INFO( ("Device disconnected\n") ); break; default: 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 ); } }
static void curtain_keypad_handler( uart_key_code_t code, uart_key_event_t event ) { //WPRINT_APP_INFO(("curtain_keypad_handler: key_code = 0x%.2x, key_event = %d\n", code, event)); if ( event == KEY_EVENT_RELEASED ) { switch ( code ) { case CURTAIN_KEY_OPEN: curtain_open(this_dev.specific.curtain); break; case CURTAIN_KEY_CLOSE: curtain_close(this_dev.specific.curtain); break; case CURTAIN_KEY_STOP: curtain_stop(this_dev.specific.curtain); break; default: break; } } else if( event == KEY_EVENT_LONG_LONG_PRESSED) { WPRINT_APP_INFO(("KEY_EVENT_LONG_LONG_PRESSED\n")); if (code == CURTAIN_KEY_OPEN) { curtain_cali_start(this_dev.specific.curtain); } } return; }
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++; } }
void application_start( ) { WPRINT_APP_INFO( ( "Application stack = %u\r\n", APPLICATION_STACK_SIZE ) ); blow_the_stack(); }
/****************************************************** * Function Definitions ******************************************************/ void application_start( ) { /* Initialise the device */ wiced_init( ); //WPRINT_APP_INFO(("Version data & time 2015/09/06 10:00\n")); /* Configure the device */ configure_device(); if(device_init() != WICED_SUCCESS){ WPRINT_APP_INFO(("device_init failed\n")); return; } WPRINT_APP_INFO(("end ...\n")); }
static void device_state_handler( wiced_bt_state_t state, wiced_result_t status ) { switch ( state ) { case WICED_BT_STATE_ENABLED: WPRINT_APP_INFO( ("Bluetooth enabled\n") ); wiced_bt_avk_init( &app_callbacks.audio_callbacks ); break; case WICED_BT_STATE_DISABLED: WPRINT_APP_INFO( ("Bluetooth disabled\n") ); break; default: break; } }
void printStatus() { linked_list_node_t* current; linked_list_get_front_node( &tcp_server.socket_list, ¤t); while(current) { wiced_tcp_socket_t *socket; wiced_tcp_server_socket_t *serverSocket; serverSocket = (wiced_tcp_server_socket_t *) current->data; socket = &serverSocket->socket; wiced_socket_state_t ss; wiced_tcp_get_socket_state( socket, &ss); switch(ss) { case WICED_SOCKET_CLOSED: WPRINT_APP_INFO(("Status:closed\n")); break; case WICED_SOCKET_CLOSING: WPRINT_APP_INFO(("Status:closing\n")); break; case WICED_SOCKET_CONNECTING: WPRINT_APP_INFO(("Status:connecting\n")); break; case WICED_SOCKET_CONNECTED: WPRINT_APP_INFO(("Status:connected\n")); break; case WICED_SOCKET_DATA_PENDING: WPRINT_APP_INFO(("Status:data pending\n")); break; case WICED_SOCKET_LISTEN: WPRINT_APP_INFO(("Status:listen\n")); break; case WICED_SOCKET_ERROR: WPRINT_APP_INFO(("Status:error\n")); break; } current = current->next; } }
int main( void ) { wiced_mac_t dest_mac = { {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} }; char* payload_ptr = 0; wwd_result_t result; NoOS_setup_timing( ); WPRINT_APP_INFO(("\nPlatform " PLATFORM " initialised\n")); /* Initialise Wiced */ WPRINT_APP_INFO(("Starting Wiced v" WICED_VERSION "\n")); nons_buffer_init_t pkt_buff_init = { pkt_buffer, sizeof( pkt_buffer ) }; while ( WWD_SUCCESS != ( result = wwd_management_init( COUNTRY, &pkt_buff_init ) ) ) { WPRINT_APP_INFO(("Error %d while starting WICED!\n", result)); } /* Get MAC address - this needs to be done before joining a network, so that */ /* we can check the address of any incoming packets against our MAC */ wwd_wifi_get_mac_address( &my_mac, WWD_STA_INTERFACE ); /* Attempt to join the Wi-Fi network */ WPRINT_APP_INFO(("Joining : " AP_SSID "\n")); while ( wwd_wifi_join( &ap_ssid, AP_SEC, (uint8_t*) AP_PASS, sizeof( AP_PASS ) - 1, NULL ) != WWD_SUCCESS ) { WPRINT_APP_INFO(("Failed to join : " AP_SSID " .. retrying\n")); } WPRINT_APP_INFO(("Successfully joined : " AP_SSID "\n")); if ( PKT_TARGET_IP != 0xFFFFFFFF ) /* Check if the target has a broadcast address */ { /* Send an ARP request to resolve the destination IP address into a MAC address */ resolve_dest_mac( PKT_TARGET_IP, &dest_mac ); } /* Loop forever, repeatedly sending the UDP packet */ while ( 1 ) { int i; /* Setup the packet buffer with the canned packet contents. */ payload_ptr = setup_canned_packet( pkt_buffer, sizeof( pkt_buffer ), my_ip_addr, &my_mac, PKT_TARGET_IP, &dest_mac, LOCAL_UDP_PORT, PKT_TARGET_UDP_PORT ); /* Copy the payload into the packet */ memcpy( payload_ptr, PAYLOAD, sizeof( PAYLOAD ) - 1 ); WPRINT_APP_INFO(("Sending Hello!\n")); send_canned_packet( pkt_buffer, sizeof( PAYLOAD ) - 1 ); for ( i = 0; i < 10; i++ ) { host_rtos_delay_milliseconds( 100 ); /* Poll for packets to receive (which will be dropped) - 802.11 device will run out of memory if packets are not read out of it */ while ( wwd_thread_poll_all( ) != 0 ) { } } } }
/****************************************************** * 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; } }
/* Helper function to print data in the response to the UART */ static void print_data( char* data, uint32_t length ) { uint32_t a; for ( a = 0; a < length; a++ ) { WPRINT_APP_INFO( ( "%c", data[a] ) ); } }
static wiced_result_t tcp_server_process( tcp_server_handle_t* server, wiced_packet_t* rx_packet ) { char* request; uint16_t request_length; uint16_t available_data_length; wiced_packet_t* tx_packet; char* tx_data; wiced_packet_get_data( rx_packet, 0, (uint8_t**) &request, &request_length, &available_data_length ); /* Null terminate the received string */ request[request_length] = '\x0'; WPRINT_APP_INFO(("Received data: %s \n", request)); /* Send echo back */ if (wiced_packet_create_tcp(&server->socket, TCP_PACKET_MAX_DATA_LENGTH, &tx_packet, (uint8_t**)&tx_data, &available_data_length) != WICED_SUCCESS) { WPRINT_APP_INFO(("TCP packet creation failed\n")); return WICED_ERROR; } /* Write the message into tx_data" */ tx_data[request_length] = '\x0'; memcpy(tx_data, request, request_length); /* Set the end of the data portion */ wiced_packet_set_data_end(tx_packet, (uint8_t*)tx_data + request_length); /* Send the TCP packet */ if (wiced_tcp_send_packet(&server->socket, tx_packet) != WICED_SUCCESS) { WPRINT_APP_INFO(("TCP packet send failed\n")); /* Delete packet, since the send failed */ wiced_packet_delete(tx_packet); server->quit=WICED_TRUE; return WICED_ERROR; } WPRINT_APP_INFO(("Echo data: %s\n", tx_data)); return WICED_SUCCESS; }
void messageArrived( MessageData* md ) { MQTTMessage* message = md->message; WPRINT_APP_INFO ( ("Message Subscribed %d \r\n", message->payloadlen));WPRINT_APP_INFO ( ("Message dup %x \r\n", message->dup));WPRINT_APP_INFO ( ("Message id %x \r\n", message->id));WPRINT_APP_INFO ( ("Message qos %x \r\n", message->qos));WPRINT_APP_INFO ( ("Message retained %x \r\n", message->retained)); WPRINT_APP_INFO( ( "Topic Name ==> %.*s\t", md->topicName->lenstring.len, md->topicName->lenstring.data ) );WPRINT_APP_INFO( ( "Message ==> %.*s\n", (int)message->payloadlen, (char*)message->payload ) ); if ( strstr( (char*) message->payload, "ON" ) ) { printf( "Turn ON LED\n" ); wiced_gpio_output_high( WICED_LED1 ); } else { if ( strstr( (char*) message->payload, "OFF" ) ) { printf( "Turn OFF LED\n" ); wiced_gpio_output_low( WICED_LED1 ); } } }
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; } } } }
static void publish_callback( void* arg ) { if ( button_pressed == 0 ) { smart_control = button_pressed = 1; } else { smart_control = button_pressed = 0; } WPRINT_APP_INFO (( "button_pressed %d\n", button_pressed )); }
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" ) ); } }
wiced_result_t wiced_wlu_server_eth_start( int tcp_server_port , char** argv) { wiced_result_t result; UNUSED_PARAMETER(argv); wiced_assert("wlu_server already started", (wlu_server.started == WICED_FALSE)); wlu_server.started = WICED_TRUE; wlu_server.eth_started = WICED_TRUE; wlu_server.eth_port = tcp_server_port; // WWD_WLAN_KEEP_AWAKE( ); /* Bring up the network interface */ result = wiced_network_up( WICED_ETHERNET_INTERFACE, WICED_USE_EXTERNAL_DHCP_SERVER, NULL ); if ( result != WICED_SUCCESS ) { WPRINT_APP_INFO(("Failed to connect to Ethernet.\n")); } /* Create a TCP socket */ if ( wiced_tcp_create_socket( &tcp_client_socket, WICED_ETHERNET_INTERFACE ) != WICED_SUCCESS ) { WPRINT_APP_INFO( ("TCP socket creation failed\n") ); } if (wiced_tcp_listen( &tcp_client_socket, tcp_server_port ) != WICED_SUCCESS) { WPRINT_APP_INFO(("TCP server socket initialization failed\n")); wiced_tcp_delete_socket(&tcp_client_socket); return WICED_ERROR; } wiced_rtos_create_thread( &wlu_server.thread, WLU_SERVER_THREAD_PRIORITY, "wlu_eth_server", wlu_server_thread, WLU_SERVER_STACK_SIZE, &wlu_server ); return WICED_SUCCESS; }
/* * Call back function to handle connection events. */ static wiced_result_t wiced_amqp_connection_event_cb( wiced_amqp_event_t event, void *args, wiced_amqp_connection_t *conn ) { switch( event ) { case AMQP_EVENT_CONNECTION_RECV_OPEN_OK: case AMQP_EVENT_CONNECTION_RECV_CLOSE_OK: { expected_event = event; wiced_rtos_set_semaphore( &semaphore ); } break; case AMQP_EVENT_CONNECTION_ERROR: { WPRINT_APP_INFO(("[AMQP] ERROR LOST CONNECTION\n\n")); } break; case AMQP_EVENT_PROTOCOL_RECV_HEADER: { WPRINT_APP_INFO(("[AMQP] ERROR RECEIVED PROTOCOL HEADER.\n")); WPRINT_APP_INFO(("[AMQP] Broker should support AMQP0.9-1.\n\n")); } break; case AMQP_EVENT_CONNECTION_RECV_CLOSE: { wiced_amqp_connection_close_arg_t *close_args = ( wiced_amqp_connection_close_arg_t* )args; /* Data is sent as short string */ memcpy( str, close_args->reply_text.str, close_args->reply_text.len ); str[ close_args->reply_text.len ] = '\0'; WPRINT_APP_INFO(("[AMQP] ERROR RECEIVED BROKER CLOSE REQUEST.\n")); WPRINT_APP_INFO(("[AMQP] REPLY TEXT: %s.\n\n",str)); } break; default: break; } return WICED_SUCCESS; }
static wiced_result_t device_init() { smart_home_app_dct_t* dct_app; wiced_result_t res; if( wiced_dct_read_lock( (void**) &dct_app, WICED_TRUE, DCT_APP_SECTION, 0, sizeof( *dct_app ) ) != WICED_SUCCESS) { return WICED_ERROR; } this_dev.configured = dct_app->device_configured; this_dev.dev_type = dct_app->dev_type; this_dev.dev_index = dct_app->dev_index; strncpy(this_dev.dev_name, dct_app->dev_name, sizeof(this_dev.dev_name)); WPRINT_APP_INFO(("this_dev.dev_name is %s\n", this_dev.dev_name)); wiced_dct_read_unlock( dct_app, WICED_TRUE ); if(this_dev.configured == WICED_FALSE) { return WICED_ERROR; } if(this_dev.dev_type == DEV_TYPE_MASTER) { this_dev.parse_socket_msg_fun = master_parse_socket_msg; uart_receive_enable(master_process_uart_msg); user_receive_enable(); }else if(this_dev.dev_type == DEV_TYPE_LIGHT || this_dev.dev_type == DEV_TYPE_CURTAIN) { if(this_dev.dev_type == DEV_TYPE_LIGHT) { res = light_dev_init(&this_dev.specific.light_dev, WICED_HARDWARE_IO_WORKER_THREAD, report_light_status); if(res != WICED_SUCCESS) { return WICED_ERROR; } this_dev.parse_socket_msg_fun = light_parse_socket_msg; //this_dev.device_keypad_handler = light_keypad_handler; uart_keypad_enable( &device_keypad, WICED_HARDWARE_IO_WORKER_THREAD, light_keypad_handler, 3000); } else if(this_dev.dev_type == DEV_TYPE_CURTAIN) { res = curtain_init(&this_dev.specific.curtain, WICED_HARDWARE_IO_WORKER_THREAD, report_curtain_pos); if( res != WICED_SUCCESS) { return WICED_ERROR; } this_dev.parse_socket_msg_fun = curtain_parse_socket_msg; //this_dev.device_keypad_handler = curtain_keypad_handler; uart_keypad_enable( &device_keypad, WICED_HARDWARE_IO_WORKER_THREAD, curtain_keypad_handler, 3000); } pre_receive_enable(); } next_receive_enable(); return WICED_SUCCESS; }
void application_start( ) { wiced_result_t result; wiced_init( ); platform_init_audio( ); WPRINT_APP_INFO ( ("Starting Bluetooth...\n") ); /* Initialize BT stack and profiles */ result = wiced_bt_init( &app_callbacks.device_manager_callbacks, &audio_preferences ); if ( result != WICED_SUCCESS ) { WPRINT_APP_ERROR( ( "Failed to initialize Bluetooth\n" ) ); } }