void rt_appManager_thread_entry(void* parameter) { rt_err_t result = RT_EOK; CommunicationProtocol *cp; /* 创建一个信号量,初始值是0 */ protocalData_mq = rt_mq_create("protocalMQ",TX_PLOAD_WIDTH,2,RT_IPC_FLAG_FIFO); while (1) { result = rt_mq_recv(protocalData_mq, &buff[0], TX_PLOAD_WIDTH, RT_WAITING_FOREVER); if(result != RT_EOK) { rt_kprintf("recv mq error !"); return; } //deal msg from nRF2401 cp = (CommunicationProtocol *)buff; if(cp->authentication == 0x7a79 && cp->type == 1) //yz { //这里应该检测CRC16 //电机,采用写信的方式吧。 rt_mq_send(machineData_mq,&cp->m1pwm,4); //LED,采用写信的方式吧。 rt_mq_send(ledData_mq,&cp->LEDS,1); } } }
static void cpu_thread_entry(void *parameter) { #ifdef RT_USING_RTGUI struct rtgui_event_command ecmd; RTGUI_EVENT_COMMAND_INIT(&ecmd); ecmd.type = RTGUI_CMD_USER_INT; ecmd.command_id = CPU_UPDATE; #else struct lcd_msg msg; #endif while (1) { #ifdef RT_USING_RTGUI rtgui_thread_send(info_tid, &ecmd.parent, sizeof(ecmd)); #else msg.type = CPU_MSG; msg.major = cpu_usage_major; msg.minor = cpu_usage_minor; rt_mq_send(&mq, &msg, sizeof(msg)); #endif rt_thread_delay(20); } }
int net_buf_start_job(rt_size_t (*fetch)(rt_uint8_t* ptr, rt_size_t len, void* parameter), void (*close)(void* parameter), void* parameter) { struct net_buffer_job job; rt_uint32_t level; /* job message */ job.fetch = fetch; job.close = close; job.parameter = parameter; level = rt_hw_interrupt_disable(); /* check netbuf worker is stopped */ if (_netbuf.stat == NETBUF_STAT_STOPPED) { /* change stat to buffering if netbuf stopped */ _netbuf.stat = NETBUF_STAT_BUFFERING; rt_hw_interrupt_enable(level); rt_kprintf("stat[stoppped] -> buffering\n"); rt_mq_send(_netbuf_mq, (void*)&job, sizeof(struct net_buffer_job)); return 0; } rt_hw_interrupt_enable(level); return -1; }
static void adc_thread_entry(void *parameter) { rt_device_t device; #ifdef RT_USING_RTGUI struct rtgui_event_command ecmd; RTGUI_EVENT_COMMAND_INIT(&ecmd); ecmd.type = RTGUI_CMD_USER_INT; ecmd.command_id = ADC_UPDATE; #else struct lcd_msg msg; #endif device = rt_device_find("adc"); while(1) { rt_device_control(device, RT_DEVICE_CTRL_ADC_START, RT_NULL); rt_device_control(device, RT_DEVICE_CTRL_ADC_RESULT, &adc_value); pwm_update(adc_value/3); #ifdef RT_USING_RTGUI rtgui_thread_send(info_tid, &ecmd.parent, sizeof(ecmd)); #else msg.type = ADC_MSG; msg.adc_value = adc_value; rt_mq_send(&mq, &msg, sizeof(msg)); #endif rt_thread_delay(20); } }
void crtpPacketReveived(CRTPPacket *p) { //portBASE_TYPE xHigherPriorityTaskWoken; //xHigherPriorityTaskWoken = pdRT_FALSE; //xQueueSendFromISR(rxQueue, p, &xHigherPriorityTaskWoken); rt_mq_send(rxQueue, p, sizeof(CRTPPacket)); }
void HMI_MsgQue_Post(u16 CMD_ID, u16 len, u8 *content) { HMI_Comunicate.Msg_ID=CMD_ID; HMI_Comunicate.Info_Len=len; HMI_Comunicate.Content=content; rt_mq_send( &HMI_MsgQue, (void*)&HMI_Comunicate,sizeof(HMI_COM) ); }
/** * This function will post an message to the usb message queue, * * @param msg the message to be posted * * @return the error code, RT_EOK on successfully. */ rt_err_t rt_usbh_event_signal(struct uhost_msg* msg) { RT_ASSERT(msg != RT_NULL); /* send message to usb message queue */ rt_mq_send(usb_mq, (void*)msg, sizeof(struct uhost_msg)); return RT_EOK; }
void player_play_req(const char* fn) { struct player_request request; request.type = PLAYER_REQUEST_PLAY_SINGLE_FILE; strncpy(request.fn, fn, sizeof(request.fn)); /* send to message queue */ rt_mq_send(player_thread_mq, (void*)&request, sizeof(struct player_request)); }
/** * This function will post an message to the usb message queue, * * @param msg the message to be posted * @param size the size of the message . * * @return the error code, RT_EOK on successfully. */ rt_err_t rt_usb_post_event(struct uhost_msg* msg, rt_size_t size) { RT_ASSERT(msg != RT_NULL); /* send message to usb message queue */ rt_mq_send(usb_mq, (void*)msg, size); return RT_EOK; }
/* 数据到达回调函数*/ static rt_err_t uart_input(rt_device_t dev, rt_size_t size) { struct rx_msg msg; msg.dev = dev; msg.size = size; /* 发送消息到消息队列中*/ rt_mq_send(&rx_mq, &msg, sizeof(struct rx_msg)); test++; return RT_EOK; }
static Ret ftk_source_touch_eventpost(FtkSource* thiz, struct rt_touch_event *event) { DECL_PRIV(thiz, priv); rt_mq_send(&priv->mq, event, sizeof(*event)); ftk_rtthread_set_file_readble(priv->fd); return RET_OK; }
// 1. MsgQueue TX rt_err_t rt_712Rule_MsgQue_Post(rt_mq_t Dest_mq,u8 *buffer, rt_size_t size) { MSG_Q_TYPE msg_struct; msg_struct.len=(u16)size; msg_struct.info=buffer; /* send message to usb message queue */ rt_mq_send(Dest_mq,(u8*)(&msg_struct), size+2); return RT_EOK; }
/// Put a Message to a Queue osStatus osMessagePut(osMessageQId queue_id, uint32_t info, uint32_t millisec) { rt_err_t result; result = rt_mq_send(queue_id, &info, 1); if (result == RT_EOK) return osOK; else return osErrorOS; }
void update_radio_list_req(void) { struct player_request request; extern rt_mq_t player_thread_mq; update_radio_list_state = UPDATE_RAIDO_LIST_PROC; request.type = PLAYER_REQUEST_UPDATE_RADIO_LIST; strcpy(request.fn, RADIO_LIST_UPDATE_URL); /* send to message queue */ rt_mq_send(update_radio_mq, (void*)&request, sizeof(struct player_request)); }
void TIM3_IRQHandler(void) { uint16_t tmp; rt_interrupt_enter(); if (TIM_GetITStatus(TIM3,TIM_IT_CC3)==SET) { TIM_ClearITPendingBit(TIM3,TIM_IT_CC3); tmp=TIM_GetCounter(TIM3); IRInt=tmp>LastTS?tmp-LastTS:tmp+59999-LastTS; LastTS=tmp; rt_mq_send(ir_mq,&IRInt,sizeof(uint16_t)); } rt_interrupt_leave(); }
int ui_calibration(int argc, char** argv) { gui_msg_t msg; char *fullpath; if(argc != 2) { return -1; } fullpath = dfs_normalize_path(NULL, argv[1]); msg.cmd = 2; msg.exec = GUI_AppAutoCalibration; msg.parameter = (void *)fullpath; rt_mq_send(guimq, &msg, sizeof(msg)); return 0; }
rt_err_t rtgui_send(struct rtgui_app* app, rtgui_event_t *event, rt_size_t event_size) { rt_err_t result; RT_ASSERT(app != RT_NULL); RT_ASSERT(event != RT_NULL); RT_ASSERT(event_size != 0); rtgui_event_dump(app, event); result = rt_mq_send(app->mq, event, event_size); if (result != RT_EOK) { if (event->type != RTGUI_EVENT_TIMER) rt_kprintf("send event to %s failed\n", app->name); } return result; }
void UART5_IRQHandler( void ) { uint8_t ch; rt_interrupt_enter( ); if( USART_GetITStatus( UART5, USART_IT_RXNE ) != RESET ) { ch = USART_ReceiveData( UART5 ); if( ( ch == 0x0a ) && ( last_ch == 0x0d ) ) /*遇到0d 0a 表明结束*/ { uart5_rxbuf.body[uart5_rxbuf.wr++] = ch; if( uart5_rxbuf.wr < 124 ) { //--------- fliter useful------ if((strncmp((char *)uart5_rxbuf.body + 3, "RMC,", 4) == 0) || (strncmp((char *)uart5_rxbuf.body + 3, "TXT,", 4) == 0) || \ (strncmp((char *)uart5_rxbuf.body + 3, "GGA,", 4) == 0)) //||(strncmp((char*)uart5_rxbuf.body+3,"GSA,",4)==0)) { rt_mq_send( &mq_gps, (void *)&uart5_rxbuf, uart5_rxbuf.wr + 2 ); } } uart5_rxbuf.wr = 0; } else { // 1. get head char if(ch == '$') uart5_rxbuf.wr = 0; // 2. judge head char if(uart5_rxbuf.body[0] != '$') // add later uart5_rxbuf.wr = 0; // 3. rx data uart5_rxbuf.body[uart5_rxbuf.wr++] = ch; if( uart5_rxbuf.wr == UART5_RX_SIZE ) { uart5_rxbuf.wr = 0; } uart5_rxbuf.body[uart5_rxbuf.wr] = 0; } last_ch = ch; USART_ClearITPendingBit( UART5, USART_IT_RXNE ); } rt_interrupt_leave( ); }
static rt_size_t _vcom_tx(struct rt_serial_device *serial, const char *buf, rt_size_t size) { struct vcom_tx_msg msg; RT_ASSERT(serial != RT_NULL); RT_ASSERT(buf != RT_NULL); msg.buf = buf; msg.serial = serial; msg.size = size; if (rt_mq_send(&vcom_tx_thread_mq, (void*)&msg, sizeof(struct vcom_tx_msg)) != RT_EOK) { rt_kprintf("vcom send msg fail\n"); return 0; } return size; }
void rt_appNRF24L01_thread_entry(void* parameter) { rt_err_t result = RT_ERROR;//RT_EOK;RT_ERROR CommunicationProtocol cp; while(1) { RF24L01_RX_Mode(); result = RF24l01_Rx_Dat(&rxbuf[0]); if(result == RT_EOK) { result = getProtocalData(&cp,&rxbuf[0]); if(result == RT_EOK){ //rt_kprintf("%04X",cp.authentication); rt_mq_send(protocalData_mq, &cp, sizeof(CommunicationProtocol)); } } else rt_thread_delay(RT_TICK_PER_SECOND); } }
rt_err_t rtgui_thread_send(rt_thread_t tid, rtgui_event_t* event, rt_size_t event_size) { rt_err_t result; struct rtgui_thread* thread; rtgui_event_dump(tid, event); /* if (event->type != RTGUI_EVENT_TIMER) rt_kprintf("event size: %d\n", event_size); */ /* find rtgui_thread */ thread = (struct rtgui_thread*) (tid->user_data); if (thread == RT_NULL) return -RT_ERROR; result = rt_mq_send(thread->mq, event, event_size); if (result != RT_EOK) { if (event->type != RTGUI_EVENT_TIMER) rt_kprintf("send event to %s failed\n", thread->tid->name); } return result; }
rt_err_t rtgui_send_sync(struct rtgui_app* app, rtgui_event_t *event, rt_size_t event_size) { rt_err_t r; rt_int32_t ack_buffer, ack_status; struct rt_mailbox ack_mb; RT_ASSERT(app != RT_NULL); RT_ASSERT(event != RT_NULL); RT_ASSERT(event_size != 0); rtgui_event_dump(app, event); /* init ack mailbox */ r = rt_mb_init(&ack_mb, "ack", &ack_buffer, 1, 0); if (r != RT_EOK) goto __return; event->ack = &ack_mb; r = rt_mq_send(app->mq, event, event_size); if (r != RT_EOK) { rt_kprintf("send sync event failed\n"); goto __return; } r = rt_mb_recv(&ack_mb, (rt_uint32_t *)&ack_status, RT_WAITING_FOREVER); if (r != RT_EOK) goto __return; if (ack_status != RTGUI_STATUS_OK) r = -RT_ERROR; else r = RT_EOK; __return: /* fini ack mailbox */ rt_mb_detach(&ack_mb); return r; }
void crtpRxTask(void *param) { CRTPPacket p; static unsigned int droppedPacket=0; while (RT_TRUE) { if (!link->receivePacket(&p)) { if(queues[p.port]) { // TODO: If full, remove one packet and then send //xQueueSend(queues[p.port], &p, 0); rt_mq_send(queues[p.port], &p, sizeof(CRTPPacket)); } else { droppedPacket++; } if(callbacks[p.port]) callbacks[p.port](&p); //Dangerous? } } }
rt_err_t rtgui_thread_send_sync(rt_thread_t tid, rtgui_event_t* event, rt_size_t event_size) { rt_err_t r; struct rtgui_thread* thread; rt_int32_t ack_buffer, ack_status; struct rt_mailbox ack_mb; rtgui_event_dump(tid, event); /* init ack mailbox */ r = rt_mb_init(&ack_mb, "ack", &ack_buffer, 1, 0); if ( r!= RT_EOK) goto __return; /* find rtgui_thread */ thread = (struct rtgui_thread*) (tid->user_data); if (thread == RT_NULL){ r = RT_ERROR; goto __return; } event->ack = &ack_mb; r = rt_mq_send(thread->mq, event, event_size); if (r != RT_EOK) { rt_kprintf("send sync event failed\n"); goto __return; } r = rt_mb_recv(&ack_mb, (rt_uint32_t*)&ack_status, RT_WAITING_FOREVER); if ( r!= RT_EOK) goto __return; if (ack_status != RTGUI_STATUS_OK) r = -RT_ERROR; else r = RT_EOK; /* fini ack mailbox */ rt_mb_detach(&ack_mb); __return: return r; }
static void com_thread_entry(void *parameter) { rt_err_t ret; uint8_t payload[MAX_RECV_PACKET_SIZE - (sizeof(PACKET) - 1)]; uint8_t packet_buffer[MAX_SEND_PACKET_SIZE]; uint16_t packet_len; TEST_CMD test_cmd; uint32_t voltage, current, ac; uint8_t test_type; uint8_t test_status; com_port_set_read_callback(packet_receive_callback); com_port_init(); while (RT_TRUE) { /* wait for payload */ RT_ASSERT(s_payload_queue != RT_NULL); ret = rt_mq_recv(s_payload_queue, payload, sizeof(payload), RT_WAITING_FOREVER); if (ret == RT_EOK) { /* do cmd */ uint8_t cmd = payload[0]; switch (cmd) { case CMD_CV_MODE: { PAYLOAD_CMD_CV_MODE *payload_cv_mode = (PAYLOAD_CMD_CV_MODE *)payload; TRACE("CMD_CV_MODE\n"); packet_len = build_cv_mode_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), RESULT_OK); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } /* notify work thread */ test_cmd.test_type = TEST_TYPE_CV_MODE; test_cmd.test_config.cv_mode_config.voltage_val = payload_cv_mode->voltage_val; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); } break; case CMD_CC_MODE: { PAYLOAD_CMD_CC_MODE *payload_cc_mode = (PAYLOAD_CMD_CC_MODE *)payload; TRACE("CMD_CC_MODE\n"); packet_len = build_cc_mode_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), RESULT_OK); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } /* notify work thread */ test_cmd.test_type = TEST_TYPE_CC_MODE; test_cmd.test_config.cc_mode_config.current_val = payload_cc_mode->current_val; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); } break; case CMD_CR_MODE: { PAYLOAD_CMD_CR_MODE *payload_cr_mode = (PAYLOAD_CMD_CR_MODE *)payload; TRACE("CMD_CR_MODE\n"); packet_len = build_cr_mode_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), RESULT_OK); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } /* notify work thread */ test_cmd.test_type = TEST_TYPE_CR_MODE; test_cmd.test_config.cr_mode_config.resist_val = payload_cr_mode->resist_val; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); } break; case CMD_CV_TEST: { PAYLOAD_CMD_CV_TEST *payload_cv_test = (PAYLOAD_CMD_CV_TEST *)payload; TRACE("CMD_CV_TEST\n"); packet_len = build_cv_test_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), RESULT_OK); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } /* notify work thread */ test_cmd.test_type = TEST_TYPE_CV_TEST; test_cmd.test_config.cv_test_config.test_category = payload_cv_test->test_category; test_cmd.test_config.cv_test_config.voltage_level = payload_cv_test->voltage_level; test_cmd.test_config.cv_test_config.voltage_val = payload_cv_test->voltage_val; test_cmd.test_config.cv_test_config.duration = payload_cv_test->duration; test_cmd.test_config.cv_test_config.ac_upper = payload_cv_test->ac_upper; test_cmd.test_config.cv_test_config.current_lower = payload_cv_test->current_lower; test_cmd.test_config.cv_test_config.current_upper = payload_cv_test->current_upper; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); } break; case CMD_CC_TEST: { PAYLOAD_CMD_CC_TEST *payload_cc_test = (PAYLOAD_CMD_CC_TEST *)payload; TRACE("CMD_CC_TEST\n"); packet_len = build_cc_test_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), RESULT_OK); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } /* notify work thread */ test_cmd.test_type = TEST_TYPE_CC_TEST; test_cmd.test_config.cc_test_config.test_category = payload_cc_test->test_category; test_cmd.test_config.cc_test_config.voltage_level = payload_cc_test->voltage_level; test_cmd.test_config.cc_test_config.current_val = payload_cc_test->current_val; test_cmd.test_config.cc_test_config.duration = payload_cc_test->duration; test_cmd.test_config.cc_test_config.ac_upper = payload_cc_test->ac_upper; test_cmd.test_config.cc_test_config.voltage_lower = payload_cc_test->voltage_lower; test_cmd.test_config.cc_test_config.voltage_upper = payload_cc_test->voltage_upper; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); } break; case CMD_CR_TEST: { PAYLOAD_CMD_CR_TEST *payload_cr_test = (PAYLOAD_CMD_CR_TEST *)payload; TRACE("CMD_CR_TEST\n"); packet_len = build_cr_test_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), RESULT_OK); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } /* notify work thread */ test_cmd.test_type = TEST_TYPE_CR_TEST; test_cmd.test_config.cr_test_config.test_category = payload_cr_test->test_category; test_cmd.test_config.cr_test_config.voltage_level = payload_cr_test->voltage_level; test_cmd.test_config.cr_test_config.resist_val = payload_cr_test->resist_val; test_cmd.test_config.cr_test_config.duration = payload_cr_test->duration; test_cmd.test_config.cr_test_config.ac_upper = payload_cr_test->ac_upper; test_cmd.test_config.cr_test_config.voltage_lower = payload_cr_test->voltage_lower; test_cmd.test_config.cr_test_config.voltage_upper = payload_cr_test->voltage_upper; test_cmd.test_config.cr_test_config.current_lower = payload_cr_test->current_lower; test_cmd.test_config.cr_test_config.current_upper = payload_cr_test->current_upper; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); } break; case CMD_EMPTY_LOAD_TEST: { PAYLOAD_CMD_EMPTY_LOAD_TEST *payload_empty_load_test = (PAYLOAD_CMD_EMPTY_LOAD_TEST *)payload; TRACE("CMD_EMPTY_LOAD_TEST\n"); packet_len = build_empty_load_test_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), RESULT_OK); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } /* notify work thread */ test_cmd.test_type = TEST_TYPE_EMPTY_LOAD_TEST; test_cmd.test_config.empty_load_test_config.duration = payload_empty_load_test->duration; test_cmd.test_config.empty_load_test_config.ac_upper = payload_empty_load_test->ac_upper; test_cmd.test_config.empty_load_test_config.voltage_lower = payload_empty_load_test->voltage_lower; test_cmd.test_config.empty_load_test_config.voltage_upper = payload_empty_load_test->voltage_upper; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); } break; case CMD_OVER_CURRENT_TEST: { PAYLOAD_CMD_OVER_CURRENT_TEST *payload_over_current_test = (PAYLOAD_CMD_OVER_CURRENT_TEST *)payload; TRACE("CMD_OVER_CURRENT_TEST\n"); packet_len = build_over_current_test_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), RESULT_OK); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } /* notify work thread */ test_cmd.test_type = TEST_TYPE_OVER_CURRENT_TEST; test_cmd.test_config.over_current_test_config.test_category = payload_over_current_test->test_category; test_cmd.test_config.over_current_test_config.voltage_level = payload_over_current_test->voltage_level; test_cmd.test_config.over_current_test_config.interval = payload_over_current_test->interval; test_cmd.test_config.over_current_test_config.ac_upper = payload_over_current_test->ac_upper; test_cmd.test_config.over_current_test_config.current_upper = payload_over_current_test->current_upper; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); } break; case CMD_SHORT_TEST: { PAYLOAD_CMD_SHORT_TEST *payload_short_test = (PAYLOAD_CMD_SHORT_TEST *)payload; TRACE("CMD_SHORT_TEST\n"); packet_len = build_short_test_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), RESULT_OK); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } /* notify work thread */ test_cmd.test_type = TEST_TYPE_SHORT_TEST; test_cmd.test_config.short_test_config.test_category = payload_short_test->test_category; test_cmd.test_config.short_test_config.voltage_level = payload_short_test->voltage_level; test_cmd.test_config.short_test_config.duration = payload_short_test->duration; test_cmd.test_config.short_test_config.ac_upper = payload_short_test->ac_upper; test_cmd.test_config.short_test_config.current_upper = payload_short_test->current_upper; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); } break; case CMD_DISCHARGE_TEST: { PAYLOAD_CMD_DISCHARGE_TEST *payload_discharge_test = (PAYLOAD_CMD_DISCHARGE_TEST *)payload; TRACE("CMD_DISCHARGE_TEST\n"); packet_len = build_discharge_test_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), RESULT_OK); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } /* notify work thread */ test_cmd.test_type = TEST_TYPE_DISCHARGE_TEST; test_cmd.test_config.discharge_test_config.duration = payload_discharge_test->duration; test_cmd.test_config.discharge_test_config.current_val = payload_discharge_test->current_val; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); } break; case CMD_STOP: { TRACE("CMD_STOP\n"); packet_len = build_stop_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), RESULT_OK); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } /* notify work thread */ test_cmd.test_type = TEST_TYPE_NONE; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); } break; case CMD_POLL: /* get value */ RT_ASSERT(g_sem_test_content != RT_NULL); rt_sem_take(g_sem_test_content, RT_WAITING_FOREVER); if (g_test_content.test_type == TEST_TYPE_OVER_CURRENT_TEST && g_test_content.test_status == TEST_STATUS_NORMAL) { current = g_over_current_test_result.over_current_test_current; voltage = g_over_current_test_result.over_current_test_voltage; if (g_over_current_test_result.over_current_test_ac > s_ac_offset_value) { ac = g_over_current_test_result.over_current_test_ac - s_ac_offset_value; } else { ac = 0; } } else { current = g_test_content.current; voltage = g_test_content.voltage; if (g_test_content.ac_current > s_ac_offset_value) { ac = g_test_content.ac_current - s_ac_offset_value; } else { ac = 0; } } test_type = g_test_content.test_type; test_status = g_test_content.test_status; rt_sem_release(g_sem_test_content); packet_len = build_poll_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), test_type, test_status, ac, voltage, current); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); } break; case CMD_SET_ADJUST_VALUE: { PAYLOAD_CMD_SET_ADJUST_VALUE *payload_set_adjust_value = (PAYLOAD_CMD_SET_ADJUST_VALUE *)payload; ADJUST_PARAMETER.measure_voltage = payload_set_adjust_value->measure_voltage; ADJUST_PARAMETER.actual_voltage = payload_set_adjust_value->actual_voltage; ADJUST_PARAMETER.measure_current = payload_set_adjust_value->measure_current; ADJUST_PARAMETER.actual_current = payload_set_adjust_value->actual_current; save_parameter(); } break; case CMD_GET_ADJUST_VALUE: TRACE("get adjust\n"); packet_len = build_get_adjust_value_cmd_ret_packet(packet_buffer, sizeof(packet_buffer), ADJUST_PARAMETER.measure_voltage, ADJUST_PARAMETER.actual_voltage, ADJUST_PARAMETER.measure_current, ADJUST_PARAMETER.actual_current); if (packet_len != PACKET_TOO_LONG) { /* reply */ com_port_write(packet_buffer, packet_len); TRACE("get adjust value ret:measure voltage:%d,actual voltage:%d,measure current:%d,actual current:%d\n", ADJUST_PARAMETER.measure_voltage, ADJUST_PARAMETER.actual_voltage, ADJUST_PARAMETER.measure_current, ADJUST_PARAMETER.actual_current); } RT_ASSERT(g_sem_test_content != RT_NULL); rt_sem_take(g_sem_test_content, RT_WAITING_FOREVER); s_ac_offset_value = g_test_content.ac_current; rt_sem_release(g_sem_test_content); /* notify work thread */ test_cmd.test_type = TEST_TYPE_NONE; RT_ASSERT(g_test_cmd_queue != RT_NULL); rt_mq_send(g_test_cmd_queue, &test_cmd, sizeof(test_cmd)); break; default: break; } } } }
rt_err_t crtpSendPacketBlock(CRTPPacket *p) { RT_ASSERT(p); return rt_mq_send(tmpQueue, p, sizeof(CRTPPacket));//xQueueSend(tmpQueue, p, portMAX_DELAY); }
static void packet_receive_callback(uint8_t *payload, uint16_t payload_size) { RT_ASSERT(s_payload_queue != RT_NULL); rt_mq_send(s_payload_queue, payload, payload_size); }
rt_err_t crtpSendPacket(CRTPPacket *p) { RT_ASSERT(p); return rt_mq_send(tmpQueue, p, sizeof(CRTPPacket));//xQueueSend(tmpQueue, p, 0); }
static void key_thread_entry(void *parameter) { #ifdef RT_USING_RTGUI rt_time_t next_delay; rt_uint8_t i; struct rtgui_event_kbd kbd_event; key_io_init(); /* init keyboard event */ RTGUI_EVENT_KBD_INIT(&kbd_event); kbd_event.mod = RTGUI_KMOD_NONE; kbd_event.unicode = 0; while (1) { next_delay = RT_TICK_PER_SECOND/10; kbd_event.key = RTGUIK_UNKNOWN; kbd_event.type = RTGUI_KEYDOWN; if (KEY_ENTER_GETVALUE() == 0 ) { for(i=0; ; i++) { rt_thread_delay( next_delay ); if (KEY_ENTER_GETVALUE() == 0) { if (i>=4) { /* HOME key */ kbd_event.key = RTGUIK_HOME; next_delay = RT_TICK_PER_SECOND/5; break; } } else { kbd_event.key = RTGUIK_RETURN; break; } } } if (KEY_DOWN_GETVALUE() == 0) { kbd_event.key = RTGUIK_DOWN; } if (KEY_UP_GETVALUE() == 0) { kbd_event.key = RTGUIK_UP; } if (KEY_RIGHT_GETVALUE() == 0) { kbd_event.key = RTGUIK_RIGHT; } if (KEY_LEFT_GETVALUE() == 0) { kbd_event.key = RTGUIK_LEFT; } if (kbd_event.key != RTGUIK_UNKNOWN) { /* post down event */ rtgui_server_post_event(&(kbd_event.parent), sizeof(kbd_event)); } else { kbd_event.type = RTGUI_KEYUP; rtgui_server_post_event(&(kbd_event.parent), sizeof(kbd_event)); } /* wait next key press */ rt_thread_delay(next_delay); } #else extern struct rt_messagequeue mq; rt_time_t next_delay; struct lcd_msg msg; msg.type = KEY_MSG; key_io_init(); while (1) { msg.key = NO_KEY; next_delay = RT_TICK_PER_SECOND/10; if (KEY_ENTER_GETVALUE() == 0 ) { msg.key = KEY_ENTER; } if (KEY_DOWN_GETVALUE() == 0) { msg.key = KEY_DOWN; } if (KEY_UP_GETVALUE() == 0) { msg.key = KEY_UP; } if (KEY_RIGHT_GETVALUE() == 0) { msg.key = KEY_RIGHT; } if (KEY_LEFT_GETVALUE() == 0) { msg.key = KEY_LEFT; } rt_mq_send(&mq, &msg, sizeof(msg)); /* wait next key press */ rt_thread_delay(next_delay); } #endif }
static void _cbDialog(WM_MESSAGE * pMsg) { int i; WM_HWIN hItem; int NCode; int Id; gui_msg_t msg; msg.exec = RT_NULL; switch (pMsg->MsgId) { case WM_INIT_DIALOG: hItem = pMsg->hWin; WM_EnableMemdev(hItem); //WM_MoveTo(hItem, 0, -30); //WM_MOTION_SetMoveable(hItem, WM_CF_MOTION_Y, 1); WINDOW_SetBkColor(hItem, GUI_WHITE); int fd; /* load APP */ for(i=0;i<GUI_COUNTOF(UIApp);i++) { hItem = BUTTON_CreateAsChild(10, 10, 50, 50, pMsg->hWin, UIApp[i].GUID, WM_CF_SHOW); BUTTON_SetText(hItem, UIApp[i].text); WM_EnableMemdev(hItem); struct stat s; stat(UIApp[i].logoPath, &s); UIApp[i].plogo = rt_malloc(s.st_size); if(UIApp[i].plogo) { fd = open(UIApp[i].logoPath, O_RDONLY , 0); if(fd >=0) { rt_kprintf("%s", UIApp[i].logoPath); read(fd, UIApp[i].plogo, s.st_size); //WM_MoveTo(hItem, 0+(i%2)*120, (i/2)*120 + 0); WM_SetSize(hItem, GUI_BMP_GetXSize(UIApp[i].plogo), GUI_BMP_GetYSize(UIApp[i].plogo)); //xPos+= xSize; //yPos+= ySize; BUTTON_SetBMPEx(hItem, BUTTON_BI_UNPRESSED, UIApp[i].plogo ,0, 0); BUTTON_SetBMPEx(hItem, BUTTON_BI_PRESSED, UIApp[i].plogo ,1, 1); BUTTON_SetTextOffset(hItem, 0, 50); close(fd); } } else { rt_kprintf("no mem!\r\n"); } } /* algin Apps */ int xPos, yPos, xSize, ySize; xPos = 0; xSize = 0; yPos = 0; ySize = 0; for(i=0;i<GUI_COUNTOF(UIApp);i++) { hItem = WM_GetDialogItem(pMsg->hWin, UIApp[i].GUID); xSize = GUI_BMP_GetXSize(UIApp[i].plogo); ySize = GUI_BMP_GetYSize(UIApp[i].plogo); if(xSize == 0 || xSize > 9999) { xSize = 60; } if(ySize == 0 || ySize > 9999) { ySize = 60; } if(abs(LCD_GetXSize() - xPos) >= xSize) { WM_MoveTo(hItem, xPos, yPos); xPos+=xSize; } else { xPos = 0; yPos+=ySize; WM_MoveTo(hItem, xPos, yPos); xPos+=xSize; } } // char *p; // p = rt_malloc(38399); // fd = open("/SD/DESKTOP.JPG",O_RDONLY , 0); // read(fd, p, 38399); // hItem = WM_GetDialogItem(pMsg->hWin, ID_IMAGE_0); // WM_EnableMemdev(hItem); // IMAGE_SetJPEG(hItem, p, 38399); break; case WM_NOTIFY_PARENT: Id = WM_GetId(pMsg->hWinSrc); NCode = pMsg->Data.v; if(NCode == WM_NOTIFICATION_RELEASED) { for(i=0;i<GUI_COUNTOF(UIApp);i++) { if(Id == UIApp[i].GUID) { msg.exec = UIApp[i].exec; break; } } if(msg.exec != RT_NULL) { rt_mq_send(guimq, &msg, sizeof(msg)); } } break; default: WM_DefaultProc(pMsg); break; } }