// 按键的中断服务程序 void PIOINT3_IRQHandler(void) { IO_int_disable(GPIO_GRP3, 4); //delay_ms(100); LPC11xx_print("key int 3_4 catch", 0, 1); task_register(long_press_chk, 1, 50); }
task_type * keystate_ds_retract_task(engineconfig_type *config, const char *what, const char *who) { task_id what_id = task_register(what, "keystate_ds_retract_task_perform", keystate_ds_retract_task_perform); return task_create(what_id, time_now(), who, (void*)config); }
void long_press_chk(void) { static uint8_t cnt_key = 0; //LPC11xx_print("----press----", gpio_get_value(GPIO_GRP1, 3), 1); uint8_t i; /* // 复位键的防抖检测, 但复位由硬件拉低完成, 软件只是检测, 所以软件加了防抖也没用 if(!gpio_get_value(GPIO_GRP1, 3)){ if(cnt_key++ > 3){ LPC11xx_print("reset cmd get", 0, 1); cnt_key = 0; task_unregister(long_press_chk); task_unregister(snd_poweroff); rcv_data_reset(); run_state = S_ON_ING; gpio_set_value(GPIO_GRP1, 9, PIN_OUTPUT, LEVEL_LOW); task_register(speaker_ctrl, 1, 300); IO_int_enable(GPIO_GRP1, 3, 0); } }else */ if(!gpio_get_value(GPIO_GRP3, 4)){ if(cnt_key++ > 10){ LPC11xx_print("power cmd get", 0, 1); cnt_key = 0; task_unregister(long_press_chk); if(gpio_get_value(GPIO_GRP1, 9)){ //开机 power_12v_on(); run_state = S_ON_ING; task_register(speaker_ctrl, 1, 300); //开机时蜂鸣器响 //IO_int_enable(GPIO_GRP3, 4, 0); }else{ //关机 task_register(snd_poweroff, 1, 500); run_state = S_OFF_ING; for(i = 0; i < TASK_MAX_NUM; ++i) LPC11xx_print("i = ", (uint32_t)task[i].p_calbak, 1); } } }else{ cnt_key = 0; task_unregister(long_press_chk); IO_int_enable(GPIO_GRP3, 4, 0); //IO_int_enable(GPIO_GRP1, 3, 0); } }
STATIC_FUNC void check_local_topology_cache(void *nothing) { assertion(-500000, (my_topology_period < MAX_TOPOLOGY_PERIOD)); struct avl_node *local_it; struct local_node *local; uint32_t m = 0; for (local_it = NULL; (local = avl_iterate_item(&local_tree, &local_it));) { if (local->neigh && local->neigh->dhn->on && local->best_tp_lndev) { struct local_topology_node *ltn = avl_find_item(&local_topology_tree, &local->neigh->dhn->on->global_id.pkid); struct local_topology_node tmp; if (!ltn) { my_description_changed = YES; return; } set_local_topology_node(&tmp, local); if ( (bmx_time - self->updated_timestamp) > ((uint32_t)my_topology_period * 10) && ( check_value_deviation(ltn->txBw, tmp.txBw, 0) || check_value_deviation(ltn->rxBw, tmp.rxBw, 0) || check_value_deviation(ltn->txRate, tmp.txRate, 0) || check_value_deviation(ltn->rxRate, tmp.rxRate, 0) ) ) { my_description_changed = YES; return; } else if ( check_value_deviation(ltn->txBw, tmp.txBw, my_topology_hysteresis) || check_value_deviation(ltn->rxBw, tmp.rxBw, my_topology_hysteresis) || check_value_deviation(ltn->txRate, tmp.txRate, my_topology_hysteresis) || check_value_deviation(ltn->rxRate, tmp.rxRate, my_topology_hysteresis) ) { my_description_changed = YES; return; } m++; } } if (local_topology_tree.items != m) { my_description_changed = YES; return; } task_register(my_topology_period/10, check_local_topology_cache, NULL, -300000); }
// 6820复位按键的中断服务程序 void PIOINT1_IRQHandler(void) { IO_int_disable(GPIO_GRP1, 3); LPC11xx_print("key int 1_3 catch", gpio_get_value(GPIO_GRP1, 3), 1); // task_register(long_press_chk, 1, 20); //防抖任务 task_unregister(snd_poweroff); rcv_data_reset(); run_state = S_ON_ING; gpio_set_value(GPIO_GRP1, 9, PIN_OUTPUT, LEVEL_LOW); task_register(speaker_ctrl, 1, 300); IO_int_enable(GPIO_GRP1, 3, 0); }
STATIC_FUNC int create_description_topology(struct tx_frame_iterator *it) { struct avl_node *local_it = NULL; struct local_node *local; int32_t m = 0; struct description_msg_topology *msg = (struct description_msg_topology *) tx_iterator_cache_msg_ptr(it); destroy_local_topology_cache(); if (my_topology_period >= MAX_TOPOLOGY_PERIOD) return TLV_TX_DATA_IGNORED; task_remove(check_local_topology_cache, NULL); task_register(my_topology_period, check_local_topology_cache, NULL, -300000); while ((local = avl_iterate_item(&local_tree, &local_it)) && m < tx_iterator_cache_msg_space_max(it)) { if (local->neigh && local->neigh->dhn->on && local->best_tp_lndev) { struct local_topology_node *ltn = debugMallocReset(sizeof(struct local_topology_node), -300000); set_local_topology_node(ltn, local); ltn->pkid = local->neigh->dhn->on->global_id.pkid; avl_insert(&local_topology_tree, ltn, -300000); msg[m].pkid = ltn->pkid; msg[m].txBw = umetric_to_fmu8( <n->txBw); msg[m].rxBw = umetric_to_fmu8(<n->rxBw); msg[m].txRate = ltn->txRate; msg[m].rxRate = ltn->rxRate; msg[m].type = 0; msg[m].reserved = 0; m++; } } if (m) return m * sizeof(struct description_msg_topology); return TLV_TX_DATA_IGNORED; }
int32_t task_dispatch(_async child, place_t remote_place) { _task* self = (_task*)_thread_getspecific(); task_register(self); uint64_t bufsize; if(_placetodispatcher(remote_place) == _placetodispatcher(_here())) { bufsize = child.size; bufsize += sizeof(method_t); bufsize += sizeof(_task*); void* buf = (void*) malloc(bufsize); _task** parent = (_task**)buf; *parent = self; method_t* method = (method_t*)(buf+sizeof(_task*)); *method = child.method; void* params = (void*) (buf + sizeof(method_t) + sizeof(_task*)); memcpy(params, child.params, child.size); struct Msg* msg = (struct Msg*) malloc(sizeof(struct Msg)); // (((_task*)_thread_getspecific()) -> total_memory) += sizeof(struct Msg); msg -> placeTo = remote_place; msg -> placeFrom = _here(); msg -> msgType = ASYNC; msg -> size = bufsize; msg -> tb.addr = buf; msg -> tb.sz = bufsize; _create_async_local(msg); } else { void* buf = _pack_ASYNC(&bufsize, sizeof(method_t) + sizeof(_task*), child); _task** parent = (_task**)buf; *parent = self; method_t* method = (method_t*)(buf+sizeof(_task*)); *method = child.method; int32_t success = WriteMsg(remote_place, ASYNC, (uint64_t)bufsize, (void*)buf); //may not be needed ///GC_FREE(buf); free(buf); if (success == EXIT_SUCCESS) { return EXIT_SUCCESS; } else { return EXIT_FAILURE; } } }
task_type * enforce_task(engine_type *engine, bool all) { task_id what_id; const char *what = "enforce"; const char *who = "next zone"; struct enf_task_ctx *ctx = &enforcer_context; if (!ctx) { ods_log_error("Malloc failure, enforce task not scheduled"); return NULL; } ctx->engine = engine; ctx->enforce_all = all; what_id = task_register(what, module_str, enforce_task_perform); return task_create(what_id, time_now(), who, what, ctx, enforce_task_clean_ctx); }
STATIC_FUNC int32_t opt_topology(uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn) { TRACE_FUNCTION_CALL; static int32_t scheduled_period = MAX_TOPOLOGY_PERIOD; if (!terminating && cmd == OPT_POST && my_topology_period != scheduled_period) { task_remove(check_local_topology_cache, NULL); if (my_topology_period < MAX_TOPOLOGY_PERIOD) task_register(my_topology_period, check_local_topology_cache, NULL, -300000); scheduled_period = my_topology_period; } if (cmd == OPT_UNREGISTER && scheduled_period < MAX_TOPOLOGY_PERIOD) { task_remove(check_local_topology_cache, NULL); scheduled_period = MAX_TOPOLOGY_PERIOD; } return SUCCESS; }
int main() { Elf32_Ehdr *simple_elfh = APPLICATION_ELF(simple); Elf32_Ehdr *writer_elfh = APPLICATION_ELF(writer); Elf32_Ehdr *reader_elfh = APPLICATION_ELF(reader); Elf32_Ehdr *rtuapp_elfh = APPLICATION_ELF(rtuappv1); Elf32_Ehdr *sys_elfh = SYSTEM_ELF; if (check_elf_magic(sys_elfh)) INFO_MSG("System ELF magic checks out @ 0x%x\n", (u_int32_t)sys_elfh); else { ERROR_MSG("Wrong System ELF magic @ 0x%x\n", (u_int32_t)sys_elfh); goto exit; } /* * Registering tasks */ task_register_cons *simplec = task_register("simple", simple_elfh); task_register_cons *readerc = task_register("reader", reader_elfh); task_register_cons *writerc = task_register("writer", writer_elfh); task_register_cons *rtuappc = task_register("rtuapp", rtuapp_elfh); if (!task_alloc(simplec)) { ERROR_MSG("Could not alloc memory for task \"simple\"\n"); goto exit; } if (!task_alloc(readerc)) { ERROR_MSG("Could not alloc memory for task \"reader\"\n"); goto exit; } if (!task_alloc(writerc)) { ERROR_MSG("Could not alloc memory for task \"writer\"\n"); goto exit; } if (!task_alloc(rtuappc)) { ERROR_MSG("Could not alloc memory for task \"rtuapp\"\n"); goto exit; } /* * Linking tasks */ if (!task_link(simplec)) { ERROR_MSG("Could not link \"simple\" task\n"); goto exit; } if (!task_link(readerc)) { ERROR_MSG("Could not link \"reader\" task\n"); goto exit; } if (!task_link(writerc)) { ERROR_MSG("Could not link \"writer\" task\n"); goto exit; } if (!task_link(rtuappc)) { ERROR_MSG("Could not link \"rtuapp\" task\n"); goto exit; } /* * Starting tasks */ if (!task_start(simplec)) { ERROR_MSG("Could not start \"simple\" task\n"); goto exit; } if (!task_start(readerc)) { ERROR_MSG("Could not start \"reader\" task\n"); goto exit; } if (!task_start(writerc)) { ERROR_MSG("Could not start \"writer\" task\n"); goto exit; } if (!task_start(rtuappc)) { ERROR_MSG("Could not start \"rtuapp\" task\n"); goto exit; } /* * Create migration task. */ if (!migrator_start()) { ERROR_MSG("Could not start migrator.\n"); goto exit; } INFO_MSG("Starting scheduler\n"); vTaskStartScheduler(); exit: INFO_MSG("Going into infinite loop...\n"); while(1) ; }
void status_deal(void) { static uint8_t last_run_state = 0xff; static uint8_t flash = 1; uint8_t level; //rcv_data2level(); if(last_run_state != run_state) LPC11xx_print("run_state", run_state, 1); if(run_state == S_NORMAL || run_state == S_INIT_ING || run_state == S_RESET_ING){ ++uart_status; if(uart_status >= 5){ // 串口接收到信息时会把uart_status置0, 所以系统正常运行时uart_status不可能>3 LPC11xx_print("over time", 0, 1); run_state = S_ABNORMAL; } } //开/关机, 初始化, 恢复出厂设置过程中不接收电源按键中断, 灯闪 if(run_state == S_ON_ING || run_state == S_OFF_ING || run_state == S_INIT_ING || run_state == S_RESET_ING ||run_state == S_SYS_OFF_DONE){ flash = 1; if(IO_int_is_on(GPIO_GRP3, 4)) IO_int_disable(GPIO_GRP3, 4); } else { //正常运行 关机完成 异常情况 接收按键中断, 灯不闪 flash = 0; if(!IO_int_is_on(GPIO_GRP3, 4)) IO_int_enable(GPIO_GRP3, 4, 0); } if(run_state == S_SYS_OFF_DONE && last_run_state != run_state){ task_unregister(snd_poweroff); task_register(delay_poweroff, 1, 500); } if(run_state != last_run_state || flash){ if(run_state == S_ON_ING || run_state == S_12V_OFF_DONE || run_state == S_SYS_OFF_DONE){ //开/关机阶段 蓝灯闪 level = gpio_get_value(GPIO_GRP0, 6); //6, 7, 10为蓝灯 gpio_set_value(GPIO_GRP0, 6, PIN_OUTPUT, !level); gpio_set_value(GPIO_GRP0, 7, PIN_OUTPUT, !level); gpio_set_value(GPIO_GRP0, 10, PIN_OUTPUT, !level); //8, 9 为黄灯 gpio_set_value(GPIO_GRP0, 8, PIN_OUTPUT, LEVEL_LOW); gpio_set_value(GPIO_GRP0, 9, PIN_OUTPUT, LEVEL_LOW); } else if(run_state == S_NORMAL) { //正常运行阶段 蓝灯常亮 //6, 7, 10为蓝灯 gpio_set_value(GPIO_GRP0, 6, PIN_OUTPUT, LEVEL_HIGH); gpio_set_value(GPIO_GRP0, 7, PIN_OUTPUT, LEVEL_HIGH); gpio_set_value(GPIO_GRP0, 10, PIN_OUTPUT, LEVEL_HIGH); //8, 9 为黄灯 gpio_set_value(GPIO_GRP0, 8, PIN_OUTPUT, 0); gpio_set_value(GPIO_GRP0, 9, PIN_OUTPUT, 0); } else if(run_state == S_INIT_ING) { //初始化阶段 蓝黄灯交替闪 level = gpio_get_value(GPIO_GRP0, 6); //6, 7, 10为蓝灯 gpio_set_value(GPIO_GRP0, 6, PIN_OUTPUT, !level); gpio_set_value(GPIO_GRP0, 7, PIN_OUTPUT, !level); gpio_set_value(GPIO_GRP0, 10, PIN_OUTPUT, !level); //8, 9 为黄灯 gpio_set_value(GPIO_GRP0, 8, PIN_OUTPUT, level); gpio_set_value(GPIO_GRP0, 9, PIN_OUTPUT, level); } else if(run_state == S_12V_OFF_DONE) { //关机完成 灯灭 //6, 7, 10为蓝灯 gpio_set_value(GPIO_GRP0, 6, PIN_OUTPUT, LEVEL_LOW); gpio_set_value(GPIO_GRP0, 7, PIN_OUTPUT, LEVEL_LOW); gpio_set_value(GPIO_GRP0, 10, PIN_OUTPUT, LEVEL_LOW); //8, 9 为黄灯 gpio_set_value(GPIO_GRP0, 8, PIN_OUTPUT, LEVEL_LOW); gpio_set_value(GPIO_GRP0, 9, PIN_OUTPUT, LEVEL_LOW); } else if(run_state == S_ABNORMAL) { //运行异常 黄灯常亮 //6, 7, 10为蓝灯 gpio_set_value(GPIO_GRP0, 6, PIN_OUTPUT, LEVEL_LOW); gpio_set_value(GPIO_GRP0, 7, PIN_OUTPUT, LEVEL_LOW); gpio_set_value(GPIO_GRP0, 10, PIN_OUTPUT, LEVEL_LOW); //8, 9 为黄灯 gpio_set_value(GPIO_GRP0, 8, PIN_OUTPUT, LEVEL_HIGH); gpio_set_value(GPIO_GRP0, 9, PIN_OUTPUT, LEVEL_HIGH); } else if(run_state == S_RESET_ING) { //恢复出厂设置, 黄灯闪亮 level = gpio_get_value(GPIO_GRP0, 8); //6, 7, 10为蓝灯 gpio_set_value(GPIO_GRP0, 6, PIN_OUTPUT, LEVEL_LOW); gpio_set_value(GPIO_GRP0, 7, PIN_OUTPUT, LEVEL_LOW); gpio_set_value(GPIO_GRP0, 10, PIN_OUTPUT, LEVEL_LOW); //8, 9 为黄灯 gpio_set_value(GPIO_GRP0, 8, PIN_OUTPUT, !level); gpio_set_value(GPIO_GRP0, 9, PIN_OUTPUT, !level); } } last_run_state = run_state; }
/** * @brief Initialise the stick scanning. * @note Starts the ADC continuous sampling. * @param None * @retval None */ void sticks_init(void) { ADC_InitTypeDef adcInit; DMA_InitTypeDef dmaInit; GPIO_InitTypeDef gpioInit; NVIC_InitTypeDef nvicInit; TIM_TimeBaseInitTypeDef timInit; TIM_OCInitTypeDef timOC; int i; // Enable the ADC and DMA clocks RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA, ENABLE); gpioInit.GPIO_Speed = GPIO_Speed_50MHz; gpioInit.GPIO_Pin = 0x7F; gpioInit.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOA, &gpioInit); ADC_DeInit(ADC1); // Setup the ADC init structure ADC_StructInit(&adcInit); adcInit.ADC_ContinuousConvMode = DISABLE; adcInit.ADC_ScanConvMode = ENABLE; adcInit.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T4_CC4; adcInit.ADC_NbrOfChannel = STICK_ADC_CHANNELS; ADC_Init(ADC1, &adcInit); // Setup the regular channel cycle for (i = 0; i < STICK_ADC_CHANNELS; ++i) { ADC_RegularChannelConfig(ADC1, ADC_Channel_0 + i, i + 1, ADC_SampleTime_239Cycles5); } // Enable ADC1 + DMA ADC_Cmd(ADC1, ENABLE); ADC_DMACmd(ADC1, ENABLE); // Calibrate ADC1 ADC_ResetCalibration(ADC1); while (ADC_GetResetCalibrationStatus(ADC1)) ; ADC_StartCalibration(ADC1); while (ADC_GetCalibrationStatus(ADC1)) ; nvicInit.NVIC_IRQChannel = DMA1_Channel1_IRQn; nvicInit.NVIC_IRQChannelSubPriority = 1; nvicInit.NVIC_IRQChannelPreemptionPriority = 1; nvicInit.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&nvicInit); // DMA Configuration DMA_DeInit(DMA1_Channel1); DMA_StructInit(&dmaInit); dmaInit.DMA_PeripheralBaseAddr = (uint32_t) &ADC1->DR; dmaInit.DMA_MemoryBaseAddr = (uint32_t) &adc_data[0]; dmaInit.DMA_DIR = DMA_DIR_PeripheralSRC; dmaInit.DMA_BufferSize = STICK_ADC_CHANNELS; dmaInit.DMA_PeripheralInc = DMA_PeripheralInc_Disable; dmaInit.DMA_MemoryInc = DMA_MemoryInc_Enable; dmaInit.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; dmaInit.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; dmaInit.DMA_Mode = DMA_Mode_Circular; dmaInit.DMA_Priority = DMA_Priority_VeryHigh; dmaInit.DMA_M2M = DMA_M2M_Disable; // Configure and enable the DMA DMA_Init(DMA1_Channel1, &dmaInit); DMA_Cmd(DMA1_Channel1, ENABLE); DMA_ITConfig(DMA1_Channel1, DMA_IT_TC, ENABLE); // TIM4 OC4 is ADC conversion trigger RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); TIM_DeInit(TIM4); /* TIM4 init */ TIM_TimeBaseStructInit(&timInit); timInit.TIM_Period = 20-1; /* 20 ms */ timInit.TIM_Prescaler = SystemCoreClock/1000 - 1; /* 1ms */ timInit.TIM_ClockDivision = 0x0; timInit.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM4, &timInit); /* TIM4 OC4 configuration in PWM mode to generate ADC_ExternalTrigConv_T4_CC4 */ TIM_OCStructInit(&timOC); timOC.TIM_OCMode = TIM_OCMode_PWM1; timOC.TIM_OutputState = TIM_OutputState_Enable; timOC.TIM_Pulse = 1; timOC.TIM_OCPolarity = TIM_OCPolarity_Low; TIM_OC4Init(TIM4, &timOC); /* TIM2 enable counter */ TIM_Cmd(TIM4, ENABLE); /* enable ADC triggering */ ADC_ExternalTrigConvCmd(ADC1, ENABLE); task_register(TASK_PROCESS_STICKS, sticks_process); task_schedule(TASK_PROCESS_STICKS, 0, 20); }
STATIC_FUNC void check_for_changed_sms(void *unused) { uint16_t found_sms = 0; uint16_t matching_sms = 0; struct opt_type *opt = get_option( 0, 0, ARG_SMS ); struct opt_parent *p = NULL; struct json_sms * sms = NULL; struct avl_node *an = NULL; char name[MAX_JSON_SMS_NAME_LEN]; char data[MAX_JSON_SMS_DATA_LEN + 1]; dbgf_all(DBGT_INFO, "checking..."); if (extensions_fd == -1) { task_remove(check_for_changed_sms, NULL); task_register(SMS_POLLING_INTERVAL, check_for_changed_sms, NULL, 300000); } while ((sms = avl_iterate_item(&json_sms_tree, &an))) { sms->stale = 1; } while ((p = list_iterate(&opt->d.parents_instance_list, p))) { int len = 0; memset(name, 0, sizeof (name)); strcpy(name, p->val); int fd = -1; char path_name[MAX_PATH_SIZE + 20] = ""; sprintf(path_name, "%s/%s", smsTx_dir, p->val); if ((fd = open(path_name, O_RDONLY, 0)) < 0) { dbgf_all(DBGT_INFO, "could not open %s - %s", path_name, strerror(errno)); continue; } else if ((len = read(fd, data, sizeof (data))) < 0 || len > MAX_JSON_SMS_DATA_LEN) { dbgf_sys(DBGT_ERR, "sms=%s data_len>=%d MUST BE <=%d bytes! errno: %s", path_name, len, MAX_JSON_SMS_DATA_LEN, strerror(errno)); close(fd); continue; } else if ((sms = avl_find_item(&json_sms_tree, name)) && sms->text_len == len && !memcmp(sms->text, data, len)) { matching_sms++; sms->stale = 0; close(fd); } else { if (sms) { avl_remove(&json_sms_tree, sms->name, -300378); debugFree(sms, -300369); } sms = debugMalloc(sizeof (struct json_sms) +len, -300370); memset(sms, 0, sizeof (struct json_sms) +len); strcpy(sms->name, name); sms->text_len = len; sms->stale = 0; memcpy(sms->text, data, len); avl_insert(&json_sms_tree, sms, -300371); close(fd); dbgf_track(DBGT_INFO, "new sms=%s size=%d! updating description..-", path_name, sms->text_len); } found_sms++; } if (found_sms != matching_sms || found_sms != json_sms_tree.items) { dbgf_all(DBGT_INFO, "sms found=%d matching=%d items=%d", found_sms, matching_sms, json_sms_tree.items); memset(name, 0, sizeof (name)); while ((sms = avl_next_item(&json_sms_tree, name))) { memcpy(name, sms->name, sizeof (sms->name)); if (sms->stale) { dbgf_track(DBGT_INFO, "removed sms=%s/%s size=%d! updating description...", smsTx_dir, sms->name, sms->text_len); avl_remove(&json_sms_tree, sms->name, -300373); debugFree(sms, -300374); } } my_description_changed = YES; } }