src/app.c

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Contact: Jeonghoon Park <jh1979.park@samsung.com>
   5  *
   6  * Licensed under the Flora License, Version 1.1 (the License);
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://floralicense.org/license/
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an AS IS BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include <stdio.h>
  20 #include <unistd.h>
  21 #include <glib.h>
  22 #include <service_app.h>
  23 #include "log.h"
  24 #include "resource.h"
  25
  26 enum {
  27         DIR_STATE_S,
  28         DIR_STATE_F,
  29         DIR_STATE_B,
  30 };
  31
  32 typedef struct app_data_s {
  33         unsigned int f_value;
  34         unsigned int r_value;
  35         unsigned int dir_state;
  36 } app_data;
  37
  38 #define FRONT_PIN 21
  39 #define REAR_PIN 4
  40
  41 static void service_app_lang_changed(app_event_info_h event_info, void *user_data)
  42 {
  43         return;
  44 }
  45
  46 static void service_app_region_changed(app_event_info_h event_info, void *user_data)
  47 {
  48         return;
  49 }
  50
  51 static void service_app_low_battery(app_event_info_h event_info, void *user_data)
  52 {
  53         return;
  54 }
  55
  56 static void service_app_low_memory(app_event_info_h event_info, void *user_data)
  57 {
  58         return;
  59 }
  60
  61 static int __servo_motor_test(void)
  62 {
  63         resource_set_motor_driver_L298N_speed(MOTOR_ID_1, 0);
  64         resource_set_motor_driver_L298N_speed(MOTOR_ID_2, 0);
  65         resource_set_servo_motor_value(0, 400);
  66         sleep(1);
  67         resource_set_servo_motor_value(0, 500);
  68         sleep(1);
  69         resource_set_servo_motor_value(0, 450);
  70         sleep(1);
  71         return 0;
  72 }
  73
  74 static void ___________control_motor(app_data *ad)
  75 {
  76         _D("control motor, state(%u), f_val(%u), r_val(%u)",
  77                         ad->dir_state, ad->f_value, ad->r_value);
  78
  79
  80         switch (ad->dir_state) {
  81         case DIR_STATE_F:
  82                 if (ad->f_value)  {
  83                         if (ad->r_value) {
  84                                 ad->dir_state = DIR_STATE_S;
  85                                 resource_set_motor_driver_L298N_speed(MOTOR_ID_1, 0);
  86                                 resource_set_motor_driver_L298N_speed(MOTOR_ID_2, 0);
  87                         } else {
  88                                 ad->dir_state = DIR_STATE_B;
  89                                 __servo_motor_test();
  90                                 resource_set_motor_driver_L298N_speed(MOTOR_ID_1, -2000);
  91                                 resource_set_motor_driver_L298N_speed(MOTOR_ID_2, -2000);
  92                         }
  93                 }
  94                 break;
  95         case DIR_STATE_B:
  96                 if (ad->r_value)  {
  97                         if (ad->f_value) {
  98                                 ad->dir_state = DIR_STATE_S;
  99                                 resource_set_motor_driver_L298N_speed(MOTOR_ID_1, 0);
 100                                 resource_set_motor_driver_L298N_speed(MOTOR_ID_2, 0);
 101                         } else {
 102                                 ad->dir_state = DIR_STATE_F;
 103                                 __servo_motor_test();
 104                                 resource_set_motor_driver_L298N_speed(MOTOR_ID_1, 2000);
 105                                 resource_set_motor_driver_L298N_speed(MOTOR_ID_2, 2000);
 106                         }
 107                 }
 108                 break;
 109         case DIR_STATE_S:
 110                 if (!ad->f_value)  {
 111                         ad->dir_state = DIR_STATE_F;
 112                         __servo_motor_test();
 113                         resource_set_motor_driver_L298N_speed(MOTOR_ID_1, 2000);
 114                         resource_set_motor_driver_L298N_speed(MOTOR_ID_2, 2000);
 115                 } else if (!ad->r_value) {
 116                         ad->dir_state = DIR_STATE_B;
 117                         __servo_motor_test();
 118                         resource_set_motor_driver_L298N_speed(MOTOR_ID_1, -2000);
 119                         resource_set_motor_driver_L298N_speed(MOTOR_ID_2, -2000);
 120                 }
 121                 break;
 122         }
 123
 124         return;
 125 }
 126
 127 static void _front_ioa_sensor_changed_cb(unsigned int value, void *data)
 128 {
 129         app_data *ad = data;
 130
 131         _D("FRONT has obstacle!");
 132
 133         ad->f_value = value;
 134
 135         ___________control_motor(ad);
 136
 137         return;
 138 }
 139
 140 static void _back_ioa_sensor_changed_cb(unsigned int value, void *data)
 141 {
 142         app_data *ad = data;
 143
 144         _D("BACK has obstacle!");
 145
 146         ad->r_value = value;
 147
 148         ___________control_motor(ad);
 149
 150         return;
 151 }
 152
 153 static bool service_app_create(void *data)
 154 {
 155         int ret = 0;
 156
 157         /*
 158          * if you want to use default configuration,
 159          * Do not need to call resource_set_motor_driver_L298N_configuration(),
 160          *
 161         */
 162         ret = resource_set_motor_driver_L298N_configuration(MOTOR_ID_1, 19, 16, 5);
 163         if (ret) {
 164                 _E("resource_set_motor_driver_L298N_configuration()");
 165                 service_app_exit();
 166         }
 167         ret = resource_set_motor_driver_L298N_configuration(MOTOR_ID_2, 26, 20, 4);
 168         if (ret) {
 169                 _E("resource_set_motor_driver_L298N_configuration()");
 170                 service_app_exit();
 171         }
 172
 173         return true;
 174 }
 175
 176 static void service_app_control(app_control_h app_control, void *data)
 177 {
 178         app_data *ad = data;
 179         int ret;
 180
 181         /* set speed 0, to reduce delay of initializing motor driver */
 182         resource_set_motor_driver_L298N_speed(MOTOR_ID_1, 0);
 183         resource_set_motor_driver_L298N_speed(MOTOR_ID_2, 0);
 184
 185         resource_read_infrared_obstacle_avoidance_sensor(FRONT_PIN, &ad->f_value);
 186         resource_read_infrared_obstacle_avoidance_sensor(REAR_PIN, &ad->r_value);
 187
 188         resource_set_infrared_obstacle_avoidance_sensor_interrupted_cb(FRONT_PIN,
 189                 _front_ioa_sensor_changed_cb, ad);
 190         resource_set_infrared_obstacle_avoidance_sensor_interrupted_cb(REAR_PIN,
 191                 _back_ioa_sensor_changed_cb, ad);
 192
 193         ___________control_motor(ad);
 194
 195         return;
 196 }
 197
 198 static void service_app_terminate(void *data)
 199 {
 200         app_data *ad = data;
 201
 202         log_file_close();
 203
 204         _D("Bye ~");
 205
 206         return;
 207 }
 208
 209 int main(int argc, char* argv[])
 210 {
 211         app_data *ad = NULL;
 212         int ret = 0;
 213         service_app_lifecycle_callback_s event_callback;
 214         app_event_handler_h handlers[5] = {NULL, };
 215
 216         log_type_set(LOG_TYPE_DLOG);
 217
 218         ad = calloc(1, sizeof(app_data));
 219         retv_if(!ad, -1);
 220
 221         event_callback.create = service_app_create;
 222         event_callback.terminate = service_app_terminate;
 223         event_callback.app_control = service_app_control;
 224
 225         service_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY],
 226                 APP_EVENT_LOW_BATTERY, service_app_low_battery, &ad);
 227         service_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY],
 228                 APP_EVENT_LOW_MEMORY, service_app_low_memory, &ad);
 229         service_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED],
 230                 APP_EVENT_LANGUAGE_CHANGED, service_app_lang_changed, &ad);
 231         service_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED],
 232                 APP_EVENT_REGION_FORMAT_CHANGED, service_app_region_changed, &ad);
 233
 234         ret = service_app_main(argc, argv, &event_callback, ad);
 235         if (ret)
 236                 _E("failed to start app");
 237
 238         return 0;
 239 }
 240