From b0945fd222eef5d6054b75ec2b5a582969e3d272 Mon Sep 17 00:00:00 2001 From: Jin Yoon Date: Mon, 3 Jul 2017 20:15:14 +0900 Subject: [PATCH] MCC Pattern : Initial version Change-Id: I6a839878b65784fd92b570056d09b61cb7d612fd --- CMakeLists.txt | 1 - inc/controller.h | 6 - inc/model.h | 17 +- inc/model/model_infrared_motion_sensor.h | 8 +- .../model_infrared_obstacle_avoidance_sensor.h | 8 +- inc/model/model_touch_sensor.h | 8 +- inc/model/model_ultrasonic_sensor.h | 6 +- src/controller.c | 174 +++++++++++++-------- src/model.c | 157 +++++++++++++------ src/model/model_infrared_motion_sensor.c | 43 +++-- .../model_infrared_obstacle_avoidance_sensor.c | 40 +++-- src/model/model_touch_sensor.c | 41 +++-- src/model/model_ultrasonic_sensor.c | 74 +++++---- 13 files changed, 365 insertions(+), 218 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 1a547ea..d2c376c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,7 +34,6 @@ ADD_EXECUTABLE(${PROJECT_NAME} ${PROJECT_ROOT_DIR}/src/controller.c ${PROJECT_ROOT_DIR}/src/connectivity.c ${PROJECT_ROOT_DIR}/src/model.c - ${PROJECT_ROOT_DIR}/src/main.c ${PROJECT_ROOT_DIR}/src/model/model_ultrasonic_sensor.c ${PROJECT_ROOT_DIR}/src/model/model_infrared_motion_sensor.c ${PROJECT_ROOT_DIR}/src/model/model_infrared_obstacle_avoidance_sensor.c diff --git a/inc/controller.h b/inc/controller.h index aef6e47..7ecdc1d 100644 --- a/inc/controller.h +++ b/inc/controller.h @@ -19,10 +19,4 @@ #ifndef __POSITION_FINDER_CONTROLLER_H__ #define __POSITION_FINDER_CONTROLLER_H__ -typedef int (*controller_event_cb)(const char *event_name, void *event_info, void *data); - -extern int controller_register_event_cb(const char *event_name, controller_event_cb event_cb, void *data); -extern int controller_unregister_event_cb(const char *event_name, controller_event_cb event_cb); -extern int controller_send_event(const char *event_name, void *event_info); - #endif /* __POSITION_FINDER_CONTROLLER_H__ */ diff --git a/inc/model.h b/inc/model.h index 074dfe0..def3713 100644 --- a/inc/model.h +++ b/inc/model.h @@ -27,13 +27,18 @@ enum sensor_type { }; typedef enum sensor_type sensor_type_e; -extern int model_init(sensor_type_e sensor_type); -extern void model_fini(void); +typedef struct _model_sensor_s model_sensor_s; +typedef model_sensor_s *model_sensor_h; -extern int model_alloc(void **data); +extern int model_init(const char *id, sensor_type_e sensor_type, int gpio_num1, int gpio_num2, model_sensor_h *out_info); +extern void model_fini(model_sensor_h info); -extern int model_read_int_value(int *out_value); -extern int model_read_double_value(double *out_value); -extern int model_write(void *data); +extern int model_read_int_value(model_sensor_h info, int *out_value); +extern int model_read_double_value(model_sensor_h info, double *out_value); + +extern int model_list_add_sensor(model_sensor_h info); +extern int model_list_remove_sensor(model_sensor_h info); +extern int model_list_get_sensor(const char *id, model_sensor_h *out_info); +extern int model_list_foreach(void (*cb)(model_sensor_h info)); #endif /* __POSITION_FINDER_MODEL_H__ */ diff --git a/inc/model/model_infrared_motion_sensor.h b/inc/model/model_infrared_motion_sensor.h index 4ff90c7..6667a96 100644 --- a/inc/model/model_infrared_motion_sensor.h +++ b/inc/model/model_infrared_motion_sensor.h @@ -19,11 +19,9 @@ #ifndef __POSITION_FINDER_MODEL_INFRARED_MOTION_SENSOR_H__ #define __POSITION_FINDER_MODEL_INFRARED_MOTION_SENSOR_H__ -typedef struct infrared_motion_event infrared_motion_event_s; +extern int model_init_infrared_motion_sensor(int gpio_num, void **peripheral_info); +extern void model_fini_infrared_motion_sensor(void *peripheral_info); -extern int model_init_infrared_motion_sensor(void); -extern void model_fini_infrared_motion_sensor(void); - -extern int model_read_infrared_motion_sensor(int *out_value); +extern int model_read_infrared_motion_sensor(void *peripheral_info, int *out_value); #endif /* __POSITION_FINDER_MODEL_INFRARED_MOTION_SENSOR_H__ */ diff --git a/inc/model/model_infrared_obstacle_avoidance_sensor.h b/inc/model/model_infrared_obstacle_avoidance_sensor.h index bfba8f9..0833684 100644 --- a/inc/model/model_infrared_obstacle_avoidance_sensor.h +++ b/inc/model/model_infrared_obstacle_avoidance_sensor.h @@ -19,11 +19,9 @@ #ifndef __POSITION_FINDER_MODEL_INFRARED_OBSTACLE_AVOIDANCE_SENSOR_H__ #define __POSITION_FINDER_MODEL_INFRARED_OBSTACLE_AVOIDANCE_SENSOR_H__ -typedef struct infrared_obstacle_avoidance_event infrared_obstacle_avoidance_event_s; +extern int model_init_infrared_obstacle_avoidance_sensor(int gpio_num, void **peripheral_info); +extern void model_fini_infrared_obstacle_avoidance_sensor(void *peripheral_info); -extern int model_init_infrared_obstacle_avoidance_sensor(void); -extern void model_fini_infrared_obstacle_avoidance_sensor(void); - -extern int model_read_infrared_obstacle_avoidance_sensor(int *out_value); +extern int model_read_infrared_obstacle_avoidance_sensor(void *peripheral_info, int *out_value); #endif /* __POSITION_FINDER_MODEL_INFRARED_OBSTACLE_AVOIDANCE_SENSOR_H__ */ diff --git a/inc/model/model_touch_sensor.h b/inc/model/model_touch_sensor.h index 4be2525..263bf62 100644 --- a/inc/model/model_touch_sensor.h +++ b/inc/model/model_touch_sensor.h @@ -19,11 +19,9 @@ #ifndef __POSITION_FINDER_MODEL_TOUCH_SENSOR_H__ #define __POSITION_FINDER_MODEL_TOUCH_SENSOR_H__ -typedef struct touch_event touch_event_s; +extern int model_init_touch_sensor(int gpio_num, void **peripheral_info); +extern void model_fini_touch_sensor(void *peripheral_info); -extern int model_init_touch_sensor(void); -extern void model_fini_touch_sensor(void); - -extern int model_read_touch_sensor(int *out_value); +extern int model_read_touch_sensor(void *peripheral_info, int *out_value); #endif /* __POSITION_FINDER_MODEL_TOUCH_SENSOR_H__ */ diff --git a/inc/model/model_ultrasonic_sensor.h b/inc/model/model_ultrasonic_sensor.h index 93149af..d58737f 100644 --- a/inc/model/model_ultrasonic_sensor.h +++ b/inc/model/model_ultrasonic_sensor.h @@ -19,8 +19,8 @@ #ifndef __POSITION_FINDER_MODEL_ULTRASONIC_SENSOR_H__ #define __POSITION_FINDER_MODEL_ULTRASONIC_SENSOR_H__ -extern int model_init_ultrasonic_sensor(void); -extern void model_fini_ultrasonic_sensor(void); -extern int model_read_ultrasonic_sensor(double *value); +extern int model_init_ultrasonic_sensor(int gpio_num1, int gpio_num2, void **peripheral_info); +extern void model_fini_ultrasonic_sensor(void *peripheral_info); +extern int model_read_ultrasonic_sensor(void *peripheral_info, double *value); #endif /* __POSITION_FINDER_MODEL_ULTRASONIC_SENSOR_H__ */ diff --git a/src/controller.c b/src/controller.c index 7950f7b..121f0a6 100644 --- a/src/controller.c +++ b/src/controller.c @@ -16,90 +16,140 @@ * limitations under the License. */ -#include + +#include +#include +#include +#include +#include #include "log.h" #include "controller.h" +#include "model.h" -struct controller_s { - Eina_List *event_cb_list; -}; -static struct controller_s controller_info; +#define GPIO_NOT_USED -1 +#define GPIO_ULTRASONIC_TRIG_NUM 20 +#define GPIO_ULTRASONIC_ECHO_NUM 21 +#define GPIO_INFRARED_MOTION_NUM 4 -struct _controller_event_cb_info_s { - char *event_name; - controller_event_cb event_cb; - void *data; -}; -typedef struct _controller_event_cb_info_s controller_event_cb_info_s; +typedef struct app_data_s { + model_sensor_h sensor_info; + Ecore_Timer *getter_timer; + void *event; +} app_data; +static Eina_Bool _ultrasonic_getter_timer(void *data) +{ + app_data *ad = data; + +#if 1 + int value = 0; + retv_if(model_read_int_value(ad->sensor_info, &value) == -1, ECORE_CALLBACK_CANCEL); + _I("Ultrasonic Value is [%d]", value); +#else + double value = 0.0; + retv_if(model_read_double_value(ad->sensor_info, &value) == -1, ECORE_CALLBACK_RENEW); + _I("Value is [%f]", value); +#endif + + return ECORE_CALLBACK_RENEW; +} -int controller_register_event_cb(const char *event_name, controller_event_cb event_cb, void *data) +static Eina_Bool _infrared_motion_getter_timer(void *data) { - controller_event_cb_info_s *event_cb_info = NULL; + app_data *ad = data; + +#if 1 + int value = 0; + retv_if(model_read_int_value(ad->sensor_info, &value) == -1, ECORE_CALLBACK_CANCEL); + _I("Infrared Motion Value is [%d]", value); +#else + double value = 0.0; + retv_if(model_read_double_value(ad->sensor_info, &value) == -1, ECORE_CALLBACK_RENEW); + _I("Value is [%f]", value); +#endif + + return ECORE_CALLBACK_RENEW; +} - retv_if(!event_name, -1); - retv_if(!event_cb, -1); +static bool service_app_create(void *data) +{ + model_sensor_h sensor_info = NULL; + app_data *ad = data; - event_cb_info = calloc(1, sizeof(controller_event_cb_info_s)); - retv_if(!event_cb_info, -1); + retv_if(model_init("Ultrasonic", SENSOR_TYPE_ULTRASONIC, GPIO_ULTRASONIC_TRIG_NUM, GPIO_ULTRASONIC_ECHO_NUM, &sensor_info) == -1, false); + ad->sensor_info = sensor_info; - event_cb_info->event_name = strdup(event_name); - goto_if(!event_cb_info->event_name, error); + ad->getter_timer = ecore_timer_add(3.0, _ultrasonic_getter_timer, ad); + if (!ad->getter_timer) { + _D("Failed to add getter timer"); + return false; + } - event_cb_info->event_cb = event_cb; - event_cb_info->data = data; + retv_if(model_init("Infrared_motion", SENSOR_TYPE_INFRARED_MOTION, GPIO_INFRARED_MOTION_NUM, GPIO_NOT_USED, &sensor_info) == -1, false); + ad->sensor_info = sensor_info; - controller_info.event_cb_list = eina_list_append(controller_info.event_cb_list, event_cb_info); + ad->getter_timer = ecore_timer_add(3.0, _infrared_motion_getter_timer, ad); + if (!ad->getter_timer) { + _D("Failed to add getter timer"); + return false; + } - return 0; + return true; +} -error: - if (event_cb_info) free(event_cb_info); +static void service_app_terminate(void *data) +{ + app_data *ad = (app_data *)data; + ecore_timer_del(ad->getter_timer); + model_fini(ad->sensor_info); + free(ad); +} - return -1; +static void service_app_control(app_control_h app_control, void *data) +{ + // Todo: add your code here. } -int controller_unregister_event_cb(const char *event_name, controller_event_cb event_cb) +static void service_app_lang_changed(app_event_info_h event_info, void *user_data) { - controller_event_cb_info_s *event_cb_info = NULL; - const Eina_List *l = NULL; - const Eina_List *ln = NULL; - - retv_if(!event_name, -1); - retv_if(!event_cb, -1); - - EINA_LIST_FOREACH_SAFE(controller_info.event_cb_list, l, ln, event_cb_info) { - if (event_cb_info->event_name - && strcmp(event_cb_info->event_name, event_name) - && event_cb_info->event_cb == event_cb) - { - controller_info.event_cb_list = eina_list_remove(controller_info.event_cb_list, event_cb_info); - break; - } - } + /*APP_EVENT_LANGUAGE_CHANGED*/ +} - return 0; +static void service_app_region_changed(app_event_info_h event_info, void *user_data) +{ + /*APP_EVENT_REGION_FORMAT_CHANGED*/ } -int controller_send_event(const char *event_name, void *event_info) +static void service_app_low_battery(app_event_info_h event_info, void *user_data) { - controller_event_cb_info_s *event_cb_info = NULL; - const Eina_List *l = NULL; - const Eina_List *ln = NULL; - - retv_if(!event_name, -1); - - EINA_LIST_FOREACH_SAFE(controller_info.event_cb_list, l, ln, event_cb_info) { - if (event_cb_info->event_name - && strcmp(event_cb_info->event_name, event_name)) - { - int ret = -1; - ret = event_cb_info->event_cb(event_name, event_info, event_cb_info->data); - if (ret < 0) _E("There were errors sending an event"); - break; - } - } + /*APP_EVENT_LOW_BATTERY*/ +} + +static void service_app_low_memory(app_event_info_h event_info, void *user_data) +{ + /*APP_EVENT_LOW_MEMORY*/ +} + +int main(int argc, char* argv[]) +{ + app_data *ad = NULL; + int ret = 0; + service_app_lifecycle_callback_s event_callback; + app_event_handler_h handlers[5] = {NULL, }; + + ad = calloc(1, sizeof(app_data)); + + event_callback.create = service_app_create; + event_callback.terminate = service_app_terminate; + event_callback.app_control = service_app_control; + + service_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, service_app_low_battery, &ad); + service_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, service_app_low_memory, &ad); + service_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, service_app_lang_changed, &ad); + service_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, service_app_region_changed, &ad); + + ret = service_app_main(argc, argv, &event_callback, ad); - return 0; + return ret; } diff --git a/src/model.c b/src/model.c index b3db6e2..d105691 100644 --- a/src/model.c +++ b/src/model.c @@ -16,9 +16,11 @@ * limitations under the License. */ +#include #include #include #include +#include #include "log.h" #include "model.h" @@ -27,48 +29,48 @@ #include "model/model_infrared_obstacle_avoidance_sensor.h" #include "model/model_touch_sensor.h" -struct _model_s { +struct _model_sensor_s { + char *id; sensor_type_e sensor_type; + int gpio_num[2]; + void *peripheral_info; }; -static struct _model_s model_s; +static struct { + Eina_List *list; +} model_s; -void model_fini(void) +int model_init(const char *id, sensor_type_e sensor_type, int gpio_num1, int gpio_num2, model_sensor_h *out_info) { - switch (model_s.sensor_type) { - case SENSOR_TYPE_ULTRASONIC: - model_fini_ultrasonic_sensor(); - break; - case SENSOR_TYPE_INFRARED_MOTION: - model_fini_infrared_motion_sensor(); - break; - case SENSOR_TYPE_INFRARED_OBSTACLE_AVOIDANCE: - model_fini_infrared_obstacle_avoidance_sensor(); - break; - case SENSOR_TYPE_TOUCH: - model_fini_touch_sensor(); - break; - default: - break; - } -} + model_sensor_h info = NULL; + int ret = -1; -int model_init(sensor_type_e sensor_type) -{ - int ret = 0; - model_s.sensor_type = sensor_type; + retv_if(!id, -1); + + info = calloc(1, sizeof(model_sensor_s)); + retv_if(!info, -1); + *out_info = info; + + info->sensor_type = sensor_type; + info->id = strdup(id); + goto_if(!info->id, error); + + info->gpio_num[0] = gpio_num1; + info->gpio_num[1] = gpio_num2; + goto_if(gpio_num1 == -1, error); switch (sensor_type) { case SENSOR_TYPE_ULTRASONIC: - ret = model_init_ultrasonic_sensor(); + goto_if(gpio_num2 == -1, error); + ret = model_init_ultrasonic_sensor(gpio_num1, gpio_num2, &info->peripheral_info); break; case SENSOR_TYPE_INFRARED_MOTION: - ret = model_init_infrared_motion_sensor(); + ret = model_init_infrared_motion_sensor(gpio_num1, &info->peripheral_info); break; case SENSOR_TYPE_INFRARED_OBSTACLE_AVOIDANCE: - ret = model_init_infrared_obstacle_avoidance_sensor(); + ret = model_init_infrared_obstacle_avoidance_sensor(gpio_num1, &info->peripheral_info); break; case SENSOR_TYPE_TOUCH: - model_init_touch_sensor(); + ret = model_init_touch_sensor(gpio_num1, &info->peripheral_info); break; default: break; @@ -79,40 +81,50 @@ int model_init(sensor_type_e sensor_type) return 0; error: - model_fini(); + if (info->id) free(info->id); + if (info) free(info); + *out_info = NULL; return -1; } -int model_alloc(void **data) +void model_fini(model_sensor_h info) { - switch (model_s.sensor_type) { + ret_if(!info); + + switch (info->sensor_type) { case SENSOR_TYPE_ULTRASONIC: + model_fini_ultrasonic_sensor(info->peripheral_info); break; case SENSOR_TYPE_INFRARED_MOTION: + model_fini_infrared_motion_sensor(info->peripheral_info); + break; case SENSOR_TYPE_INFRARED_OBSTACLE_AVOIDANCE: + model_fini_infrared_obstacle_avoidance_sensor(info->peripheral_info); + break; case SENSOR_TYPE_TOUCH: - _E("No function for allocation"); + model_fini_touch_sensor(info->peripheral_info); break; default: break; } - return 0; + free(info->id); + free(info); } -int model_read_int_value(int *out_value) +int model_read_int_value(model_sensor_h info, int *out_value) { int ret = 0; - switch (model_s.sensor_type) { + switch (info->sensor_type) { case SENSOR_TYPE_ULTRASONIC: - ret = model_read_infrared_obstacle_avoidance_sensor(out_value); + ret = model_read_infrared_obstacle_avoidance_sensor(info, out_value); break; case SENSOR_TYPE_INFRARED_MOTION: - ret = model_read_infrared_motion_sensor(out_value); + ret = model_read_infrared_motion_sensor(info, out_value); break; case SENSOR_TYPE_TOUCH: - ret = model_read_touch_sensor(out_value); + ret = model_read_touch_sensor(info, out_value); break; default: break; @@ -126,13 +138,13 @@ int model_read_int_value(int *out_value) return 0; } -int model_read_double_value(double *out_value) +int model_read_double_value(model_sensor_h info, double *out_value) { int ret = 0; - switch (model_s.sensor_type) { + switch (info->sensor_type) { case SENSOR_TYPE_ULTRASONIC: - ret = model_read_ultrasonic_sensor(out_value); + ret = model_read_ultrasonic_sensor(info, out_value); break; default: _E("There is no data to retrieve"); @@ -147,16 +159,61 @@ int model_read_double_value(double *out_value) return 0; } -int model_write(void *data) +int model_list_add_sensor(model_sensor_h info) { - switch (model_s.sensor_type) { - case SENSOR_TYPE_ULTRASONIC: - case SENSOR_TYPE_INFRARED_MOTION: - case SENSOR_TYPE_TOUCH: - _E("No function for writing"); - break; - default: - break; + Eina_List *l, *ln; + model_sensor_h temp = NULL; + + retv_if(!info, -1); + retv_if(!info->id, -1); + + EINA_LIST_FOREACH_SAFE(model_s.list, l, ln, temp) { + retv_if(!temp->id, -1); + if (!strcmp(temp->id, info->id)) { + _E("That id[%s] already exists.", info->id); + return -1; + } + } + model_s.list = eina_list_append(model_s.list, info); + return 0; +} + +int model_list_remove_sensor(model_sensor_h info) +{ + retv_if(!info, -1); + model_s.list = eina_list_remove(model_s.list, info); + return 0; +} + +int model_list_get_sensor(const char *id, model_sensor_h *out_info) +{ + Eina_List *l, *ln; + model_sensor_h temp = NULL; + + retv_if(!id, -1); + + EINA_LIST_FOREACH_SAFE(model_s.list, l, ln, temp) { + retv_if(!temp->id, -1); + if (!strcmp(temp->id, id)) { + _E("That id[%s] already exists.", id); + *out_info = temp; + return 0; + } + } + + *out_info = NULL; + return -1; +} + +int model_list_foreach(void (*cb)(model_sensor_h info)) +{ + Eina_List *l, *ln; + model_sensor_h temp = NULL; + + retv_if(!cb, -1); + + EINA_LIST_FOREACH_SAFE(model_s.list, l, ln, temp) { + cb(temp); } return 0; diff --git a/src/model/model_infrared_motion_sensor.c b/src/model/model_infrared_motion_sensor.c index 3236792..52d9b83 100644 --- a/src/model/model_infrared_motion_sensor.c +++ b/src/model/model_infrared_motion_sensor.c @@ -16,6 +16,7 @@ * limitations under the License. */ +#include #include #include #include @@ -23,47 +24,59 @@ #include "log.h" #include "model/model_infrared_motion_sensor.h" -#define GPIO_NUM 4 - -struct model_infrared_motion_sensor { +struct _model_infrared_motion_sensor_s { peripheral_gpio_h gpio; }; -static struct model_infrared_motion_sensor model_infrared_motion_sensor_s; +typedef struct _model_infrared_motion_sensor_s model_infrared_motion_sensor_s; -void model_fini_infrared_motion_sensor(void) +void model_fini_infrared_motion_sensor(void *peripheral_info) { + model_infrared_motion_sensor_s *info = peripheral_info; + + ret_if(!info); + _I("Infrared Motion Sensor is finishing..."); - if (model_infrared_motion_sensor_s.gpio) - peripheral_gpio_close(model_infrared_motion_sensor_s.gpio); + + if (info->gpio) + peripheral_gpio_close(info->gpio); + + free(info); } -int model_init_infrared_motion_sensor(void) +int model_init_infrared_motion_sensor(int gpio_num, void **peripheral_info) { + model_infrared_motion_sensor_s *info = NULL; int ret = 0; _I("Infrared Motion Sensor is initializing..."); - /* GPIO for Ultrasonic Sensor's Transmit */ - ret = peripheral_gpio_open(GPIO_NUM, &model_infrared_motion_sensor_s.gpio); + info = calloc(1, sizeof(model_infrared_motion_sensor_s)); + retv_if(!info, -1); + *peripheral_info = info; + + ret = peripheral_gpio_open(gpio_num, &info->gpio); retv_if(ret != 0, -1); - retv_if(!model_infrared_motion_sensor_s.gpio, -1); + retv_if(!info->gpio, -1); - ret = peripheral_gpio_set_direction(model_infrared_motion_sensor_s.gpio, PERIPHERAL_GPIO_DIRECTION_IN); + ret = peripheral_gpio_set_direction(info->gpio, PERIPHERAL_GPIO_DIRECTION_IN); goto_if(ret != 0, error); return 0; error: - model_fini_infrared_motion_sensor(); + model_fini_infrared_motion_sensor(info); + free(info); + *peripheral_info = NULL; return -1; } -int model_read_infrared_motion_sensor(int *out_value) +int model_read_infrared_motion_sensor(void *peripheral_info, int *out_value) { + model_infrared_motion_sensor_s *info = peripheral_info; int ret = 0; - ret = peripheral_gpio_read(model_infrared_motion_sensor_s.gpio, out_value); + ret = peripheral_gpio_read(info->gpio, out_value); retv_if(ret < 0, -1); _I("Infrared Motion Sensor Value : %d", *out_value); diff --git a/src/model/model_infrared_obstacle_avoidance_sensor.c b/src/model/model_infrared_obstacle_avoidance_sensor.c index 31dfbc2..9bed0eb 100644 --- a/src/model/model_infrared_obstacle_avoidance_sensor.c +++ b/src/model/model_infrared_obstacle_avoidance_sensor.c @@ -16,6 +16,7 @@ * limitations under the License. */ +#include #include #include #include @@ -23,47 +24,58 @@ #include "log.h" #include "model/model_infrared_obstacle_avoidance_sensor.h" -#define GPIO_NUM 4 -struct model_infrared_obstacle_avoidance_sensor { +struct _model_infrared_obstacle_avoidance_sensor_s { peripheral_gpio_h gpio; }; -static struct model_infrared_obstacle_avoidance_sensor model_infrared_obstacle_avoidance_sensor_s; +typedef struct _model_infrared_obstacle_avoidance_sensor_s model_infrared_obstacle_avoidance_sensor_s; -void model_fini_infrared_obstacle_avoidance_sensor(void) +void model_fini_infrared_obstacle_avoidance_sensor(void *peripheral_info) { + model_infrared_obstacle_avoidance_sensor_s *info = peripheral_info; + _I("Infrared Obstacle Avoidance Sensor is finishing..."); + ret_if(!info); + + if (info->gpio) + peripheral_gpio_close(info->gpio); - if (model_infrared_obstacle_avoidance_sensor_s.gpio) - peripheral_gpio_close(model_infrared_obstacle_avoidance_sensor_s.gpio); + free(info); } -int model_init_infrared_obstacle_avoidance_sensor(void) +int model_init_infrared_obstacle_avoidance_sensor(int gpio_num, void **peripheral_info) { + model_infrared_obstacle_avoidance_sensor_s *info = NULL; int ret = 0; _I("Infrared Obstacle Avoidance is initializing..."); - /* GPIO for Ultrasonic Sensor's Transmit */ - ret = peripheral_gpio_open(GPIO_NUM, &model_infrared_obstacle_avoidance_sensor_s.gpio); + info = calloc(1, sizeof(model_infrared_obstacle_avoidance_sensor_s)); + retv_if(!info, -1); + *peripheral_info = info; + + ret = peripheral_gpio_open(gpio_num, &info->gpio); retv_if(ret != 0, -1); - retv_if(!model_infrared_obstacle_avoidance_sensor_s.gpio, -1); + retv_if(!info->gpio, -1); - ret = peripheral_gpio_set_direction(model_infrared_obstacle_avoidance_sensor_s.gpio, PERIPHERAL_GPIO_DIRECTION_IN); + ret = peripheral_gpio_set_direction(info->gpio, PERIPHERAL_GPIO_DIRECTION_IN); goto_if(ret != 0, error); return 0; error: - model_fini_infrared_obstacle_avoidance_sensor(); + model_fini_infrared_obstacle_avoidance_sensor(info); + free(info); + *peripheral_info = NULL; return -1; } -int model_read_infrared_obstacle_avoidance_sensor(int *out_value) +int model_read_infrared_obstacle_avoidance_sensor(void *peripheral_info, int *out_value) { + model_infrared_obstacle_avoidance_sensor_s *info = peripheral_info; int ret = 0; - ret = peripheral_gpio_read(model_infrared_obstacle_avoidance_sensor_s.gpio, out_value); + ret = peripheral_gpio_read(info->gpio, out_value); retv_if(ret < 0, -1); _I("Infrared Obstacle Avoidance Sensor Value : %d", *out_value); diff --git a/src/model/model_touch_sensor.c b/src/model/model_touch_sensor.c index 2fb11ad..749c583 100644 --- a/src/model/model_touch_sensor.c +++ b/src/model/model_touch_sensor.c @@ -16,6 +16,7 @@ * limitations under the License. */ +#include #include #include #include @@ -23,47 +24,57 @@ #include "log.h" #include "model/model_touch_sensor.h" -#define GPIO_NUM 4 - -struct model_touch_sensor { +struct _model_touch_sensor_s { peripheral_gpio_h gpio; }; -static struct model_touch_sensor model_touch_sensor_s; +typedef struct _model_touch_sensor_s model_touch_sensor_s; -void model_fini_touch_sensor(void) +void model_fini_touch_sensor(void *peripheral_info) { + model_touch_sensor_s *info = peripheral_info; + _I("Touch Sensor is finishing..."); + ret_if(!info); - if (model_touch_sensor_s.gpio) - peripheral_gpio_close(model_touch_sensor_s.gpio); + if (info->gpio) + peripheral_gpio_close(info->gpio); + + free(info); } -int model_init_touch_sensor(void) +int model_init_touch_sensor(int gpio_num, void **peripheral_info) { + model_touch_sensor_s *info = NULL; int ret = 0; _I("Touch is initializing..."); - /* GPIO for Ultrasonic Sensor's Transmit */ - ret = peripheral_gpio_open(GPIO_NUM, &model_touch_sensor_s.gpio); + info = calloc(1, sizeof(model_touch_sensor_s)); + retv_if(!info, -1); + *peripheral_info = info; + + ret = peripheral_gpio_open(gpio_num, &info->gpio); retv_if(ret != 0, -1); - retv_if(!model_touch_sensor_s.gpio, -1); + retv_if(!info->gpio, -1); - ret = peripheral_gpio_set_direction(model_touch_sensor_s.gpio, PERIPHERAL_GPIO_DIRECTION_IN); + ret = peripheral_gpio_set_direction(info->gpio, PERIPHERAL_GPIO_DIRECTION_IN); goto_if(ret != 0, error); return 0; error: - model_fini_touch_sensor(); + model_fini_touch_sensor(info); + free(info); + *peripheral_info = NULL; return -1; } -int model_read_touch_sensor(int *out_value) +int model_read_touch_sensor(void *peripheral_info, int *out_value) { + model_touch_sensor_s *info = peripheral_info; int ret = 0; - ret = peripheral_gpio_read(model_touch_sensor_s.gpio, out_value); + ret = peripheral_gpio_read(info->gpio, out_value); retv_if(ret < 0, -1); _I("Touch Sensor Value : %d", *out_value); diff --git a/src/model/model_ultrasonic_sensor.c b/src/model/model_ultrasonic_sensor.c index 8fb674c..bc9b227 100644 --- a/src/model/model_ultrasonic_sensor.c +++ b/src/model/model_ultrasonic_sensor.c @@ -16,96 +16,108 @@ * limitations under the License. */ +#include #include #include #include #include "log.h" -#define GPIO_TRAN_NUM 20 -#define GPIO_ECHO_NUM 21 - -struct _model_s { - peripheral_gpio_h tran_gpio; +struct _model_ultrasonic_s { + peripheral_gpio_h trig_gpio; peripheral_gpio_h echo_gpio; }; -static struct _model_s model_s; +typedef struct _model_ultrasonic_s model_ultrasonic_s; -void model_fini_ultrasonic_sensor(void) +void model_fini_ultrasonic_sensor(void *peripheral_info) { - if (model_s.echo_gpio) - peripheral_gpio_close(model_s.echo_gpio); + model_ultrasonic_s *info = peripheral_info; + + ret_if(!info); + + if (info->echo_gpio) + peripheral_gpio_close(info->echo_gpio); - if (model_s.tran_gpio) - peripheral_gpio_close(model_s.tran_gpio); + if (info->trig_gpio) + peripheral_gpio_close(info->trig_gpio); + + free(info); } -int model_init_ultrasonic_sensor(void) +int model_init_ultrasonic_sensor(int gpio_num1, int gpio_num2, void **peripheral_info) { + model_ultrasonic_s *info = NULL; int ret = 0; - /* GPIO for Ultrasonic Sensor's Transmit */ - ret = peripheral_gpio_open(GPIO_TRAN_NUM, &model_s.tran_gpio); - retv_if(ret != 0, -1); - retv_if(!model_s.tran_gpio, -1); + _I("Ultrasonic Sensor is initializing..."); + + info = calloc(1, sizeof(model_ultrasonic_s)); + retv_if(!info, -1); + *peripheral_info = info; + + ret = peripheral_gpio_open(gpio_num1, &info->trig_gpio); + retv_if(ret != 0, goto error); + retv_if(!info->trig_gpio, error); - ret = peripheral_gpio_set_direction(model_s.tran_gpio, PERIPHERAL_GPIO_DIRECTION_OUT); + ret = peripheral_gpio_set_direction(info->trig_gpio, PERIPHERAL_GPIO_DIRECTION_OUT); goto_if(ret != 0, error); - /* GPIO for Ultrasonic Sensor's Echo */ - ret = peripheral_gpio_open(GPIO_ECHO_NUM, &model_s.echo_gpio); + ret = peripheral_gpio_open(gpio_num2, &info->echo_gpio); goto_if(ret != 0, error); - goto_if(!model_s.echo_gpio, error); + goto_if(!info->echo_gpio, error); - ret = peripheral_gpio_set_direction(model_s.echo_gpio, PERIPHERAL_GPIO_DIRECTION_IN); + ret = peripheral_gpio_set_direction(info->echo_gpio, PERIPHERAL_GPIO_DIRECTION_IN); goto_if(ret != 0, error); return 0; error: - model_fini_ultrasonic_sensor(); + model_fini_ultrasonic_sensor(info); + free(info); + *peripheral_info = NULL; return -1; } -static int _get_echo_value(void) +static int _get_echo_value(model_ultrasonic_s *info) { int ret = 0; int value = 0; - ret = peripheral_gpio_read(model_s.echo_gpio, &value); + ret = peripheral_gpio_read(info->echo_gpio, &value); retv_if(ret < 0, -1); return value; } -int model_read_ultrasonic_sensor(double *value) +int model_read_ultrasonic_sensor(void *peripheral_info, double *value) { + model_ultrasonic_s *info = peripheral_info; int ret = 0; double duration = 0.0; struct timeval start_time, end_time, temp_start_time, temp_end_time; - ret = peripheral_gpio_write(model_s.tran_gpio, 0); + ret = peripheral_gpio_write(info->trig_gpio, 0); retv_if(ret < 0, -1); sleep(1); - ret = peripheral_gpio_write(model_s.tran_gpio, 1); + ret = peripheral_gpio_write(info->trig_gpio, 1); retv_if(ret < 0, -1); usleep(10); - ret = peripheral_gpio_write(model_s.tran_gpio, 0); + ret = peripheral_gpio_write(info->trig_gpio, 0); retv_if(ret < 0, -1); _D("Count the distance"); gettimeofday(&temp_start_time, NULL); - while (_get_echo_value() == 0) { + while (_get_echo_value(info) == 0) { gettimeofday(&temp_end_time, NULL); duration = (double)temp_end_time.tv_sec + (double)(temp_end_time.tv_usec / 1000000.0) - (double)temp_start_time.tv_sec - (double)(temp_start_time.tv_usec / 1000000.0); if (duration > 1.0f) { - _E("Cannot get the echo value[%d]", _get_echo_value()); + _E("Cannot get the echo value."); return -1; } } @@ -113,7 +125,7 @@ int model_read_ultrasonic_sensor(double *value) _D("After checking #1"); - while (_get_echo_value() == 1); + while (_get_echo_value(info) == 1); gettimeofday(&end_time, NULL); _D("After checking #2"); -- 2.7.4