// 按键的中断服务程序
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;
}
}
