void pr_alarms_unblock(void) {
--alarms_blocked;
if (alarms_blocked == 0 && alarm_pending) {
alarm_pending = 0;
nalarms++;
handle_alarm();
}
}
int pr_timer_reset(int timerno, module *mod) {
struct timer *t = NULL;
if (!timers) {
errno = EPERM;
return -1;
}
if (_indispatch) {
errno = EINTR;
return -1;
}
pr_alarms_block();
if (!recycled)
recycled = xaset_create(timer_pool, NULL);
for (t = (struct timer *) timers->xas_list; t; t = t->next) {
if (t->timerno == timerno &&
(t->mod == mod || mod == ANY_MODULE)) {
t->count = t->interval;
xaset_remove(timers, (xasetmember_t *) t);
xaset_insert(recycled, (xasetmember_t *) t);
nalarms++;
/* The handle_alarm() function also readjusts the timers lists
* as part of its processing, so it needs to be called when a timer
* is reset.
*/
handle_alarm();
break;
}
}
pr_alarms_unblock();
if (t != NULL) {
pr_trace_msg("timer", 7, "reset timer ID %d ('%s', for module '%s')",
t->timerno, t->desc, t->mod ? t->mod->name : "[none]");
return t->timerno;
}
return 0;
}
bool net::tcp_server::start()
{
if (_M_nlisteners == 0) {
return false;
}
_M_must_stop = false;
do {
if (_M_handle_alarm) {
handle_alarm();
_M_handle_alarm = false;
}
process_events(1000);
handle_expired(_M_current_msec);
} while (!_M_must_stop);
return true;
}
int pr_timer_sleep(int seconds) {
int timerno = 0;
sigset_t oset;
_sleep_sem = 0;
if (alarms_blocked || _indispatch) {
errno = EPERM;
return -1;
}
timerno = pr_timer_add(seconds, -1, NULL, sleep_cb, "sleep");
if (timerno == -1)
return -1;
sigemptyset(&oset);
while (!_sleep_sem) {
sigsuspend(&oset);
handle_alarm();
}
return 0;
}
int pr_timer_add(int seconds, int timerno, module *mod, callback_t cb,
const char *desc) {
struct timer *t = NULL;
if (seconds <= 0 ||
cb == NULL ||
desc == NULL) {
errno = EINVAL;
return -1;
}
if (!timers)
timers = xaset_create(timer_pool, (XASET_COMPARE) timer_cmp);
/* Check to see that, if specified, the timerno is not already in use. */
if (timerno >= 0) {
for (t = (struct timer *) timers->xas_list; t; t = t->next) {
if (t->timerno == timerno) {
errno = EPERM;
return -1;
}
}
}
if (!free_timers)
free_timers = xaset_create(timer_pool, NULL);
/* Try to use an old timer first */
pr_alarms_block();
t = (struct timer *) free_timers->xas_list;
if (t != NULL) {
xaset_remove(free_timers, (xasetmember_t *) t);
} else {
if (timer_pool == NULL) {
timer_pool = make_sub_pool(permanent_pool);
pr_pool_tag(timer_pool, "Timer Pool");
}
/* Must allocate a new one */
t = palloc(timer_pool, sizeof(struct timer));
}
if (timerno < 0) {
/* Dynamic timer */
if (dynamic_timerno < PR_TIMER_DYNAMIC_TIMERNO) {
dynamic_timerno = PR_TIMER_DYNAMIC_TIMERNO;
}
timerno = dynamic_timerno++;
}
t->timerno = timerno;
t->count = t->interval = seconds;
t->callback = cb;
t->mod = mod;
t->remove = 0;
t->desc = desc;
/* If called while _indispatch, add to the recycled list to prevent
* list corruption
*/
if (_indispatch) {
if (!recycled)
recycled = xaset_create(timer_pool, NULL);
xaset_insert(recycled, (xasetmember_t *) t);
} else {
xaset_insert_sort(timers, (xasetmember_t *) t, TRUE);
nalarms++;
set_sig_alarm();
/* The handle_alarm() function also readjusts the timers lists
* as part of its processing, so it needs to be called when a timer
* is added.
*/
handle_alarm();
}
pr_alarms_unblock();
pr_trace_msg("timer", 7, "added timer ID %d ('%s', for module '%s'), "
"triggering in %ld %s", t->timerno, t->desc,
t->mod ? t->mod->name : "[none]", t->interval,
t->interval != 1 ? "seconds" : "second");
return timerno;
}
int pr_timer_remove(int timerno, module *mod) {
struct timer *t = NULL, *tnext = NULL;
int nremoved = 0;
/* If there are no timers currently registered, do nothing. */
if (!timers)
return 0;
pr_alarms_block();
for (t = (struct timer *) timers->xas_list; t; t = tnext) {
tnext = t->next;
if ((timerno < 0 || t->timerno == timerno) &&
(mod == ANY_MODULE || t->mod == mod)) {
nremoved++;
if (_indispatch) {
t->remove++;
} else {
xaset_remove(timers, (xasetmember_t *) t);
xaset_insert(free_timers, (xasetmember_t *) t);
nalarms++;
/* The handle_alarm() function also readjusts the timers lists
* as part of its processing, so it needs to be called when a timer
* is removed.
*/
handle_alarm();
}
pr_trace_msg("timer", 7, "removed timer ID %d ('%s', for module '%s')",
t->timerno, t->desc, t->mod ? t->mod->name : "[none]");
}
/* If we are removing a specific timer, break out of the loop now.
* Otherwise, keep removing any matching timers.
*/
if (nremoved > 0 &&
timerno >= 0) {
break;
}
}
pr_alarms_unblock();
if (nremoved == 0) {
errno = ENOENT;
return -1;
}
/* If we removed a specific timer because of the given timerno, return
* that timerno value.
*/
if (timerno >= 0) {
return timerno;
}
return nremoved;
}
int main ( int argc, char **argv )
{
char *dev_serial = getenv("BC_DEV");
if(dev_serial == NULL) {
dev_serial = "/dev/ttyACM0";
}
fd = open ( dev_serial, O_RDWR | O_NOCTTY );
if ( fd < 0 )
{
// TODO: THROW error
fprintf(stderr, "Failed to open device: %s\n", dev_serial);
return EXIT_FAILURE;
}
// save status port settings.
tcgetattr ( fd, &oldtio );
// Setup the serial port.
struct termios newtio = { 0, };
newtio.c_cflag = baudrate | CS8 | CREAD | PARODD;
newtio.c_iflag = 0;
newtio.c_oflag = 0;
newtio.c_lflag = 0; //ICANON;
newtio.c_cc[VMIN] = 1;
newtio.c_cc[VTIME] = 0;
tcflush ( fd, TCIFLUSH | TCIOFLUSH );
tcsetattr ( fd, TCSANOW, &newtio );
if( argc == 1) {
printf_information();
} else if (argc > 1 ) {
const char *command = argv[1];
// Alarm
if(strcasecmp(command, "alarm") == 0 ) {
handle_alarm( argc-2, &argv[2]);
// Initialize
} else if (strcasecmp(command, "init") == 0) {
handle_init();
}
else if(strcasecmp(command, "temperature") == 0 ) {
handle_temperature();
}
else if(strcasecmp(command, "drift") == 0 ) {
handle_drift();
}
else if ( strcasecmp(command, "brightness") == 0) {
handle_brightness(argc-2, &argv[2]);
} else if ( strcasecmp(command, "test") == 0){
handle_test();
}
}
sync(fd);
// tcsetattr ( fd, TCSANOW, &oldtio );
close(fd);
return EXIT_SUCCESS;
}
void handle_stlv_packet(unsigned char* packet)
{
stlv_packet pack = packet;
char type_buf[MAX_ELEMENT_TYPE_BUFSIZE];
element_handle handle = get_first_element(pack);
while (IS_VALID_STLV_HANDLE(handle))
{
int type_len = get_element_type(pack, handle, type_buf, sizeof(type_buf));
log_info("Read Element: %x\n", type_buf[0]);
switch (type_buf[0])
{
case ELEMENT_TYPE_ECHO:
{
int data_len = get_element_data_size(pack, handle, type_buf, type_len);
unsigned char* data = get_element_data_buffer(pack, handle, type_buf, type_len);
log_info("echo: ");
print_stlv_string(data, data_len);
log_info("\n");
handle_echo(data, data_len);
}
break;
case ELEMENT_TYPE_CLOCK:
{
int data_len = get_element_data_size(pack, handle, type_buf, type_len);
unsigned char* data = get_element_data_buffer(pack, handle, type_buf, type_len);
log_info("clock: %d/%d/%d %d:%d:%d\n",
(int)data[0], (int)data[1], (int)data[2], (int)data[3], (int)data[4], (int)data[5]);
handle_clock(data[0], data[1], data[2], data[3], data[4], data[5]);
if (data_len >= 8)
handle_phone_info(data[6], data[7]);
}
break;
case ELEMENT_TYPE_MESSAGE:
if (type_len == 2)
{
switch (type_buf[1])
{
case ELEMENT_TYPE_MESSAGE_SMS:
log_info("notification(SMS):\n");
break;
case ELEMENT_TYPE_MESSAGE_FB:
log_info("notification(Facebook):\n");
break;
case ELEMENT_TYPE_MESSAGE_TW:
log_info("notification(Twitter):\n");
break;
default:
break;
}
handle_msg_element(type_buf[1], pack, handle);
}
break;
case ELEMENT_TYPE_FILE:
handle_file(pack, handle);
break;
case ELEMENT_TYPE_GET_FILE:
{
int data_len = get_element_data_size(pack, handle, type_buf, type_len);
uint8_t* data = get_element_data_buffer(pack, handle, type_buf, type_len);
STLV_BUF_BEGIN_TEMP_STRING(data, data_len);
handle_get_file((char*)data);
STLV_BUF_END_TEMP_STRING(data, data_len);
}
break;
case ELEMENT_TYPE_ACTIVITY_DATA:
handle_get_activity();
break;
case ELEMENT_TYPE_LIST_FILES:
{
int data_len = get_element_data_size(pack, handle, type_buf, type_len);
uint8_t* data = get_element_data_buffer(pack, handle, type_buf, type_len);
STLV_BUF_BEGIN_TEMP_STRING(data, data_len);
handle_list_file((char*)data);
STLV_BUF_END_TEMP_STRING(data, data_len);
}
break;
case ELEMENT_TYPE_REMOVE_FILE:
{
int data_len = get_element_data_size(pack, handle, type_buf, type_len);
uint8_t* data = get_element_data_buffer(pack, handle, type_buf, type_len);
STLV_BUF_BEGIN_TEMP_STRING(data, data_len);
uint8_t file_name_pos = 0;
for (uint8_t i = 0; i < data_len; ++i)
{
if (data[i] == ';')
data[i] = '\0';
if (data[i] == '\0')
{
handle_remove_file((char*)(&data[file_name_pos]));
file_name_pos = i + 1;
}
}
STLV_BUF_END_TEMP_STRING(data, data_len);
}
break;
#if 0
case ELEMENT_TYPE_SPORT_HEARTBEAT:
{
int data_len = get_element_data_size(pack, handle, type_buf, type_len);
uint8_t* data = get_element_data_buffer(pack, handle, type_buf, type_len);
STLV_BUF_BEGIN_TEMP_STRING(data, data_len);
handle_sports_heartbeat((char*)data);
STLV_BUF_END_TEMP_STRING(data, data_len);
}
break;
case ELEMENT_TYPE_SPORTS_DATA:
handle_get_sports_data();
break;
#endif
case ELEMENT_TYPE_SPORTS_GRID:
log_info("Get Sports Grid Request\n");
handle_get_sports_grid();
break;
case ELEMENT_TYPE_ALARM:
{
int data_len = get_element_data_size(pack, handle, type_buf, type_len);
uint8_t* data = get_element_data_buffer(pack, handle, type_buf, type_len);
if (data_len != sizeof(alarm_conf_t))
{
log_info("Alarm element decode failed: length mismatch (%d/%d)", data_len, sizeof(alarm_conf_t));
}
else
{
handle_alarm((alarm_conf_t*)data);
}
}
break;
case ELEMENT_TYPE_SN:
handle_get_device_id();
break;
case ELEMENT_TYPE_ACTIVITY:
handle_gps_data(pack, handle);
break;
case ELEMENT_TYPE_GESTURE_CONTROL:
{
int data_len = get_element_data_size(pack, handle, type_buf, type_len);
uint8_t* data = get_element_data_buffer(pack, handle, type_buf, type_len);
if (data_len != 5)
{
log_info("gesture control decode failed: length mismatch (%d/1)", data_len);
}
else
{
handle_gesture_control(*data, data + 1);
}
}
break;
case ELEMENT_TYPE_WATCHCONFIG:
{
int data_len = get_element_data_size(pack, handle, type_buf, type_len);
uint8_t* data = get_element_data_buffer(pack, handle, type_buf, type_len);
log_info("Set Watch UI Config %d/%d", data_len, (int)sizeof(ui_config));
//if (data_len >= (int)sizeof(ui_config))
handle_set_watch_config((ui_config*)(data + 1));
}
break;
case ELEMENT_TYPE_UNLOCK_WATCH:
handle_unlock_watch();
break;
case ELEMENT_TYPE_DAILY_ACTIVITY:
handle_daily_activity();
break;
}
handle = get_next_element(pack, handle);
}
}
static void timers_handle_signals(void) {
if (recvd_signal_flags) {
recvd_signal_flags &= ~RECEIVED_SIG_ALRM;
handle_alarm();
}
}
