TC_ASSERT_GEQ_CLEANUP("open", fd2, 0, close(fd1));
ret = lseek(fd1, 0, SEEK_END);
- TC_ASSERT_EQ_CLEANUP("lseek", ret, size, close(fd1);close(fd2));
+ TC_ASSERT_EQ_CLEANUP("lseek", ret, size, close(fd1); close(fd2));
ret = sendfile(fd2, fd1, NULL, size);
close(fd2);
*/
static void itc_dm_conn_get_address_p(void)
{
- int ret;
- char ipAddr[BUF_SIZE];
- ret = dm_conn_get_address(ipAddr);
- TC_ASSERT_EQ("dm_conn_get_address" , ret , DM_ERROR_NONE);
- printf("itc_dm_conn_get_address_p : %s \n", ipAddr);
- TC_ASSERT_EQ("dm_conn_get_address" , ipAddr[3] , '.');
- TC_SUCCESS_RESULT();
+ int ret;
+ char ipAddr[BUF_SIZE];
+ ret = dm_conn_get_address(ipAddr);
+ TC_ASSERT_EQ("dm_conn_get_address" , ret , DM_ERROR_NONE);
+ printf("itc_dm_conn_get_address_p : %s \n", ipAddr);
+ TC_ASSERT_EQ("dm_conn_get_address" , ipAddr[3] , '.');
+ TC_SUCCESS_RESULT();
}
/**
*/
static void itc_dm_conn_get_channel_p(void)
{
- int ret;
- int val = -1;
- ret = dm_conn_get_channel(&val);
- TC_ASSERT_EQ("dm_conn_get_channel" , ret , DM_ERROR_NONE);
- TC_ASSERT_GEQ("dm_conn_get_channel" , val , 0 );
- TC_SUCCESS_RESULT();
+ int ret;
+ int val = -1;
+ ret = dm_conn_get_channel(&val);
+ TC_ASSERT_EQ("dm_conn_get_channel" , ret , DM_ERROR_NONE);
+ TC_ASSERT_GEQ("dm_conn_get_channel" , val , 0);
+ TC_SUCCESS_RESULT();
}
/**
*/
static void itc_dm_conn_get_interface_p(void)
{
- int ret;
- char interface[BUF_SIZE];
- ret = dm_conn_get_interface(interface);
- TC_ASSERT_EQ("dm_conn_get_interface" , ret , DM_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ int ret;
+ char interface[BUF_SIZE];
+ ret = dm_conn_get_interface(interface);
+ TC_ASSERT_EQ("dm_conn_get_interface" , ret , DM_ERROR_NONE);
+ TC_SUCCESS_RESULT();
}
/**
*/
static void itc_dm_conn_get_rssi_p(void)
{
- int ret;
- int val = -1;
- ret = dm_conn_get_rssi(&val);
- TC_ASSERT_EQ("dm_conn_get_rssi" , ret , DM_ERROR_NONE);
- TC_ASSERT_LEQ("dm_conn_get_rssi" , val , 0 );
- TC_SUCCESS_RESULT();
+ int ret;
+ int val = -1;
+ ret = dm_conn_get_rssi(&val);
+ TC_ASSERT_EQ("dm_conn_get_rssi" , ret , DM_ERROR_NONE);
+ TC_ASSERT_LEQ("dm_conn_get_rssi" , val , 0);
+ TC_SUCCESS_RESULT();
}
/**
*/
static void itc_dm_conn_set_get_tx_power_p(void)
{
- int ret;
- int setVal = 1, getVal, defaultvalue;
- // To get default value dm_conn_get_tx_power(&defaultvalue);
- ret = dm_conn_set_tx_power(&setVal);
- TC_ASSERT_EQ("dm_conn_set_tx_power" , ret , DM_ERROR_NONE);
- ret = dm_conn_get_tx_power(&getVal);
- TC_ASSERT_EQ("dm_conn_get_tx_power" , ret, DM_ERROR_NONE);
- TC_ASSERT_EQ_CLEANUP("itc_dm_conn_set_get_power" , setVal , getVal, dm_conn_set_tx_power(&defaultvalue));
- dm_conn_set_tx_power(&defaultvalue);
- TC_SUCCESS_RESULT();
+ int ret;
+ int setVal = 1, getVal, defaultvalue;
+ // To get default value dm_conn_get_tx_power(&defaultvalue);
+ ret = dm_conn_set_tx_power(&setVal);
+ TC_ASSERT_EQ("dm_conn_set_tx_power" , ret , DM_ERROR_NONE);
+ ret = dm_conn_get_tx_power(&getVal);
+ TC_ASSERT_EQ("dm_conn_get_tx_power" , ret, DM_ERROR_NONE);
+ TC_ASSERT_EQ_CLEANUP("itc_dm_conn_set_get_power" , setVal , getVal, dm_conn_set_tx_power(&defaultvalue));
+ dm_conn_set_tx_power(&defaultvalue);
+ TC_SUCCESS_RESULT();
}
/**
*/
static conn_cb linkEvent()
{
- printf("Set link event\n");
+ printf("Set link event\n");
}
/**
*/
static void itc_dm_conn_register_unregister_linkup_p(void)
{
- int ret;
- ret = dm_conn_register_linkup_cb(linkEvent);
- TC_ASSERT_EQ("dm_conn_register_linkup_cb" , ret, DM_ERROR_NONE);
- ret = dm_conn_unregister_linkup_cb(linkEvent);
- TC_ASSERT_EQ("dm_conn_unregister_linkup_cb" , ret, DM_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ int ret;
+ ret = dm_conn_register_linkup_cb(linkEvent);
+ TC_ASSERT_EQ("dm_conn_register_linkup_cb" , ret, DM_ERROR_NONE);
+ ret = dm_conn_unregister_linkup_cb(linkEvent);
+ TC_ASSERT_EQ("dm_conn_unregister_linkup_cb" , ret, DM_ERROR_NONE);
+ TC_SUCCESS_RESULT();
}
/**
*/
static void itc_dm_conn_register_unregister_linkdown_p(void)
{
- int ret;
- ret = dm_conn_register_linkdown_cb(linkEvent);
- TC_ASSERT_EQ("dm_conn_register_linkdown_cb" , ret, DM_ERROR_NONE);
- ret = dm_conn_unregister_linkup_cb(linkEvent);
- TC_ASSERT_EQ("dm_conn_unregister_linkup_cb" , ret, DM_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ int ret;
+ ret = dm_conn_register_linkdown_cb(linkEvent);
+ TC_ASSERT_EQ("dm_conn_register_linkdown_cb" , ret, DM_ERROR_NONE);
+ ret = dm_conn_unregister_linkup_cb(linkEvent);
+ TC_ASSERT_EQ("dm_conn_unregister_linkup_cb" , ret, DM_ERROR_NONE);
+ TC_SUCCESS_RESULT();
}
/****************************************************************************
int itc_dm_conn_get_address_main(void)
{
- itc_dm_conn_get_address_p();
- return 0;
+ itc_dm_conn_get_address_p();
+ return 0;
}
/****************************************************************************
int itc_dm_conn_get_channel_main(void)
{
- itc_dm_conn_get_channel_p();
- return 0;
+ itc_dm_conn_get_channel_p();
+ return 0;
}
/****************************************************************************
int itc_dm_conn_get_interface_main(void)
{
- itc_dm_conn_get_interface_p();
- return 0;
+ itc_dm_conn_get_interface_p();
+ return 0;
}
/****************************************************************************
int itc_dm_conn_get_rssi_main(void)
{
- itc_dm_conn_get_rssi_p();
- return 0;
+ itc_dm_conn_get_rssi_p();
+ return 0;
}
/****************************************************************************
int itc_dm_conn_set_get_tx_power_main(void)
{
- itc_dm_conn_set_get_tx_power_p();
- return 0;
+ itc_dm_conn_set_get_tx_power_p();
+ return 0;
}
/****************************************************************************
int itc_dm_conn_regi_unreg_linkup_main(void)
{
- itc_dm_conn_register_unregister_linkup_p();
- return 0;
+ itc_dm_conn_register_unregister_linkup_p();
+ return 0;
}
/****************************************************************************
int itc_dm_conn_regi_unreg_linkdown_main(void)
{
- itc_dm_conn_register_unregister_linkdown_p();
- return 0;
+ itc_dm_conn_register_unregister_linkdown_p();
+ return 0;
}
*/
static int display_resource(FAR void *arg)
{
- int ret;
- char argbuffer[10];
- memset(argbuffer, 0x00, sizeof(argbuffer));
- strcpy(argbuffer, "/8/0");
-
- ret = dm_lwm2m_display_client_resource(argbuffer);
- TC_ASSERT_EQ_CLEANUP("dm_lwm2m_display_client_resource", ret, DM_ERROR_NONE, dm_lwm2m_stop_client());
- ret = dm_lwm2m_stop_client();
- TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
+ int ret;
+ char argbuffer[10];
+ memset(argbuffer, 0x00, sizeof(argbuffer));
+ strcpy(argbuffer, "/8/0");
+
+ ret = dm_lwm2m_display_client_resource(argbuffer);
+ TC_ASSERT_EQ_CLEANUP("dm_lwm2m_display_client_resource", ret, DM_ERROR_NONE, dm_lwm2m_stop_client());
+ ret = dm_lwm2m_stop_client();
+ TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
}
/**
*/
static void itc_dm_lwm2m_start_stop_client_p(void)
{
- int ret;
- ret = dm_lwm2m_start_client(&test_data_itc);
- TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
+ int ret;
+ ret = dm_lwm2m_start_client(&test_data_itc);
+ TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
- ret = dm_lwm2m_stop_client();
- TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
+ ret = dm_lwm2m_stop_client();
+ TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
static void itc_dm_lwm2m_get_client_lifetime_p(void)
{
- int life = -1;
- int ret = -1;
- ret = dm_lwm2m_start_client(&test_data_itc);
- TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
+ int life = -1;
+ int ret = -1;
+ ret = dm_lwm2m_start_client(&test_data_itc);
+ TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
- ret = dm_lwm2m_get_client_lifetime(&life);
- TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_client_lifetime", ret, DM_ERROR_NONE, dm_lwm2m_stop_client());
- TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_client_lifetime", (life < 0), false, dm_lwm2m_stop_client());
+ ret = dm_lwm2m_get_client_lifetime(&life);
+ TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_client_lifetime", ret, DM_ERROR_NONE, dm_lwm2m_stop_client());
+ TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_client_lifetime", (life < 0), false, dm_lwm2m_stop_client());
- ret = dm_lwm2m_stop_client();
- TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
+ ret = dm_lwm2m_stop_client();
+ TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
static void itc_dm_lwm2m_get_server_address_p(void)
{
- int ret = dm_lwm2m_start_client(&test_data_itc);
- TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
+ int ret = dm_lwm2m_start_client(&test_data_itc);
+ TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
- char ipAddr[ITC_DM_IPADDR_LEN];
- ret = dm_lwm2m_get_server_address(ipAddr);
- TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_server_address", ret, DM_ERROR_NONE, dm_lwm2m_stop_client());
- TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_server_address" , ipAddr[3] , '.', dm_lwm2m_stop_client());
+ char ipAddr[ITC_DM_IPADDR_LEN];
+ ret = dm_lwm2m_get_server_address(ipAddr);
+ TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_server_address", ret, DM_ERROR_NONE, dm_lwm2m_stop_client());
+ TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_server_address" , ipAddr[3] , '.', dm_lwm2m_stop_client());
- ret = dm_lwm2m_stop_client();
- TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
+ ret = dm_lwm2m_stop_client();
+ TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
static void itc_dm_lwm2m_get_server_port_p(void)
{
- char port[ITC_DM_SERVER_PORT];
- int ret = dm_lwm2m_start_client(&test_data_itc);
- TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
+ char port[ITC_DM_SERVER_PORT];
+ int ret = dm_lwm2m_start_client(&test_data_itc);
+ TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
- ret = dm_lwm2m_get_server_port(port);
- TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_server_port", ret, DM_ERROR_NONE, dm_lwm2m_stop_client());
- TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_server_port", (port[0] < 0), false, dm_lwm2m_stop_client());
+ ret = dm_lwm2m_get_server_port(port);
+ TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_server_port", ret, DM_ERROR_NONE, dm_lwm2m_stop_client());
+ TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_server_port", (port[0] < 0), false, dm_lwm2m_stop_client());
- ret = dm_lwm2m_stop_client();
- TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
+ ret = dm_lwm2m_stop_client();
+ TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
static void itc_dm_lwm2m_get_client_state_p(void)
{
- int8_t state = -1;
- int ret = dm_lwm2m_start_client(&test_data_itc);
- TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
+ int8_t state = -1;
+ int ret = dm_lwm2m_start_client(&test_data_itc);
+ TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
- ret = dm_lwm2m_get_client_state(&state);
- TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_client_state", ret, DM_ERROR_NONE, dm_lwm2m_stop_client());
- TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_client_state", (state < 0), false, dm_lwm2m_stop_client());
+ ret = dm_lwm2m_get_client_state(&state);
+ TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_client_state", ret, DM_ERROR_NONE, dm_lwm2m_stop_client());
+ TC_ASSERT_EQ_CLEANUP("dm_lwm2m_get_client_state", (state < 0), false, dm_lwm2m_stop_client());
- ret = dm_lwm2m_stop_client();
- TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
+ ret = dm_lwm2m_stop_client();
+ TC_ASSERT_EQ("dm_lwm2m_stop_client" , ret , DM_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
static void itc_dm_lwm2m_display_client_resource_p(void)
{
- int ret = dm_lwm2m_start_client(&test_data_itc);
- TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
- work_queue(HPWORK, &itc_dm_wq, display_resource, NULL, MSEC2TICK(6000));
- TC_SUCCESS_RESULT();
+ int ret = dm_lwm2m_start_client(&test_data_itc);
+ TC_ASSERT_EQ("dm_lwm2m_start_client" , ret , DM_ERROR_NONE);
+ work_queue(HPWORK, &itc_dm_wq, display_resource, NULL, MSEC2TICK(6000));
+ TC_SUCCESS_RESULT();
}
/****************************************************************************
{
#ifdef CONFIG_ITC_DM_START
#ifdef CONFIG_ITC_DM_CLOSE
- itc_dm_lwm2m_start_stop_client_p();
- sleep(1);
+ itc_dm_lwm2m_start_stop_client_p();
+ sleep(1);
#ifdef CONFIG_ITC_DM_GET_CLIENT_LIFETIME
- itc_dm_lwm2m_get_client_lifetime_p();
- sleep(1);
+ itc_dm_lwm2m_get_client_lifetime_p();
+ sleep(1);
#endif
#ifdef CONFIG_ITC_DM_GET_SERVER_ADDR
- itc_dm_lwm2m_get_server_address_p();
- sleep(1);
+ itc_dm_lwm2m_get_server_address_p();
+ sleep(1);
#endif
#ifdef CONFIG_ITC_DM_GET_SERVER_PORT
- itc_dm_lwm2m_get_server_port_p();
- sleep(1);
+ itc_dm_lwm2m_get_server_port_p();
+ sleep(1);
#endif
#ifdef CONFIG_ITC_DM_GET_CLIENT_STATE
- itc_dm_lwm2m_get_client_state_p();
- sleep(1);
+ itc_dm_lwm2m_get_client_state_p();
+ sleep(1);
#endif
#ifdef CONFIG_ITC_DM_DISPLAY_CLIENT_RESOURCE
- itc_dm_lwm2m_display_client_resource_p();
- sleep(1);
+ itc_dm_lwm2m_display_client_resource_p();
+ sleep(1);
#endif
#endif
#endif
- return 0;
+ return 0;
}
static int app_dhcp_main(void)
{
- uint32_t timeleft = 15000;
- struct dhcpc_state state;
- void *dhcp_handle;
- int ret;
- dhcp_handle = dhcpc_open(NET_DEVNAME);
- ret = dhcpc_request(dhcp_handle, &state);
- while (ret != OK) {
- usleep(10);
- //sys_msleep(10);
- timeleft -= 10;
-
- if (timeleft <= 0)
- break;
- }
-
- if (timeleft <= 0) {
- dhcpc_close(dhcp_handle);
- return -1;
- }
-
- netlib_set_ipv4addr(NET_DEVNAME, &state.ipaddr);
- netlib_set_ipv4netmask(NET_DEVNAME, &state.netmask);
- netlib_set_dripv4addr(NET_DEVNAME, &state.default_router);
-
- printf("IP address : %s ----\n", inet_ntoa(state.ipaddr));
- return 1;
+ uint32_t timeleft = 15000;
+ struct dhcpc_state state;
+ void *dhcp_handle;
+ int ret;
+ dhcp_handle = dhcpc_open(NET_DEVNAME);
+ ret = dhcpc_request(dhcp_handle, &state);
+ while (ret != OK) {
+ usleep(10);
+ //sys_msleep(10);
+ timeleft -= 10;
+
+ if (timeleft <= 0)
+ break;
+ }
+
+ if (timeleft <= 0) {
+ dhcpc_close(dhcp_handle);
+ return -1;
+ }
+
+ netlib_set_ipv4addr(NET_DEVNAME, &state.ipaddr);
+ netlib_set_ipv4netmask(NET_DEVNAME, &state.netmask);
+ netlib_set_dripv4addr(NET_DEVNAME, &state.default_router);
+
+ printf("IP address : %s ----\n", inet_ntoa(state.ipaddr));
+ return 1;
}
static conn_cb linkUpEvent()
{
- isConnected = 1;
- return 0;
+ isConnected = 1;
+ return 0;
}
int wifiAutoConnectInit_itc()
{
- int8_t ret;
- uint8_t result;
-
- isConnected = 0;
- dm_conn_register_linkup_cb(linkUpEvent);
-
- if (WifiIsConnected(&result, NULL) != SLSI_STATUS_SUCCESS) {
- printf("failed to WifiIsConnected\n");
- return;
- }
-
- if (result > 0) {
- printf("Wi-Fi status - Connected : %d\n", result);
- isConnected = 1;
- return 1;
- }
-
- ret = WiFiStart(SLSI_WIFI_STATION_IF, NULL);
- if (ret == SLSI_STATUS_SUCCESS) {
- printf("[AutoConnect]STA mode started\n");
- ret = WiFiNetworkJoin(CONFIG_DM_AP_SSID, strlen(CONFIG_DM_AP_SSID), NULL, get_security_config(CONFIG_DM_AP_SECURITY, CONFIG_DM_AP_PASS));
- sleep(1);
- if (ret == SLSI_STATUS_SUCCESS) {
- printf("[AutoConnect]Start doJoin with SSID %s\n", CONFIG_DM_AP_SSID);
- return 1;
- } else {
- printf("[AutoConnect]Failed to join the network.[%d]\n", ret);
- }
- return -1;
- } else {
- printf("[AutoConnect]Failed to start STA mode\n");
- }
- return -1;
+ int8_t ret;
+ uint8_t result;
+
+ isConnected = 0;
+ dm_conn_register_linkup_cb(linkUpEvent);
+
+ if (WifiIsConnected(&result, NULL) != SLSI_STATUS_SUCCESS) {
+ printf("failed to WifiIsConnected\n");
+ return;
+ }
+
+ if (result > 0) {
+ printf("Wi-Fi status - Connected : %d\n", result);
+ isConnected = 1;
+ return 1;
+ }
+
+ ret = WiFiStart(SLSI_WIFI_STATION_IF, NULL);
+ if (ret == SLSI_STATUS_SUCCESS) {
+ printf("[AutoConnect]STA mode started\n");
+ ret = WiFiNetworkJoin(CONFIG_DM_AP_SSID, strlen(CONFIG_DM_AP_SSID), NULL, get_security_config(CONFIG_DM_AP_SECURITY, CONFIG_DM_AP_PASS));
+ sleep(1);
+ if (ret == SLSI_STATUS_SUCCESS) {
+ printf("[AutoConnect]Start doJoin with SSID %s\n", CONFIG_DM_AP_SSID);
+ return 1;
+ } else {
+ printf("[AutoConnect]Failed to join the network.[%d]\n", ret);
+ }
+ return -1;
+ } else {
+ printf("[AutoConnect]Failed to start STA mode\n");
+ }
+ return -1;
}
void wifiAutoConnectDeInit_itc()
{
- isConnected = 0;
- dm_conn_unregister_linkup_cb(linkUpEvent);
+ isConnected = 0;
+ dm_conn_unregister_linkup_cb(linkUpEvent);
}
static void wifiAutoConnect()
{
- int ret;
- if ((ret = wifiAutoConnectInit_itc()) == 1) {
- int waitTime = 10;
- while (waitTime--) {
- if (isConnected == 1) {
- printf("[AutoConnect]WiFi Connected!\n");
- int dhcp_ret = app_dhcp_main();
- if (dhcp_ret == -1) {
- printf("Timeout fail to get ip address\n");
- return dhcp_ret;
- } else if (dhcp_ret == 0) {
- printf("No network interface\n");
- return dhcp_ret;
- }
- printf("DHCP done\n");
- break;
- }
- sleep(1);
- }
- if (waitTime <= 0) {
- printf("[AutoConnect]WiFi is not working. Test Canceled\n");
- return 0;
- }
- }
+ int ret;
+ if ((ret = wifiAutoConnectInit_itc()) == 1) {
+ int waitTime = 10;
+ while (waitTime--) {
+ if (isConnected == 1) {
+ printf("[AutoConnect]WiFi Connected!\n");
+ int dhcp_ret = app_dhcp_main();
+ if (dhcp_ret == -1) {
+ printf("Timeout fail to get ip address\n");
+ return dhcp_ret;
+ } else if (dhcp_ret == 0) {
+ printf("No network interface\n");
+ return dhcp_ret;
+ }
+ printf("DHCP done\n");
+ break;
+ }
+ sleep(1);
+ }
+ if (waitTime <= 0) {
+ printf("[AutoConnect]WiFi is not working. Test Canceled\n");
+ return 0;
+ }
+ }
}
#ifdef CONFIG_BUILD_KERNEL
int itc_dm_main(int argc, char *argv[])
#endif
{
- sem_wait(&tc_sem);
- total_pass = 0;
- total_fail = 0;
+ sem_wait(&tc_sem);
+ total_pass = 0;
+ total_fail = 0;
#ifndef CONFIG_EXAMPLES_TESTCASE_DM_WIFI
- printf("=== Please Setup WiFi Info ===\n");
- return 0;
+ printf("=== Please Setup WiFi Info ===\n");
+ return 0;
#endif
- wifiAutoConnect();
+ wifiAutoConnect();
- printf("=== TINYARA DM ITC START! ===\n");
- itc_dm_lwm2m_testcase_main();
+ printf("=== TINYARA DM ITC START! ===\n");
+ itc_dm_lwm2m_testcase_main();
#ifdef CONFIG_ITC_DM_CONN_GET_RSSI
- itc_dm_conn_get_rssi_main();
+ itc_dm_conn_get_rssi_main();
#endif
#ifdef CONFIG_ITC_DM_CONN_GET_ADDRESS
- itc_dm_conn_get_address_main();
+ itc_dm_conn_get_address_main();
#endif
#ifdef CONFIG_ITC_DM_CONN_GET_INTERFACE
- itc_dm_conn_get_interface_main();
+ itc_dm_conn_get_interface_main();
#endif
#ifdef CONFIG_ITC_DM_CONN_GET_CHANNEL
- itc_dm_conn_get_channel_main();
+ itc_dm_conn_get_channel_main();
#endif
#ifdef CONFIG_ITC_DM_CONN_GET_TX_POWER
#ifdef CONFIG_ITC_DM_CONN_SET_TX_POWER
- itc_dm_conn_set_get_tx_power_main();
+ itc_dm_conn_set_get_tx_power_main();
#endif
#endif
#ifdef CONFIG_ITC_DM_CONN_REGI_LINKUP
#ifdef CONFIG_ITC_DM_CONN_UNREGI_LINKUP
- itc_dm_conn_regi_unreg_linkup_main();
+ itc_dm_conn_regi_unreg_linkup_main();
#endif
#endif
#ifdef CONFIG_ITC_DM_CONN_REGI_LINKDOWN
#ifdef CONFIG_ITC_DM_CONN_UNREGI_LINKDOWN
- itc_dm_conn_regi_unreg_linkdown_main();
+ itc_dm_conn_regi_unreg_linkdown_main();
#endif
#endif
- printf("\n=== TINYARA DM ITC COMPLETE ===\n");
- printf("\t\tTotal pass : %d\n\t\tTotal fail : %d\n", total_pass, total_fail);
+ printf("\n=== TINYARA DM ITC COMPLETE ===\n");
+ printf("\t\tTotal pass : %d\n\t\tTotal fail : %d\n", total_pass, total_fail);
- wifiAutoConnectDeInit_itc();
+ wifiAutoConnectDeInit_itc();
- sem_post(&tc_sem);
+ sem_post(&tc_sem);
- return 0;
+ return 0;
}
*/
void gpio_event_callback(void *user_data)
{
- SYSIO_ITC_PRINT("\n inside the function %s \n", __func__);
- iotbus_gpio_context_h hnd = (iotbus_gpio_context_h) user_data;
- int value = iotbus_gpio_read(hnd);
- if (value < 0) {
- gpio_flag_callback = 0;
- return;
- }
- gpio_flag_callback = 1;
-
- return;
+ SYSIO_ITC_PRINT("\n inside the function %s \n", __func__);
+ iotbus_gpio_context_h hnd = (iotbus_gpio_context_h) user_data;
+ int value = iotbus_gpio_read(hnd);
+ if (value < 0) {
+ gpio_flag_callback = 0;
+ return;
+ }
+ gpio_flag_callback = 1;
+
+ return;
}
/**
*/
void itc_gpio_open_close_p(void)
{
- int gpiopin = 12;
- int ret;
- g_gpio = iotbus_gpio_open(gpiopin);
- TC_ASSERT_NEQ ("iotbus_gpio_open" , g_gpio, NULL);
+ int gpiopin = 12;
+ int ret;
+ g_gpio = iotbus_gpio_open(gpiopin);
+ TC_ASSERT_NEQ("iotbus_gpio_open" , g_gpio, NULL);
gpiopin = 14;
g_gpio2 = iotbus_gpio_open(gpiopin);
ret = iotbus_gpio_close(g_gpio2);
TC_ASSERT_EQ("iotbus_gpio_close", ret, 0);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
void itc_gpio_get_pin_p(void)
{
- int gpioSetpin = 12;
- int gpioGetpin;
- iotbus_gpio_context_h m_gpio = iotbus_gpio_open(gpioSetpin);
- TC_ASSERT_NEQ("iotbus_gpio_open" , m_gpio, NULL);
+ int gpioSetpin = 12;
+ int gpioGetpin;
+ iotbus_gpio_context_h m_gpio = iotbus_gpio_open(gpioSetpin);
+ TC_ASSERT_NEQ("iotbus_gpio_open" , m_gpio, NULL);
gpioGetpin = iotbus_gpio_get_pin(m_gpio);
TC_ASSERT_EQ_CLEANUP("iotbus_gpio_get_pin", gpioGetpin, gpioSetpin, iotbus_gpio_close(m_gpio));
- iotbus_gpio_close(m_gpio);
- TC_SUCCESS_RESULT();
+ iotbus_gpio_close(m_gpio);
+ TC_SUCCESS_RESULT();
}
/**
*/
void itc_gpio_read_write_p(void)
{
- int ret, gpiopin = 12;
- g_gpio = iotbus_gpio_open(gpiopin);
- TC_ASSERT_NEQ("iotbus_gpio_open" , g_gpio, NULL);
+ int ret, gpiopin = 12;
+ g_gpio = iotbus_gpio_open(gpiopin);
+ TC_ASSERT_NEQ("iotbus_gpio_open" , g_gpio, NULL);
ret = iotbus_gpio_read(g_gpio);
TC_ASSERT_EQ_CLEANUP("iotbus_gpio_read", (ret < 0), false, iotbus_gpio_close(g_gpio));
ret = iotbus_gpio_write(g_gpio, 1);
TC_ASSERT_EQ_CLEANUP("iotbus_gpio_write", (ret < 0), false, iotbus_gpio_close(g_gpio));
- iotbus_gpio_close(g_gpio);
- TC_SUCCESS_RESULT();
+ iotbus_gpio_close(g_gpio);
+ TC_SUCCESS_RESULT();
}
/**
*/
void itc_gpio_register_unregister_callback_p(void)
{
- gpio_flag_callback = 0;
- int ret;
- int data = 0, gpio_pin2 = 57, gpio_pin1 = 41;
+ gpio_flag_callback = 0;
+ int ret;
+ int data = 0, gpio_pin2 = 57, gpio_pin1 = 41;
- g_gpio = iotbus_gpio_open(gpio_pin1);
- TC_ASSERT_NEQ ("iotbus_gpio_open" , g_gpio, NULL);
+ g_gpio = iotbus_gpio_open(gpio_pin1);
+ TC_ASSERT_NEQ("iotbus_gpio_open" , g_gpio, NULL);
g_gpio2 = iotbus_gpio_open(gpio_pin2);
TC_ASSERT_NEQ_CLEANUP("iotbus_gpio_open", g_gpio2 , NULL , iotbus_gpio_close(g_gpio));
- iotbus_gpio_set_direction(g_gpio, IOTBUS_GPIO_DIRECTION_OUT);
- iotbus_gpio_set_direction(g_gpio2, IOTBUS_GPIO_DIRECTION_IN);
+ iotbus_gpio_set_direction(g_gpio, IOTBUS_GPIO_DIRECTION_OUT);
+ iotbus_gpio_set_direction(g_gpio2, IOTBUS_GPIO_DIRECTION_IN);
ret = iotbus_gpio_register_cb(g_gpio2, IOTBUS_GPIO_EDGE_RISING, gpio_event_callback, (void *)g_gpio2);
TC_ASSERT_EQ_CLEANUP("iotbus_gpio_register_cb", ret , 0, iotbus_gpio_close(g_gpio2); iotbus_gpio_close(g_gpio));
- // To trigger event for callback
- iotbus_gpio_write(g_gpio, data);
- sleep(1);
- data = 1;
- iotbus_gpio_write(g_gpio, data);
- sleep(2);
+ // To trigger event for callback
+ iotbus_gpio_write(g_gpio, data);
+ sleep(1);
+ data = 1;
+ iotbus_gpio_write(g_gpio, data);
+ sleep(2);
TC_ASSERT_EQ_CLEANUP("iotbus_gpio_register_cb", gpio_flag_callback, 1, iotbus_gpio_unregister_cb(g_gpio); iotbus_gpio_close(g_gpio2); iotbus_gpio_close(g_gpio));
ret = iotbus_gpio_close(g_gpio2);
TC_ASSERT_EQ_CLEANUP("iotbus_gpio_close", ret, 0 , iotbus_gpio_close(g_gpio));
- ret = iotbus_gpio_close(g_gpio);
- TC_ASSERT_EQ(iotbus_gpio_close, ret, 0)
+ ret = iotbus_gpio_close(g_gpio);
+ TC_ASSERT_EQ(iotbus_gpio_close, ret, 0)
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
int itc_gpio_main(void)
{
- iotapi_initialize();
+ iotapi_initialize();
- itc_gpio_open_close_p();
- itc_gpio_get_pin_p();
- itc_gpio_set_get_direction_p();
- itc_gpio_set_get_edge_mode_p();
- itc_gpio_set_get_drive_mode_p();
- itc_gpio_read_write_p();
- itc_gpio_register_unregister_callback_p();
+ itc_gpio_open_close_p();
+ itc_gpio_get_pin_p();
+ itc_gpio_set_get_direction_p();
+ itc_gpio_set_get_edge_mode_p();
+ itc_gpio_set_get_drive_mode_p();
+ itc_gpio_read_write_p();
+ itc_gpio_register_unregister_callback_p();
- return 0;
+ return 0;
}
*/
void itc_iotbus_i2c_init_stop_p(void)
{
- int ret = IOTBUS_ERROR_NONE;
- iotbus_i2c_context_h h_i2c = iotbus_i2c_init(g_bus);
- TC_ASSERT_NEQ("iotbus_i2c_init", h_i2c, NULL);
+ int ret = IOTBUS_ERROR_NONE;
+ iotbus_i2c_context_h h_i2c = iotbus_i2c_init(g_bus);
+ TC_ASSERT_NEQ("iotbus_i2c_init", h_i2c, NULL);
- ret = iotbus_i2c_stop(h_i2c);
- TC_ASSERT_EQ("iotbus_i2c_stop", ret, IOTBUS_ERROR_NONE);
+ ret = iotbus_i2c_stop(h_i2c);
+ TC_ASSERT_EQ("iotbus_i2c_stop", ret, IOTBUS_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
void itc_iotbus_i2c_set_address_p(void)
{
- int ret = IOTBUS_ERROR_NONE;
- uint8_t address = 0x08;
- iotbus_i2c_context_h h_i2c = iotbus_i2c_init(g_bus);
- TC_ASSERT_NEQ("iotbus_i2c_init", h_i2c, NULL);
+ int ret = IOTBUS_ERROR_NONE;
+ uint8_t address = 0x08;
+ iotbus_i2c_context_h h_i2c = iotbus_i2c_init(g_bus);
+ TC_ASSERT_NEQ("iotbus_i2c_init", h_i2c, NULL);
ret = iotbus_i2c_set_address(h_i2c, address);
TC_ASSERT_EQ_CLEANUP("iotbus_i2c_set_address", ret, IOTBUS_ERROR_NONE, iotbus_i2c_stop(h_i2c));
- ret = iotbus_i2c_stop(h_i2c);
- TC_ASSERT_EQ("iotbus_i2c_stop", ret, IOTBUS_ERROR_NONE);
+ ret = iotbus_i2c_stop(h_i2c);
+ TC_ASSERT_EQ("iotbus_i2c_stop", ret, IOTBUS_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
void itc_iotbus_i2c_write_read_p(void)
{
- int ret = IOTBUS_ERROR_NONE;
- uint8_t szCmd[2] = { 0x01, 0x02 };
- uint8_t szReadBuf[10];
- iotbus_i2c_context_h h_i2c = iotbus_i2c_init(g_bus);
- TC_ASSERT_NEQ("iotbus_i2c_init", h_i2c, NULL);
+ int ret = IOTBUS_ERROR_NONE;
+ uint8_t szCmd[2] = { 0x01, 0x02 };
+ uint8_t szReadBuf[10];
+ iotbus_i2c_context_h h_i2c = iotbus_i2c_init(g_bus);
+ TC_ASSERT_NEQ("iotbus_i2c_init", h_i2c, NULL);
ret = iotbus_i2c_write(h_i2c, szCmd, 1);
TC_ASSERT_EQ_CLEANUP("iotbus_i2c_write", (ret < 0), false, iotbus_i2c_stop(h_i2c));
ret = iotbus_i2c_read(h_i2c, szReadBuf, 10);
TC_ASSERT_EQ_CLEANUP("iotbus_i2c_read", ret, IOTBUS_ERROR_NONE, iotbus_i2c_stop(h_i2c));
- ret = iotbus_i2c_stop(h_i2c);
- TC_ASSERT_EQ("iotbus_i2c_stop", ret, IOTBUS_ERROR_NONE);
+ ret = iotbus_i2c_stop(h_i2c);
+ TC_ASSERT_EQ("iotbus_i2c_stop", ret, IOTBUS_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
int itc_i2c_main(void)
{
- itc_iotbus_i2c_init_stop_p();
- itc_iotbus_i2c_set_frequency_p();
- itc_iotbus_i2c_set_address_p();
- itc_iotbus_i2c_write_read_p();
- return 0;
+ itc_iotbus_i2c_init_stop_p();
+ itc_iotbus_i2c_set_frequency_p();
+ itc_iotbus_i2c_set_address_p();
+ itc_iotbus_i2c_write_read_p();
+ return 0;
}
*/
void itc_pwm_open_close_p(void)
{
- int device = 0;
- int channel = 1;
- int ret = 0;
- iotbus_pwm_context_h h_pwm = iotbus_pwm_open(device, channel);
- TC_ASSERT_NEQ("iotbus_pwm_open", h_pwm, NULL);
+ int device = 0;
+ int channel = 1;
+ int ret = 0;
+ iotbus_pwm_context_h h_pwm = iotbus_pwm_open(device, channel);
+ TC_ASSERT_NEQ("iotbus_pwm_open", h_pwm, NULL);
- ret = iotbus_pwm_close(h_pwm);
- TC_ASSERT_EQ("iotbus_pwm_close", ret, OK);
+ ret = iotbus_pwm_close(h_pwm);
+ TC_ASSERT_EQ("iotbus_pwm_close", ret, OK);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
void itc_pwm_set_get_duty_cycle_p(void)
{
- int device = 0;
- int channel = 1;
- int cycle = 20;
- int ret = 0;
- iotbus_pwm_context_h h_pwm = iotbus_pwm_open(device, channel);
- TC_ASSERT_NEQ("iotbus_pwm_open", h_pwm, NULL);
+ int device = 0;
+ int channel = 1;
+ int cycle = 20;
+ int ret = 0;
+ iotbus_pwm_context_h h_pwm = iotbus_pwm_open(device, channel);
+ TC_ASSERT_NEQ("iotbus_pwm_open", h_pwm, NULL);
ret = iotbus_pwm_set_duty_cycle(h_pwm, cycle);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_set_duty_cycle", ret, OK, iotbus_pwm_close(h_pwm));
ret = iotbus_pwm_get_duty_cycle(h_pwm);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_get_duty_cycle", ret, cycle, iotbus_pwm_close(h_pwm));
- ret = iotbus_pwm_close(h_pwm);
- TC_ASSERT_EQ("iotbus_pwm_close", ret, OK);
+ ret = iotbus_pwm_close(h_pwm);
+ TC_ASSERT_EQ("iotbus_pwm_close", ret, OK);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
void itc_pwm_set_get_period_p(void)
{
- int device = 0;
- int channel = 1;
- int period = 1000;
- int ret = 0;
- iotbus_pwm_context_h h_pwm = iotbus_pwm_open(device, channel);
- TC_ASSERT_NEQ("iotbus_pwm_open", h_pwm, NULL);
+ int device = 0;
+ int channel = 1;
+ int period = 1000;
+ int ret = 0;
+ iotbus_pwm_context_h h_pwm = iotbus_pwm_open(device, channel);
+ TC_ASSERT_NEQ("iotbus_pwm_open", h_pwm, NULL);
ret = iotbus_pwm_set_period(h_pwm, period);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_set_period", ret, OK, iotbus_pwm_close(h_pwm));
ret = iotbus_pwm_get_period(h_pwm);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_get_period", ret, period, iotbus_pwm_close(h_pwm));
- ret = iotbus_pwm_close(h_pwm);
- TC_ASSERT_EQ("iotbus_pwm_close", ret, OK);
+ ret = iotbus_pwm_close(h_pwm);
+ TC_ASSERT_EQ("iotbus_pwm_close", ret, OK);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
int itc_pwm_main(void)
{
- itc_pwm_open_close_p();
- itc_pwm_set_get_duty_cycle_p();
- itc_pwm_set_get_period_p();
- itc_pwm_set_enabled_is_enabled_p();
+ itc_pwm_open_close_p();
+ itc_pwm_set_get_duty_cycle_p();
+ itc_pwm_set_get_period_p();
+ itc_pwm_set_enabled_is_enabled_p();
- return 0;
+ return 0;
}
unsigned int gBus = 0;
struct iotbus_spi_config_s _g_st_config = {
- (char)8,
- 0,
- 12000000,
- IOTBUS_SPI_MODE0,
+ (char)8,
+ 0,
+ 12000000,
+ IOTBUS_SPI_MODE0,
};
/**
*/
void itc_iotbus_spi_open_close_p(void)
{
- int ret = IOTBUS_ERROR_NONE;
- iotbus_spi_context_h h_spi = iotbus_spi_open(gBus, &_g_st_config);
- TC_ASSERT_NEQ("iotbus_spi_open", h_spi, NULL);
+ int ret = IOTBUS_ERROR_NONE;
+ iotbus_spi_context_h h_spi = iotbus_spi_open(gBus, &_g_st_config);
+ TC_ASSERT_NEQ("iotbus_spi_open", h_spi, NULL);
- ret = iotbus_spi_close(h_spi);
- TC_ASSERT_EQ("iotbus_spi_close", ret, IOTBUS_ERROR_NONE);
+ ret = iotbus_spi_close(h_spi);
+ TC_ASSERT_EQ("iotbus_spi_close", ret, IOTBUS_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
void itc_iotbus_spi_write_recv_trasfer_p(void)
{
- unsigned char sz_txbuf[64] = { 0, };
- unsigned char sz_rxbuf[64] = { 0, };
- int ret = IOTBUS_ERROR_NONE;
- iotbus_spi_context_h h_spi = iotbus_spi_open(gBus, &_g_st_config);
- TC_ASSERT_NEQ("iotbus_spi_open", h_spi, NULL);
+ unsigned char sz_txbuf[64] = { 0, };
+ unsigned char sz_rxbuf[64] = { 0, };
+ int ret = IOTBUS_ERROR_NONE;
+ iotbus_spi_context_h h_spi = iotbus_spi_open(gBus, &_g_st_config);
+ TC_ASSERT_NEQ("iotbus_spi_open", h_spi, NULL);
ret = iotbus_spi_write(h_spi, sz_txbuf, 8);
TC_ASSERT_EQ_CLEANUP("iotbus_spi_write", ret, IOTBUS_ERROR_NONE, iotbus_spi_close(h_spi));
ret = iotbus_spi_recv(h_spi, sz_rxbuf, 8);
TC_ASSERT_EQ_CLEANUP("iotbus_spi_recv", ret, IOTBUS_ERROR_NONE, iotbus_spi_close(h_spi));
- ret = iotbus_spi_transfer_buf(h_spi, sz_txbuf, sz_rxbuf, 16);
+ ret = iotbus_spi_transfer_buf(h_spi, sz_txbuf, sz_rxbuf, 16);
#ifdef CONFIG_SPI_EXCHANGE
TC_ASSERT_EQ_CLEANUP("iotbus_spi_transfer_buf", ret, IOTBUS_ERROR_NONE, iotbus_spi_close(h_spi));
#else
TC_ASSERT_EQ_CLEANUP("iotbus_spi_transfer_buf", ret, IOTBUS_ERROR_NOT_SUPPORTED, iotbus_spi_close(h_spi));
#endif
- ret = iotbus_spi_close(h_spi);
- TC_ASSERT_EQ("iotbus_spi_close", ret, IOTBUS_ERROR_NONE);
+ ret = iotbus_spi_close(h_spi);
+ TC_ASSERT_EQ("iotbus_spi_close", ret, IOTBUS_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
int itc_spi_main(void)
{
- itc_iotbus_spi_open_close_p();
- itc_iotbus_spi_write_recv_trasfer_p();
- return 0;
+ itc_iotbus_spi_open_close_p();
+ itc_iotbus_spi_write_recv_trasfer_p();
+ return 0;
}
int itc_sysio_launcher(int argc, FAR char *argv[])
{
- total_pass = 0;
- total_fail = 0;
+ total_pass = 0;
+ total_fail = 0;
- sem_wait(&tc_sem);
+ sem_wait(&tc_sem);
#ifdef CONFIG_SYSIO_ITC_PWM
- itc_pwm_main();
+ itc_pwm_main();
#endif
#ifdef CONFIG_SYSIO_ITC_UART
- itc_uart_main();
+ itc_uart_main();
#endif
#ifdef CONFIG_SYSIO_ITC_SPI
- itc_spi_main();
+ itc_spi_main();
#endif
#ifdef CONFIG_SYSIO_ITC_I2C
- itc_i2c_main();
+ itc_i2c_main();
#endif
#ifdef CONFIG_SYSIO_ITC_GPIO
- itc_gpio_main();
+ itc_gpio_main();
#endif
- SYSIO_ITC_PRINT("\n=== TINYARA SYSIO TC COMPLETE ===\n");
- SYSIO_ITC_PRINT("\t\tTotal pass : %d\n\t\tTotal fail : %d\n", total_pass, total_fail);
+ SYSIO_ITC_PRINT("\n=== TINYARA SYSIO TC COMPLETE ===\n");
+ SYSIO_ITC_PRINT("\t\tTotal pass : %d\n\t\tTotal fail : %d\n", total_pass, total_fail);
- sem_post(&tc_sem);
+ sem_post(&tc_sem);
- return 0;
+ return 0;
}
#ifdef CONFIG_BUILD_KERNEL
#endif
{
#ifdef CONFIG_TASH
- tash_cmd_install("sysio_itc", itc_sysio_launcher, 0);
+ tash_cmd_install("sysio_itc", itc_sysio_launcher, 0);
#else
- itc_sysio_launcher(argc, argv);
+ itc_sysio_launcher(argc, argv);
#endif
- return 0;
+ return 0;
}
*/
void itc_iotbus_uart_init_stop_p(void)
{
- int ret = IOTBUS_ERROR_NONE;
- iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
- TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
+ int ret = IOTBUS_ERROR_NONE;
+ iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
+ TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
- ret = iotbus_uart_stop(h_uart);
- TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
+ ret = iotbus_uart_stop(h_uart);
+ TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
void itc_iotbus_uart_set_baudrate_p(void)
{
- int i_baudrate = 115200;
- int ret = IOTBUS_ERROR_NONE;
- iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
- TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
+ int i_baudrate = 115200;
+ int ret = IOTBUS_ERROR_NONE;
+ iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
+ TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
ret = iotbus_uart_set_baudrate(h_uart, i_baudrate);
TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_baudrate", ret, IOTBUS_ERROR_NONE, iotbus_uart_stop(h_uart));
- ret = iotbus_uart_stop(h_uart);
- TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
+ ret = iotbus_uart_stop(h_uart);
+ TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
- TC_SUCCESS_RESULT();;
+ TC_SUCCESS_RESULT();;
}
/**
*/
void itc_iotbus_uart_write_read_p(void)
{
- int ret = IOTBUS_ERROR_NONE;
- char szInputText[32] = "UART READ/WRITE ITC TESTING!";
- char szOutputText[32];
- iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
- TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
+ int ret = IOTBUS_ERROR_NONE;
+ char szInputText[32] = "UART READ/WRITE ITC TESTING!";
+ char szOutputText[32];
+ iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
+ TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
ret = iotbus_uart_write(h_uart, szInputText, sizeof(szInputText));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_write", ret < 0, false, iotbus_uart_stop(h_uart));
- usleep(MICROSECOND);
+ usleep(MICROSECOND);
ret = iotbus_uart_read(h_uart, szOutputText, sizeof(szOutputText));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_read", ret < 0, false, iotbus_uart_stop(h_uart));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_read", strcmp(szInputText, szOutputText), 0, iotbus_uart_stop(h_uart));
- ret = iotbus_uart_stop(h_uart);
- TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
+ ret = iotbus_uart_stop(h_uart);
+ TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/**
*/
void itc_iotbus_uart_flush_p(void)
{
- int ret = IOTBUS_ERROR_NONE;
- iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
- TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
+ int ret = IOTBUS_ERROR_NONE;
+ iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
+ TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
ret = iotbus_uart_flush(h_uart);
TC_ASSERT_EQ_CLEANUP("iotbus_uart_flush", ret, IOTBUS_ERROR_NONE, iotbus_uart_stop(h_uart));
- ret = iotbus_uart_stop(h_uart);
- TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
+ ret = iotbus_uart_stop(h_uart);
+ TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
- TC_SUCCESS_RESULT();
+ TC_SUCCESS_RESULT();
}
/****************************************************************************
int itc_uart_main(void)
{
#ifndef CONFIG_SERIAL_TERMIOS
- SYSIO_ITC_UART_PRINT("IOTBUS Not Supported\n");
+ SYSIO_ITC_UART_PRINT("IOTBUS Not Supported\n");
#else
- itc_iotbus_uart_init_stop_p();
- itc_iotbus_uart_set_baudrate_p();
- itc_iotbus_uart_set_mode_p();
- itc_iotbus_uart_set_flowcontrol_p();
- itc_iotbus_uart_write_read_p();
- itc_iotbus_uart_flush_p();
-
+ itc_iotbus_uart_init_stop_p();
+ itc_iotbus_uart_set_baudrate_p();
+ itc_iotbus_uart_set_mode_p();
+ itc_iotbus_uart_set_flowcontrol_p();
+ itc_iotbus_uart_write_read_p();
+ itc_iotbus_uart_flush_p();
#endif
- return 0;
+ return 0;
}
MEMORY_MEASURE_PRINT(sizeof(TYPE) + 1); \
mbedtls_printf("\n"); \
} \
-} while(0)
+} while (0)
struct pthread_arg {
int argc;
* @brief Callback registration function for Reset-Confirmation and Reset-Result functions.
* @remarks Only one callback function can be set with this API.\n
* If multiple callbacks are set, the last one is registered only.\n
- And the callbacks are called in the internal thread, which is not detached,\n
+ * And the callbacks are called in the internal thread, which is not detached,\n
* so application should return it to get the next callbacks.
* @param[in] confirm_cb Callback function that will be called to get the user's input when reset is triggered.
* @param[in] result_cb Callback function that will be called after the reset process is done.
}
sscanf(cp, "%d.%d.%d.%d", &check_range[0], &check_range[1], &check_range[2], &check_range[3]);
for (idx = 0; idx < 4; idx++) {
- if (check_range[idx] < 0 || check_range[idx] > 255 ) {
+ if (check_range[idx] < 0 || check_range[idx] > 255) {
return 0;
}
}
projects / rtos / tinyara.git / commitdiff