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;
}
}
