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