/**@brief Open connection with the Audio service. * * @details The function opens the audio service and provides message * handler function pointer. * @param[in] queue Queue of messages. * @param[in] service Pointer to ui service. * @return none. */ void ui_audio_svc_open(void *queue, service_t *service) { ui_svc = service; ui_audio_svc = cfw_client_init(queue, ui_audio_svc_handle_message, UISVC_AUDIO_CLIENT); if (ui_audio_svc == NULL) force_panic(); cfw_open_service_conn(ui_audio_svc, AUDIO_SVC_ID, "UI SVC Audio"); }
int main(void) { queue = queue_create(10, NULL); cfw_service_mgr_init(queue); sanity_test_list(); test_timers(); test_service_init(queue, TEST_SERVICE_ID); pr_info(LOG_MODULE_MAIN, "End of init...."); pr_info(LOG_MODULE_MAIN, "Start of real stuff...\n"); cfw_client_t *c = cfw_client_init(queue, my_handle_message, "Client 1"); //cfw_client_t *c2 = cfw_client_init(queue, my_handle_message, "Client 2"); cfw_open_service_conn(c, TEST_SERVICE_ID, "Conn1"); cfw_open_service_conn(c, TEST_SERVICE_ID, "Conn2"); _cfw_loop(queue); return EXIT_SUCCESS; }
static void start_service(struct _srv_cb *p_cb, int svc_id) { printf("server_main::%s(): BLE_CORE_SERVICE_ID available:" " priv: 0x%p, svc_id: %d\n", __func__, p_cb, svc_id); int i; for (i = 0; i < MAX_CLIENT_SVC; i++) if ((p_cb->client_svc_cb[i].svc_id != svc_id) && (p_cb->client_svc_cb[i].state == 0)) break; sleep(1); printf("%s(): slot found: %d\n", __func__, i); if (i < MAX_CLIENT_SVC) { p_cb->client_svc_cb[i].state = 1; p_cb->client_svc_cb[i].svc_id = svc_id; cfw_open_service_conn(p_cb->client, svc_id, &p_cb->client_svc_cb[i]); } else { printf("server_main::%s(): NO free srv_cb slot" " found for svc_id: %d\n", __func__, svc_id); } }
DRIVER_API_RC tst_gpio_srv_test_single_edge(cfw_client_t *gpio_client, unsigned int service_id, unsigned int input_pin, unsigned int output_pin) { cfw_service_conn_t *gpio_service_conn = NULL; if (!cfw_service_registered(service_id)) { cu_print("soc gpio register failed\n"); return DRV_RC_FAIL; } cfw_open_service_conn(gpio_client, service_id, &gpio_service_conn); SRV_WAIT((!gpio_service_conn), 1000); CU_ASSERT("TST_GPIO open service failed", (gpio_service_conn)); if(gpio_service_conn == NULL) { return DRV_RC_FAIL; } TEST_GPIO(configure, "TST_GPIO config failed", gpio_service_conn, output_pin, 1, "cfg_output single edge"); // ******************************** // * Test rising edge * // ******************************** TEST_GPIO(set_state, "TST_GPIO set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1 re"); TEST_GPIO(listen, "TST_GPIO listen failed (re)", gpio_service_conn, input_pin, RISING_EDGE, DEB_OFF, "listen re"); tst_gpio_event = 0; TEST_GPIO(set_state, "TST_GPIO set 2 failed (re)", gpio_service_conn, output_pin, 0, "set_output 0 re"); // Check no event CU_ASSERT("TST_GPIO RE irq wrong detected", (tst_gpio_event == 0)); if(tst_gpio_event) { return DRV_RC_FAIL; } // Check GPIO port value TEST_GPIO(get_state, "TST_GPIO get 1 failed (re)", gpio_service_conn, "get_output 1 re"); CU_ASSERT("TST_GPIO RE wrong port state detected (should be LOW)", (!(tst_gpio_get_value & (1<<input_pin)))); if(tst_gpio_get_value & (1<<input_pin)) { return DRV_RC_FAIL; } TEST_GPIO(set_state, "TST_GPIO set 3 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1 re"); // Check event CU_ASSERT("TST_GPIO RE irq RE not detected", (tst_gpio_event == 1)); if(tst_gpio_event != 1) { return DRV_RC_FAIL; } // Check GPIO port value TEST_GPIO(get_state, "TST_GPIO get 2 failed (re)", gpio_service_conn, "get_output 2 re"); CU_ASSERT("TST_GPIO RE wrong port state detected (should be HIGH)", (tst_gpio_get_value & (1<<input_pin))); if(!(tst_gpio_get_value & (1<<input_pin))) { return DRV_RC_FAIL; } TEST_GPIO(unlisten, "TST_GPIO unlisten failed (re)", gpio_service_conn, input_pin, "unlisten re"); // ******************************** // * Test falling edge * // ******************************** TEST_GPIO(set_state, "TST_GPIO set 1 failed (fe)", gpio_service_conn, output_pin, 0, "set_output 1 fe"); TEST_GPIO(listen, "TST_GPIO listen failed (fe)", gpio_service_conn, input_pin, FALLING_EDGE, DEB_OFF, "listen fe"); tst_gpio_event = 0; // Check no event TEST_GPIO(set_state, "TST_GPIO set 2 failed (fe)", gpio_service_conn, output_pin, 1, "set_output 0 fe"); CU_ASSERT("TST_GPIO FE irq wrong detected", (tst_gpio_event == 0)); if(tst_gpio_event) { return DRV_RC_FAIL; } // Check GPIO port value TEST_GPIO(get_state, "TST_GPIO get 1 failed (fe)", gpio_service_conn, "get_output 1 fe"); CU_ASSERT("TST_GPIO FE wrong port state detected (should be HIGH)", (tst_gpio_get_value & (1<<input_pin))); if(!(tst_gpio_get_value & (1<<input_pin))) { return DRV_RC_FAIL; } // Check event TEST_GPIO(set_state, "TST_GPIO set 3 failed (fe)", gpio_service_conn, output_pin, 0, "set_output 1 fe"); CU_ASSERT("TST_GPIO FE irq not detected", (tst_gpio_event == 1)); if(tst_gpio_event != 1) { return DRV_RC_FAIL; } // Check GPIO port value TEST_GPIO(get_state, "TST_GPIO get 2 failed (fe)", gpio_service_conn, "get_output 2 fe"); CU_ASSERT("TST_GPIO FE wrong port state detected (should be LOW)", (!(tst_gpio_get_value & (1<<input_pin)))); if(tst_gpio_get_value & (1<<input_pin)) { return DRV_RC_FAIL; } TEST_GPIO(unlisten, "TST_GPIO unlisten failed (fe)", gpio_service_conn, input_pin, "unlisten fe"); // Deconfigure output pin TEST_GPIO(set_state, "TST_GPIO set deconfig failed", gpio_service_conn, output_pin, 0, "set_output 0"); TEST_GPIO(configure, "TST_GPIO end config failed", gpio_service_conn, output_pin, 0, "cfg_input single edge"); cu_print("GPIO single edge test done\n"); return DRV_RC_OK; }
void sensor_core_svc_rsp_handle(struct cfw_message *p_msg, void *p_param) { switch (CFW_MESSAGE_ID(p_msg)) { case MSG_ID_CFW_OPEN_SERVICE_RSP: { cfw_open_conn_rsp_msg_t *cnf = (cfw_open_conn_rsp_msg_t *)p_msg; p_sc_service_conn = (cfw_service_conn_t *)cnf->service_conn; if (NULL == p_sc_service_conn) { SS_PRINT_ERR("Opening Score_svc failed"); return; } SS_PRINT_LOG("Opening Score_svc successful"); if (core_connected_cb) { core_connected_cb(core_connected_cb_data); } } break; case MSG_ID_CFW_REGISTER_EVT_RSP: { SS_PRINT_LOG("Register evt!!"); } break; case MSG_ID_CFW_REGISTER_SVC_AVAIL_EVT_RSP: break; case MSG_ID_CFW_SVC_AVAIL_EVT: { uint16_t service_id = ((cfw_svc_available_evt_msg_t *)p_msg)->service_id; SS_PRINT_LOG("AVAIL_EVT: %d", service_id); if (ARC_SC_SVC_ID == service_id) { cfw_open_service_conn(p_client, ARC_SC_SVC_ID, NULL); } else { SS_PRINT_LOG("AVAIL_EVT:service_id is error"); } } break; case MSG_ID_SENSOR_SERVICE_START_SCANNING_RSP: { SS_PRINT_LOG("[%s]Scanning rsp", __func__); } break; case MSG_ID_SENSOR_SERVICE_START_SCANNING_EVT: { sensor_service_scan_event_t *p_evt = (sensor_service_scan_event_t *)p_msg; uint8_t sensor_type = (uint8_t)(((uint32_t)p_evt->handle) >> 8); uint8_t sensor_id = (uint8_t)(((uint32_t)p_evt->handle) & 0xff); send_scan_evt_message_to_clients(sensor_type, sensor_id); SS_PRINT_LOG("[%s]Scanning evt", __func__); } break; case MSG_ID_SENSOR_SERVICE_STOP_SCANNING_RSP: { SS_PRINT_LOG("[%s]Stop SCANNING RSP", __func__); } break; case MSG_ID_SENSOR_SERVICE_PAIR_RSP: { SS_PRINT_LOG("[%s]PAIR RSP", __func__); } break; case MSG_ID_SENSOR_SERVICE_SUBSCRIBE_DATA_RSP: { sensor_service_message_general_rsp_t *p_rsp = (sensor_service_message_general_rsp_t *)p_msg; uint8_t sensor_type = (uint8_t)(((uint32_t)p_rsp->handle) >> 8); uint8_t sensor_id = (uint8_t)(((uint32_t)p_rsp->handle) & 0xff); SS_PRINT_LOG("SUBSCRIBE_DATA_RSP:type=%d,id=%d,status=%d]", \ sensor_type, sensor_id, \ p_rsp->status); send_sensor_subscribing_rsp_message_to_clients(sensor_type, sensor_id, p_rsp->status); } break; case MSG_ID_SENSOR_SERVICE_SUBSCRIBE_DATA_EVT: { sensor_service_subscribe_data_event_t *p_evt = (sensor_service_subscribe_data_event_t *)p_msg; sensor_service_sensor_data_header_t *p_data_header = &p_evt->sensor_data_header; uint8_t sensor_type = (uint8_t)(((uint32_t)p_evt->handle) >> 8); uint8_t sensor_id = (uint8_t)(((uint32_t)p_evt->handle) & 0xff); send_sensor_subscribing_evt_message_to_clients( sensor_type, sensor_id, 0, \ p_data_header-> timestamp, \ (void *) p_data_header->data, \ p_data_header-> data_length); } break; case MSG_ID_SENSOR_SERVICE_UNSUBSCRIBE_DATA_RSP: { SS_PRINT_LOG("[%s]UNSUBSCRIBED RSP", __func__); ss_sensor_unsubscribe_data_rsp_t *p_rsp = (ss_sensor_unsubscribe_data_rsp_t *)p_msg; uint8_t sensor_type = GET_SENSOR_TYPE(p_rsp->handle); uint8_t sensor_id = GET_SENSOR_ID(p_rsp->handle); send_sensor_unsubscribing_rsp_message_to_clients(sensor_type, sensor_id, p_rsp->status); } break; case MSG_ID_SENSOR_SERVICE_UNPAIR_RSP: break; case MSG_ID_SS_SENSOR_UNLINK_EVT: break; default: SS_PRINT_ERR("[%s]unhandled msg %d", __func__, CFW_MESSAGE_ID(p_msg)); break; } cfw_msg_free(p_msg); }
void test_handle_message(struct cfw_message * msg, void * param) { cfw_log("%s:%s for param: %s conn:%p id:%d\n", __FILE__, __func__, (char*) param, msg->conn, CFW_MESSAGE_ID(msg)); //cfw_dump_message(msg); switch (CFW_MESSAGE_ID(msg)) { case MSG_ID_CFW_REGISTER_SVC_AVAIL_EVT_RSP: break; case MSG_ID_CFW_SVC_AVAIL_EVT: { int svc_id = ((cfw_svc_available_evt_msg_t *)msg)->service_id; if (svc_id == SOC_GPIO_SERVICE_ID) { cfw_open_service_conn(client, SOC_GPIO_SERVICE_ID, "Conn1"); } break; } case MSG_ID_CFW_OPEN_SERVICE_RSP: { cfw_log("%s:%s for conn: %s\n", __FILE__, __func__, (char*) CFW_MESSAGE_PRIV(msg)); cfw_open_conn_rsp_msg_t * cnf = (cfw_open_conn_rsp_msg_t*) msg; gpio_service_conn = cnf->service_conn; gpio_configure(gpio_service_conn, 26, 1, NULL); break; } case MSG_ID_GPIO_CONFIGURE_RSP: gpio_set_state(gpio_service_conn, 26, 1, NULL); break; case MSG_ID_GPIO_SET_RSP: { int val; void * next; if (!((int) CFW_MESSAGE_PRIV(msg))) { val = 0; next = (void*) 1; } else { val = 1; next = (void*) 0; } printf("Got response: %d %d \n", val, (int) next); if (count ++ > 100) { cfw_close_service_conn(gpio_service_conn, NULL); } else { gpio_set_state(gpio_service_conn, 26, val, next); } } break; case MSG_ID_CFW_CLOSE_SERVICE_RSP: { cfw_close_conn_rsp_msg_t * resp = (cfw_close_conn_rsp_msg_t*) msg; cfw_log("%s: res: %d\n", __func__, resp->rsp_header.status); exit(0); } break; default: { cfw_log("%s: Unhandled message: %d\n", __func__, CFW_MESSAGE_ID(msg)); break; } } cfw_msg_free(msg); }
void client_handle_message(struct cfw_message *msg, void *param) { _cfw_client_t *c = (_cfw_client_t *)param; bool handled = false; switch (CFW_MESSAGE_ID(msg)) { case MSG_ID_CFW_REGISTER_SVC_AVAIL_EVT_RSP: if (get_conn_helper(c, msg->priv)) handled = true; break; case MSG_ID_CFW_SVC_AVAIL_EVT: { cfw_svc_available_evt_msg_t *evt = (cfw_svc_available_evt_msg_t *)msg; if (get_conn_helper(c, evt->header.priv)) { cfw_open_service_conn(c, evt->service_id, evt->header.priv); handled = true; } } break; case MSG_ID_CFW_OPEN_SERVICE_RSP: { cfw_open_conn_rsp_msg_t *cnf = (cfw_open_conn_rsp_msg_t *)msg; /** Make client handle point to server handle */ ((cfw_service_conn_t *)cnf->service_conn)->server_handle = cnf->svc_server_handle; /** Initialize service port. */ ((cfw_service_conn_t *)cnf->service_conn)->port = cnf->port; #ifndef CONFIG_PORT_IS_MASTER /* Set local port and cpu id */ if (get_cpu_id() != cnf->cpu_id) { port_set_port_id(cnf->port); port_set_cpu_id(cnf->port, cnf->cpu_id); } #endif struct conn_helper_data *helper = get_conn_helper( c, cnf->header.priv); if (helper != NULL) { helper->service_conn = (cfw_service_conn_t *)cnf->service_conn; if (helper->event_count > 0) { cfw_register_events(helper->service_conn, helper->events, helper->event_count, helper); } else { /* call the helper callback and free it */ cfw_open_service_helper_done(c, helper); } handled = true; } break; } case MSG_ID_CFW_REGISTER_EVT_RSP: { struct conn_helper_data *helper = get_conn_helper( c, CFW_MESSAGE_PRIV(msg)); if (helper != NULL) { helper->cb(helper->service_conn, helper->cb_data); list_remove(&c->helper_list, &helper->list); bfree(helper); handled = true; } } break; case MSG_ID_CFW_CLOSE_SERVICE_RSP: { /* Free client-side conn */ bfree(msg->conn); break; } default: //Nothing to do break; } if (handled) /* message handled here: free it */ bfree(msg); else { /* defer processing to message handler */ if (CFW_MESSAGE_CB(msg)) { /* A specific callback was specified for this message */ CFW_MESSAGE_CB(msg) (msg); } else { /* Call client global message handler */ c->handle_msg(msg, c->data); } } }
int press_simulation(unsigned int service_id, unsigned int input_pin, unsigned int output_pin) { cfw_service_conn_t *gpio_service_conn = NULL; cfw_client_t *gpio_client = cfw_client_init( get_test_queue(), pwrbtn_tst_handle_msg, NULL); if (!cfw_service_registered(service_id)) { cu_print("TST_PWRBTN: ss gpio service not registered\n"); return DRV_RC_FAIL; } cfw_open_service_conn(gpio_client, service_id, &gpio_service_conn); SRV_WAIT((!gpio_service_conn), 2000); CU_ASSERT("TST_PWRBTN: can not open ss gpio service", (gpio_service_conn)); if (gpio_service_conn == NULL) { return DRV_RC_FAIL; } /* The configuration put the pin to 0 => the pin have to be set to 1 * before first press simulation */ TEST_PWRBTN(configure, "TST_PWRBTN: gpio configuration failed", gpio_service_conn, output_pin, 1, "SS pin 2 output"); SRV_WAIT((!tst_pwrbtn_configure), 2000); TEST_PWRBTN(set_state, "TST_PWRBTN: set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1"); /* wait state response */ SRV_WAIT((!tst_pwrbtn_set_state), 2000); /* wait 3s */ local_task_sleep_ms(3000); tst_step = VERY_SH_PRESS; cu_print("Start pattern with press_duration = 700ms\n"); TEST_PWRBTN(set_state, "TST_PWRBTN: set 0 failed (re)", gpio_service_conn, output_pin, 0, "set_output 0"); local_task_sleep_ms(700); TEST_PWRBTN(set_state, "TST_PWRBTN: set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1"); /* wait pattern detection */ SRV_WAIT((!tst_very_short), 2000); /* wait 3s */ local_task_sleep_ms(3000); cu_print("Start pattern with press_duration = 2500ms\n"); tst_step = SH_PRESS; TEST_PWRBTN(set_state, "TST_PWRBTN: set 0 failed (re)", gpio_service_conn, output_pin, 0, "set_output 0"); local_task_sleep_ms(2500); TEST_PWRBTN(set_state, "TST_PWRBTN: set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1"); /* wait pattern detection */ SRV_WAIT((!tst_short), 2000); /* wait 3s */ local_task_sleep_ms(3000); cu_print("Start pattern with press_duration = 4000ms\n"); tst_step = SINGLE_PRESS; TEST_PWRBTN(set_state, "TST_PWRBTN: set 0 failed (re)", gpio_service_conn, output_pin, 0, "set_output 0"); local_task_sleep_ms(4000); TEST_PWRBTN(set_state, "TST_PWRBTN: set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1"); /* wait pattern detection */ SRV_WAIT((!tst_single), 2000); /* wait 3s */ local_task_sleep_ms(3000); cu_print("Start pattern with press_duration = 7000ms\n"); tst_step = L_PRESS; TEST_PWRBTN(set_state, "TST_PWRBTN: set 0 failed (re)", gpio_service_conn, output_pin, 0, "set_output 0"); local_task_sleep_ms(7000); TEST_PWRBTN(set_state, "TST_PWRBTN: set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1"); /* wait pattern detection */ SRV_WAIT((!tst_long), 2000); /* wait 3s */ local_task_sleep_ms(3000); cu_print("Start pattern with press_duration = 12000ms\n"); tst_step = VERY_L_PRESS; TEST_PWRBTN(set_state, "TST_PWRBTN: set 0 failed (re)", gpio_service_conn, output_pin, 0, "set_output 0"); local_task_sleep_ms(12000); TEST_PWRBTN(set_state, "TST_PWRBTN: set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1"); /* wait 3s */ local_task_sleep_ms(3000); /* Start failed double press pattern : very_short_press + 550 ms delay max + short_press */ cu_print("Start double pattern press failed...\n"); tst_step = DBLE_PRESS_FAIL_1; TEST_PWRBTN(set_state, "TST_PWRBTN: set 0 failed (re)", gpio_service_conn, output_pin, 0, "set_output 0"); local_task_sleep_ms(700); TEST_PWRBTN(set_state, "TST_PWRBTN: set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1"); /* wait pattern detection */ SRV_WAIT((!tst_double_fail_1), 2000); /* wait between the very short press */ local_task_sleep_ms(550); tst_step = DBLE_PRESS_FAIL_2; TEST_PWRBTN(set_state, "TST_PWRBTN: set 0 failed (re)", gpio_service_conn, output_pin, 0, "set_output 0"); local_task_sleep_ms(2700); TEST_PWRBTN(set_state, "TST_PWRBTN: set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1"); /* wait pattern detection */ SRV_WAIT((!tst_double_fail_2), 2000); /* wait 3s */ local_task_sleep_ms(3000); cu_print("Start too short pattern with duration = 300ms\n"); tst_step = TOO_SHORT_PRESS; TEST_PWRBTN(set_state, "TST_PWRBTN: set 0 failed (re)", gpio_service_conn, output_pin, 0, "set_output 0"); local_task_sleep_ms(300); TEST_PWRBTN(set_state, "TST_PWRBTN: set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1"); /* wait pattern detection */ SRV_WAIT((!tst_double_fail_2), 2000); /* wait 3s */ local_task_sleep_ms(3000); /* Start double press pattern : very_short_press + 350 ms delay max + very_short_press */ cu_print("Start double pattern press...\n"); tst_step = DBLE_PRESS; TEST_PWRBTN(set_state, "TST_PWRBTN: set 0 failed (re)", gpio_service_conn, output_pin, 0, "set_output 0"); local_task_sleep_ms(700); TEST_PWRBTN(set_state, "TST_PWRBTN: set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1"); /* wait between the very short press */ local_task_sleep_ms(350); TEST_PWRBTN(set_state, "TST_PWRBTN: set 0 failed (re)", gpio_service_conn, output_pin, 0, "set_output 0"); local_task_sleep_ms(900); TEST_PWRBTN(set_state, "TST_PWRBTN: set 1 failed (re)", gpio_service_conn, output_pin, 1, "set_output 1"); /* wait pattern detection */ SRV_WAIT((!tst_double), 2000); /* wait 2s */ local_task_sleep_ms(2000); cfw_close_service_conn(gpio_service_conn, NULL); return DRV_RC_OK; }