rt_err_t crtpReceivePacketWait(CRTPPort portId, CRTPPacket *p, int wait) {
RT_ASSERT(queues[portId]);
RT_ASSERT(p);
// return xQueueReceive(queues[portId], p, M2T(wait));
return rt_mq_recv(queues[portId], p, sizeof(CRTPPacket), M2T(wait));
}
rt_err_t rtgui_recv_filter(rt_uint32_t type, rtgui_event_t *event, rt_size_t event_size)
{
struct rtgui_app *app;
RT_ASSERT(event != RT_NULL);
RT_ASSERT(event_size != 0);
app = (struct rtgui_app *)(rt_thread_self()->user_data);
if (app == RT_NULL)
return -RT_ERROR;
while (rt_mq_recv(app->mq, event, event_size, RT_WAITING_FOREVER) == RT_EOK)
{
if (event->type == type)
{
return RT_EOK;
}
else
{
if (RTGUI_OBJECT(app)->event_handler != RT_NULL)
{
RTGUI_OBJECT(app)->event_handler(RTGUI_OBJECT(app), event);
}
}
}
return -RT_ERROR;
}
/**
* This function is the main entry of usb hub thread, it is in charge of
* processing all messages received from the usb message buffer.
*
* @param parameter the parameter of the usb host thread.
*
* @return none.
*/
static void rt_usbh_hub_thread_entry(void* parameter)
{
while(1)
{
struct uhost_msg msg;
/* receive message */
if(rt_mq_recv(usb_mq, &msg, sizeof(struct uhost_msg), RT_WAITING_FOREVER)
!= RT_EOK ) continue;
RT_DEBUG_LOG(RT_DEBUG_USB, ("msg type %d\n", msg.type));
switch (msg.type)
{
case USB_MSG_CONNECT_CHANGE:
rt_usbh_hub_port_change(msg.content.hub);
break;
case USB_MSG_CALLBACK:
/* invoke callback */
msg.content.cb.function(msg.content.cb.context);
break;
default:
break;
}
}
}
/* Vcom Tx Thread */
static void vcom_tx_thread_entry(void* parameter)
{
struct vcom_tx_msg msg;
while (1)
{
if (rt_mq_recv(&vcom_tx_thread_mq, (void*)&msg,
sizeof(struct vcom_tx_msg), RT_WAITING_FOREVER) == RT_EOK)
{
struct ufunction *func;
struct vcom *data;
func = (struct ufunction*)msg.serial->parent.user_data;
data = (struct vcom*)func->user_data;
if (!data->connected)
{
continue;
}
rt_completion_init(&data->wait);
data->ep_in->request.buffer = (void*)msg.buf;
data->ep_in->request.size = msg.size;
data->ep_in->request.req_type = UIO_REQUEST_WRITE;
rt_usbd_io_request(func->device, data->ep_in, &data->ep_in->request);
if (rt_completion_wait(&data->wait, TX_TIMEOUT) != RT_EOK)
{
rt_kprintf("vcom tx timeout\n");
}
}
}
}
rt_err_t rtgui_recv_filter(rt_uint32_t type, rtgui_event_t *event, rt_size_t event_size)
{
rtgui_event_t *e;
struct rtgui_app *app;
RT_ASSERT(event != RT_NULL);
RT_ASSERT(event_size != 0);
app = (struct rtgui_app *)(rt_thread_self()->user_data);
if (app == RT_NULL)
return -RT_ERROR;
e = (rtgui_event_t*)&app->event_buffer[0];
while (rt_mq_recv(app->mq, e, sizeof(union rtgui_event_generic), RT_WAITING_FOREVER) == RT_EOK)
{
if (e->type == type)
{
rt_memcpy(event, e, event_size);
return RT_EOK;
}
else
{
if (RTGUI_OBJECT(app)->event_handler != RT_NULL)
{
RTGUI_OBJECT(app)->event_handler(RTGUI_OBJECT(app), e);
}
}
}
return -RT_ERROR;
}
void fnAlarm(void)
{
rt_uint32_t e;
uint8_t buf,int_m,t=0;
uint16_t delay1,delay2,strength;
rt_thread_delay_hmsm(0,0,3,0);
int_m = (clock_m+5)%60;
rt_kprintf("It is %d:%d now\nAlarm Level %d\n",clock_h,clock_m,t);
rt_event_send(reg_event,REG_ALARM_MSK);
while (rt_mq_recv(key_mq,&buf,sizeof(uint8_t),0)!=RT_EOK)
{
if (clock_m==int_m)
{
t+=1;
int_m = (int_m+5)%60;
rt_kprintf("Alarm Level %d\n",t);
}
switch (t)
{
case 0: delay1 = 500; delay2 = 4500; strength = 400; break;
case 1: delay1 = 1000; delay2 = 2000; strength = 600; break;
case 2: delay1 = 500; delay2 = 500; strength = 800; break;
default: delay1 = 500; delay2 = 250; strength = 1000; break;
}
SetAlarm(strength);
rt_thread_delay_hmsm(0,0,0,delay1);
SetAlarm(0);
Animate(delay2);
}
rt_event_recv(reg_event,REG_ALARM_MSK,RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,0,&e);
return;
}
/***********************************************************
* Function:
* Description:
* Input:
* Input:
* Output:
* Return:
* Others:
***********************************************************/
static void rt_thread_entry_gps( void* parameter )
{
rt_err_t res;
// 1. init
GPS_Abnormal_init();
//2. main while
while( 1 )
{
res = rt_mq_recv( &mq_gps, (void*)&gps_rx, 124, RT_TICK_PER_SECOND / 20 ); //等待100ms,实际上就是变长的延时,最长100ms
if( res == RT_EOK ) //收到一包数据
{
if( flag_bd_upgrade_uart == 0 )
{
GPS_Rx_Process( gps_rx.body, gps_rx.wr );
GPS_Abnormal_process();// GPS 模块异常检测
}else
{
if( gps_rx.body[0] == 0x40 )
{
rt_device_write( &dev_vuart, 0, gps_rx.body, gps_rx.wr);
}
}
}
rt_thread_delay(6 );
}
}
rt_err_t rtgui_thread_recv_filter(rt_uint32_t type, rtgui_event_t* event, rt_size_t event_size)
{
struct rtgui_thread* thread;
/* find rtgui_thread */
thread = (struct rtgui_thread*) (rt_thread_self()->user_data);
if (thread == RT_NULL) return -RT_ERROR;
while (rt_mq_recv(thread->mq, event, event_size, RT_WAITING_FOREVER) == RT_EOK)
{
if (event->type == type)
{
return RT_EOK;
}
else
{
/* let widget to handle event */
if (thread->widget != RT_NULL &&
thread->widget->event_handler != RT_NULL)
{
thread->widget->event_handler(thread->widget, event);
}
}
}
return -RT_ERROR;
}
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);
}
}
}
rt_err_t crtpReceivePacket(CRTPPort portId, CRTPPacket *p)
{
RT_ASSERT(queues[portId]);
RT_ASSERT(p);
//return xQueueReceive(queues[portId], p, 0);
return rt_mq_recv(queues[portId], p, sizeof(CRTPPacket), RT_WAITING_FOREVER);
}
// 1. MsgQueue Rx
rt_err_t rt_Rx_hmi2gsm_MsgQue(u8 *buffer,u16 rec_len)
{
if(rt_mq_recv(&hmi2gsm_mq,&buffer[0], rec_len, MsgQ_Timeout) //RT_WAITING_FOREVER
!= RT_EOK )
return RT_ERROR;
else
return RT_EOK;
}
rt_err_t rt_Rx_hmi2app808_MsgQue(u8 *buffer,u16 rec_len)
{
if(rt_mq_recv(&hmi2app808_mq,&buffer[0], rec_len, MsgQ_Timeout)
!= RT_EOK )
return RT_ERROR;
else
return RT_EOK;
}
static void led_thread_entry(void* parameter)
{
rt_uint8_t ledStatus;
rt_hw_led_init();
ledData_mq = rt_mq_create("LEDMQ",1,2,RT_IPC_FLAG_FIFO);
while (1)
{
if(rt_mq_recv(ledData_mq,&ledStatus,1,RT_WAITING_FOREVER) == RT_EOK)
{
if(ledStatus &0x10)
{
rt_hw_led_on(4);
}
else
{
rt_hw_led_off(4);
}
if(ledStatus &0x08)
{
rt_hw_led_on(3);
}
else
{
rt_hw_led_off(3);
}
if(ledStatus &0x04)
{
rt_hw_led_on(2);
}
else
{
rt_hw_led_off(2);
}
if(ledStatus &0x2)
{
rt_hw_led_on(1);
}
else
{
rt_hw_led_off(1);
}
if(ledStatus &0x01)
{
rt_hw_led_on(0);
}
else
{
rt_hw_led_off(0);
}
}
}
}
void crtpTxTask(void *param)
{
CRTPPacket p;
while (RT_TRUE)
{
//if (xQueueReceive(tmpQueue, &p, portMAX_DELAY) == pdRT_TRUE)
if (rt_mq_recv(tmpQueue, &p, sizeof(CRTPPacket), RT_WAITING_FOREVER) == RT_EOK)
{
link->sendPacket(&p);
}
}
}
rt_err_t rtgui_thread_recv_nosuspend(rtgui_event_t* event, rt_size_t event_size)
{
struct rtgui_thread* thread;
rt_err_t r;
/* find rtgui_thread */
thread = (struct rtgui_thread*) (rt_thread_self()->user_data);
if (thread == RT_NULL) return -RT_ERROR;
r = rt_mq_recv(thread->mq, event, event_size, 0);
return r;
}
rt_err_t rtgui_recv(rtgui_event_t *event, rt_size_t event_size, rt_int32_t timeout)
{
struct rtgui_app *app;
rt_err_t r;
RT_ASSERT(event != RT_NULL);
RT_ASSERT(event_size != 0);
app = (struct rtgui_app *)(rt_thread_self()->user_data);
if (app == RT_NULL) return -RT_ERROR;
r = rt_mq_recv(app->mq, event, event_size, timeout);
return r;
}
/***********************************************************
* Function:
* Description:
* Input:
* Input:
* Output:
* Return:
* Others:
***********************************************************/
static void rt_thread_entry_gps( void *parameter )
{
rt_err_t res;
// 1. init
GPS_Abnormal_init();
//2. main while
while( 1 )
{
// 1. rx data
res = rt_mq_recv( &mq_gps, (void *)&gps_rx, 124, 2 ); //等待100ms,实际上就是变长的延时,最长100ms
if(res == RT_EOK ) //收到一包数据
{
;
}
rt_thread_delay(30);
gps_thread_runCounter = 0;
}
}
/// Get a Message or Wait for a Message from a Queue
osEvent osMessageGet(osMessageQId queue_id, uint32_t millisec)
{
osEvent event;
rt_err_t result;
rt_tick_t ticks;
ticks = rt_tick_from_millisecond(millisec);
result = rt_mq_recv(queue_id, &event.value, 4, ticks);
if (result == RT_EOK)
{
event.status = osEventMessage;
}
else
{
event.status = osEventTimeout;
}
return event;
}
static Ret ftk_source_touch_dispatch(FtkSource* thiz)
{
DECL_PRIV(thiz, priv);
struct rt_touch_event touchevent;
rt_mq_recv(&priv->mq, &touchevent, sizeof(touchevent), RT_WAITING_FOREVER);
priv->event.type = FTK_EVT_NOP;
priv->event.u.mouse.x = touchevent.x;
priv->event.u.mouse.y = touchevent.y;
if (touchevent.pressed)
{
if (priv->pressed)
{
priv->event.type = FTK_EVT_MOUSE_MOVE;
}
else
{
priv->event.type = FTK_EVT_MOUSE_DOWN;
priv->pressed = 1;
}
}
else
{
if (priv->pressed)
{
priv->event.type = FTK_EVT_MOUSE_UP;
}
priv->pressed = 0;
}
if (priv->on_event != NULL && priv->event.type != FTK_EVT_NOP)
{
priv->on_event(priv->user_data, &priv->event);
priv->event.type = FTK_EVT_NOP;
}
return RET_OK;
}
void update_radio_thread(void* parameter)
{
rt_err_t result;
struct player_request request;
/* get request from message queue */
result = rt_mq_recv(update_radio_mq, (void*)&request,
sizeof(struct player_request), RT_WAITING_FOREVER);
if (result == RT_EOK)
{
switch (request.type)
{
case PLAYER_REQUEST_UPDATE_RADIO_LIST:
if ((strstr(request.fn, "http://") == request.fn ||
(strstr(request.fn, "HTTP://") == request.fn )))
{
struct rtgui_event_command ecmd;
if(update_radio_list(request.fn)==0)
{
update_radio_list_state = UPDATE_RADIO_LIST_SUCCEED;
}
else
{
update_radio_list_state = UPDATE_RADIO_LIST_CONNECT_FAILED;
}
RTGUI_EVENT_COMMAND_INIT(&ecmd);
ecmd.type = RTGUI_EVENT_PAINT;
ecmd.command_id = PLAYER_REQUEST_UPDATE_RADIO_LIST;
rtgui_thread_send(rt_thread_find("ply_ui"), &ecmd.parent, sizeof(ecmd));
}
break;
}
}
rt_mq_delete(update_radio_mq);
update_radio_mq = RT_NULL;
}
void usb_thread_entry(void* parameter)
{
int i;
rt_thread_t tid;
msd_msg_t msg;
dev = rt_device_find(MOUNT_DEVICE);
if(!dev)
{
rt_kprintf("no %s device found!\r\n", MOUNT_DEVICE);
tid = rt_thread_self();
rt_thread_delete(tid);
}
rt_device_init(dev);
rt_device_open(dev, RT_DEVICE_OFLAG_RDWR);
usbd_init(); /* USB Device Initialization */
usbd_connect(__TRUE); /* USB Device Connect */
while (!usbd_configured ())
{
rt_thread_delay(10);
}
rt_kprintf("usb enum complete\r\n");
while(1)
{
if(rt_mq_recv(msd_mq, &msg, sizeof(msd_msg_t), RT_WAITING_FOREVER) == RT_EOK)
{
if(msg.dir == 0) USBD_MSC_EP_BULKOUT_Event(0);
else USBD_MSC_EP_BULKIN_Event (0);
}
}
}
static void net_buf_thread_entry(void* parameter)
{
rt_err_t result;
struct net_buffer_job job;
while (1)
{
/* get a job */
result = rt_mq_recv(_netbuf_mq, (void*)&job, sizeof(struct net_buffer_job), RT_WAITING_FOREVER);
if (result == RT_EOK)
{
/* set stat to buffering */
if (_netbuf.stat == NETBUF_STAT_BUFFERING)
{
/* reset data length and read/save index */
_netbuf.data_length = 0;
_netbuf.read_index = _netbuf.save_index = 0;
/* perform the job */
net_buf_do_job(&job);
}
}
}
}
void thread_gps_upgrade_udisk( void* parameter )
{
#define READ_PACKET_SIZE 1012
void ( *msg )( void *p );
int fd = -1, size;
u32 count = 0;
rt_uint8_t *pdata; /*数据*/
rt_uint8_t buf[32];
rt_uint8_t ch_h, ch_l;
rt_err_t res;
LENGTH_BUF uart_buf;
rt_uint32_t file_datalen; /*升级文件长度*/
rt_uint8_t file_matchcode[2]; /*文件匹配码*/
rt_uint16_t packet_num;
rt_uint16_t crc;
msg = parameter;
ptr_mem_packet = rt_malloc( READ_PACKET_SIZE+20 );
if( ptr_mem_packet == RT_NULL )
{
msg( "E内存不足" );
return;
}
/*查找U盘*/
while( 1 )
{
if( rt_device_find( "udisk" ) == RT_NULL ) /*没有找到*/
{
count++;
if( count <= 10 )
{
msg( "I等待U盘插入" );
BD_upgrad_contr=1;
}else
{
msg( "EU盘不存在" ); /*指示U盘不存在*/
BD_upgrad_contr=1;
goto end_upgrade_usb_0;
}
rt_thread_delay( RT_TICK_PER_SECOND );
}else
{
msg( "I查找升级文件" );
break;
}
WatchDog_Feed();
}
/*查找指定文件BEIDOU.IMG*/
fd = open( "/udisk/BEIDOU.IMG", O_RDONLY, 0 );
if( fd >= 0 )
{
msg( "I分析文件" );
}else
{
msg( "E升级文件不存在" );
goto end_upgrade_usb_0;
}
size = read( fd, ptr_mem_packet, 16 );
pdata = ptr_mem_packet;
if( ( *pdata != 0x54 ) || ( *( pdata + 1 ) != 0x44 ) )
{
msg( "E文件头错误" );
goto end_upgrade_usb_1;
}
ch_h = ( *( pdata + 9 ) & 0xf0 ) >> 4;
ch_l = ( *( pdata + 9 ) & 0xf );
sprintf( buf, "I版本:%d.%d.%d", ch_h, ch_l, *( pdata + 10 ) );
msg( buf );
/*升级数据长度*/
file_datalen =0;
file_datalen = ( *( pdata + 11 ) ) << 24;
file_datalen |= ( *( pdata + 12 ) ) << 16;
file_datalen |= ( *( pdata + 13 ) ) << 8;
file_datalen |= *( pdata + 14 );
rt_kprintf("file_datalen=%x",file_datalen);
/*文件匹配码在尾部*/
count = 0;
ch_h = 0;
do{
res = read( fd, ptr_mem_packet,READ_PACKET_SIZE );
if(res) count = res;
WatchDog_Feed();
}while(res>0);
//rt_kprintf("res=%02x\r\n",res);
//if(res==0) res=READ_PACKET_SIZE;
if( ( ptr_mem_packet[count - 1] != 0x54 ) || ( ptr_mem_packet[count - 2] != 0x44 ) )
{
msg( "E文件尾错误" );
goto end_upgrade_usb_1;
}
file_matchcode[0] = ptr_mem_packet[count - 6];
file_matchcode[1] = ptr_mem_packet[count - 5];
rt_kprintf("file datalen=%x matchcode=%02x%02x",file_datalen,file_matchcode[0],file_matchcode[1]);
close( fd );
msg( "I配置端口" );
fd = open( "/udisk/BEIDOU.IMG", O_RDONLY, 0 );
if( fd < 0 )
{
msg( "E升级文件不存在" );
goto end_upgrade_usb_0;
}
/*开始升级*/
/*停止gps线程*/
rt_thread_suspend( &thread_gps );
/*进入升级状态*/
memcpy( buf, "\x40\x30\xC0\x00\x03\x00\x01\x34\x21\x0D\x0A", 11 );
dev_gps_write( &dev_gps, 0, buf, 11 );
rt_thread_delay( RT_TICK_PER_SECOND );
/*版本查询*/
count = 0;
dev_gps_write( &dev_gps, 0, "\x40\x10\xC0\x00\x10\x00\x01\xC2\x84\x0D\x0A", 11 );
while( 1 )
{
rt_thread_delay(RT_TICK_PER_SECOND/10);
res = rt_mq_recv( &mq_gps, (void*)&uart_buf, 124, 5 );
if( res == RT_EOK ) //收到一包数据
{
count=0; // clear
rt_kprintf("\r\n版本查询\r\n");
for( ch_h = 0; ch_h < uart_buf.wr; ch_h++ )
{
rt_kprintf( "%02x ", uart_buf.body[ch_h] );
}
rt_kprintf( "\r\n" );
if( ( uart_buf.wr == 15 ) && ( uart_buf.body[4] == 0x02 ) ) /*进入升级状态*/
{
ch_h = ( uart_buf.body[7] & 0xf0 ) >> 4;
ch_l = ( uart_buf.body[7] & 0xf );
sprintf( buf, "I版本:%d.%d.%d", ch_h, ch_l, uart_buf.body[8] );
msg( buf );
break;
}
}else /*超时*/
void player_thread(void* parameter)
{
rt_err_t result;
struct player_request request;
while(1)
{
/* get request from message queue */
result = rt_mq_recv(player_thread_mq, (void*)&request,
sizeof(struct player_request), RT_WAITING_FOREVER);
if (result == RT_EOK)
{
switch (request.type)
{
case PLAYER_REQUEST_PLAY_SINGLE_FILE:
if ((strstr(request.fn, ".mp3") != RT_NULL) ||
(strstr(request.fn, ".MP3") != RT_NULL))
{
is_playing = RT_TRUE;
player_notify_play();
/* get music tag information */
mp3(request.fn);
player_notify_stop();
is_playing = RT_FALSE;
}
else if ((strstr(request.fn, ".wav") != RT_NULL) ||
(strstr(request.fn, ".WAV") != RT_NULL))
{
is_playing = RT_TRUE;
player_notify_play();
wav(request.fn);
player_notify_stop();
is_playing = RT_FALSE;
}
else if ((strstr(request.fn, "http://") == request.fn ||
(strstr(request.fn, "HTTP://") == request.fn )))
{
is_playing = RT_TRUE;
player_notify_play();
ice_mp3(request.fn, request.station);
/* notfiy net buffer worker to stop */
net_buf_stop_job();
player_notify_stop();
is_playing = RT_FALSE;
}
else if (strstr(request.fn, "douban://") == request.fn)
{
is_playing = RT_TRUE;
player_notify_play();
douban_radio(request.fn, request.station);
/* notfiy net buffer worker to stop */
net_buf_stop_job();
player_notify_stop();
is_playing = RT_FALSE;
}
break;
}
}
}
}
void rt_thread_alarm_entry (void *parameter)
{
uint8_t buf;
uint16_t t;
rt_uint32_t e;
AlarmerInit();
SetAlarm(0);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
if (PWR_GetFlagStatus(PWR_FLAG_WU)==SET)
{
rt_kprintf("\n\nWaken up by DS3231\n");
if ((IIC_Read(DS3231_ADDRESS, DS3231_CON_STA)) & 0x01) fnAlarm();
IIC_Write(DS3231_ADDRESS, DS3231_CON_STA,0x80);
}
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, DISABLE);
while (rt_mq_recv(key_mq,&buf,sizeof(uint8_t),10)==RT_EOK);
while (1)
{
do
{
rt_mq_recv(key_mq,&buf,sizeof(uint8_t),RT_WAITING_FOREVER);
}while(buf!=0);
t = 0;
reg_output[REG_ALARM]=0xF777F7F7;
rt_event_send(reg_event,REG_ALARM_MSK);
rt_mq_recv(key_mq,&buf,sizeof(uint8_t),RT_WAITING_FOREVER);
if (buf>9)
{
rt_event_recv(reg_event,REG_ALARM_MSK,RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,0,&e);
continue;
}
t = buf;
reg_output[REG_ALARM]=(0x01000000*REG_HexToReg(buf)) | (0x00FFFFFF & reg_output[REG_ALARM]) | 0x80000000;
rt_mq_recv(key_mq,&buf,sizeof(uint8_t),RT_WAITING_FOREVER);
if (buf>9)
{
rt_event_recv(reg_event,REG_ALARM_MSK,RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,0,&e);
continue;
}
t = t*10+buf;
reg_output[REG_ALARM]=(0x00010000*REG_HexToReg(buf)) | (0xFF00FFFF & reg_output[REG_ALARM]);
rt_mq_recv(key_mq,&buf,sizeof(uint8_t),RT_WAITING_FOREVER);
if (buf>9)
{
rt_event_recv(reg_event,REG_ALARM_MSK,RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,0,&e);
continue;
}
t = t*10+buf;
reg_output[REG_ALARM]=(0x00000100*REG_HexToReg(buf)) | (0xFFFF00FF & reg_output[REG_ALARM]);
rt_mq_recv(key_mq,&buf,sizeof(uint8_t),RT_WAITING_FOREVER);
if (buf>9)
{
rt_event_recv(reg_event,REG_ALARM_MSK,RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,0,&e);
continue;
}
t = t*10+buf;
reg_output[REG_ALARM]=(0x00000001*REG_HexToReg(buf)) | (0xFFFFFF00 & reg_output[REG_ALARM]);
rt_mq_recv(key_mq,&buf,sizeof(uint8_t),RT_WAITING_FOREVER);
if (buf<=9)
{
rt_event_recv(reg_event,REG_ALARM_MSK,RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,0,&e);
continue;
}else
{
if (fnSetAlarmClock(t/100,t%100,buf==0x0B)==ERROR)
rt_event_recv(reg_event,REG_ALARM_MSK,RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,0,&e);
}
}
}
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;
}
}
}
}
void rt_init_thread_entry(void *parameter)
{
rt_device_t lcd;
rt_hw_led_init();
rt_hw_key_init();
rt_hw_adc_init();
rt_hw_lcd_init();
rt_hw_cpu_init();
#ifdef RT_USING_RTGUI
extern void rtgui_system_server_init(void);
/* find lcd device */
lcd = rt_device_find("lcd");
/* set lcd device as rtgui graphic driver */
rtgui_graphic_set_device(lcd);
/* init rtgui system server */
rtgui_system_server_init();
/* startup rtgui */
rtgui_startup();
#else
{
char buf[20] = {'\0'};
struct lcd_msg msg;
rt_device_t device;
device = rt_device_find("lcd");
rt_device_control(device, RT_DEVICE_CTRL_LCD_CLEAR_SCR, RT_NULL);
x = 1;
y = 1;
rt_device_control(device, RT_DEVICE_CTRL_LCD_PUT_STRING, "ADC");
x = 1;
y = 20;
rt_device_control(device, RT_DEVICE_CTRL_LCD_PUT_STRING, "CPU");
x = 1;
y = 40;
rt_device_control(device, RT_DEVICE_CTRL_LCD_PUT_STRING, "KEY");
while(1)
{
if (rt_mq_recv(&mq, &msg, sizeof(msg), RT_WAITING_FOREVER) == RT_EOK)
{
switch(msg.type)
{
case ADC_MSG:
x = 40;
y = 1;
rt_memset(buf, 0, sizeof(buf));
rt_sprintf(buf, "%04d", msg.adc_value);
rt_device_control(device, RT_DEVICE_CTRL_LCD_PUT_STRING, buf);
break;
case CPU_MSG:
x = 40;
y = 20;
rt_memset(buf, 0, sizeof(buf));
rt_sprintf(buf, "%03d %03d", msg.major, msg.minor);
rt_device_control(device, RT_DEVICE_CTRL_LCD_PUT_STRING, buf);
break;
case KEY_MSG:
x = 40;
y = 40;
rt_memset(buf, 0, sizeof(buf));
switch(msg.key)
{
case KEY_DOWN:
rt_sprintf(buf, "DOWN KEY ");
break;
case KEY_UP:
rt_sprintf(buf, "UP KEY ");
break;
case KEY_RIGHT:
rt_sprintf(buf, "RIGHT KEY");
break;
case KEY_LEFT:
rt_sprintf(buf, "LEFT KEY ");
break;
case KEY_ENTER:
rt_sprintf(buf, "ENTER KEY");
break;
default:
rt_sprintf(buf, "NO KEY ");
break;
}
rt_device_control(device, RT_DEVICE_CTRL_LCD_PUT_STRING, buf);
break;
}
}
}
}
#endif
}
void LCDPANELProcess_thread_entry(void* parameter)
{
struct rx_msg msg;
rt_device_t device;
// 从RT系统中获取串口1设备
device = rt_device_find("uart1");
if (device != RT_NULL)
{
/* 设置回调函数及打开设备*/
rt_device_set_rx_indicate(device, uart_input);
// 以读写方式打开设备
rt_device_open(device, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
}
rt_thread_delay(50); //* Release 1 second cpu time solt for other module init function */
IWDG_ReloadCounter();
rt_thread_delay(50);
while (1)
{
IWDG_ReloadCounter();
MessageTX[7]=0X01;
rt_thread_delay( RT_TICK_PER_SECOND/20 ); /* sleep 0.5 second and switch to other thread */
while (rt_mq_recv(&rx_mq, &msg, sizeof(struct rx_msg), 50) == RT_EOK)
{
rt_uint32_t rx_length;
test1++;
rx_length = (sizeof(QueryLCDRxBuf) - 1) > msg.size ? msg.size : sizeof(QueryLCDRxBuf) - 1;
/* 读取消息*/
rx_length = rt_device_read(msg.dev, 0, &QueryLCDRxBuf[0], rx_length);
if(QueryLCDRxBuf[0] != 0xaa)
{
break;
}
while (rx_length < 10)
{
if (rt_mq_recv(&rx_mq, &msg, sizeof(struct rx_msg), 5) == RT_EOK)
{
rt_device_read(msg.dev, 0, &QueryLCDRxBuf[rx_length++], 1);
}
else
{
break;
}
}
if ((rx_length == 10) && (QueryLCDRxBuf[9] == 0xcc))
{
QueryLCDRxBuf[rx_length] = '\0';
if((QueryLCDRxBuf[1]==0x01)&&(StartupMark==1))//LCD启动，而且车启动时
{
if((QueryLCDRxBuf[2]==0x01)|(GSM_flag==1))//LCD手动模式开,且GSM有信号时
{
// MessageTX[12] = rxlen;
MessageTX[13] = 0x03;
MD=0; //开风机
MessageTX[11]=0x01;//风机启动状态
fwsRlyWindOpen(RLY_WIND_MD_FLAG,FELAY_DELAY_FOREVER);
}
else if((QueryLCDRxBuf[2]==0x00)&(GSM_flag==0))//LCD手动模式关,且GSM有信号时
{
// MessageTX[12] = rxlen;
MessageTX[13] = 0x04;
MD=1;//关风机
fwsRlyWindClose(RLY_WIND_MD_FLAG);
}
else
{
// MessageTX[12] = rxlen;
MessageTX[13] = 0x02;
}
}
else if((QueryLCDRxBuf[1]==0x00)||(StartupMark==0))//LCD关闭，而且车熄火
{
MessageTX[12] = StartupMark;
MessageTX[13] = 0x05;
MD=1; //关风机
if(StartupMark==0)
fwsRlyWindClose(RLY_WIND_ALLOFF_FLAG);
else
fwsRlyWindClose(RLY_WIND_MD_FLAG);
}
else
{
// MessageTX[12] = rxlen;
MessageTX[13] = 0x06;
}
// if(QueryLCDRxBuf[7]==0x01)//自动模式时
// {
// MessageTX[12]=QueryLCDRxBuf[5];
// MessageTX[13]=QueryLCDRxBuf[6];
// }
}
else
{
break;
}
rt_device_write(msg.dev, 0, &MessageTX[0], SENDTO_LCD_LEN);
}
}
}
