/**
* This function will initialize the usb host stack, all the usb class driver and
* host controller driver are also be initialized here.
*
* @return none.
*/
rt_err_t rt_usb_host_init(void)
{
ucd_t drv;
rt_device_t uhc;
#ifdef RT_USBH_HID
uprotocal_t protocal;
#endif
uhc = rt_device_find(USB_HOST_CONTROLLER_NAME);
if(uhc == RT_NULL)
{
rt_kprintf("can't find usb host controller %s\n", USB_HOST_CONTROLLER_NAME);
return -RT_ERROR;
}
/* initialize usb hub */
rt_usbh_hub_init();
/* initialize class driver */
rt_usbh_class_driver_init();
#ifdef RT_USBH_MSTORAGE
/* register mass storage class driver */
drv = rt_usbh_class_driver_storage();
rt_usbh_class_driver_register(drv);
#endif
#ifdef RT_USBH_HID
/* register hid class driver */
drv = rt_usbh_class_driver_hid();
rt_usbh_class_driver_register(drv);
#ifdef RT_USBH_HID_KEYBOARD
/* register hid keyboard protocal */
protocal = rt_usbh_hid_protocal_kbd();
rt_usbh_hid_protocal_register(protocal);
#endif
#ifdef RT_USBH_HID_MOUSE
/* register hid mouse protocal */
protocal = rt_usbh_hid_protocal_mouse();
rt_usbh_hid_protocal_register(protocal);
#endif
#endif
#ifdef RT_USBH_ADK
/* register adk class driver */
drv = rt_usbh_class_driver_adk();
rt_usbh_class_driver_register(drv);
#endif
/* register hub class driver */
drv = rt_usbh_class_driver_hub();
rt_usbh_class_driver_register(drv);
/* initialize usb host controller */
rt_device_init(uhc);
return RT_EOK;
}
void rt_init_thread_entry(void *parameter)
{
#ifdef RT_USING_COMPONENTS_INIT
/* initialization RT-Thread Components */
rt_components_init();
#endif
rt_platform_init();
/* Filesystem Initialization */
#ifdef RT_USING_DFS
/* mount sd card fat partition 1 as root directory */
if (dfs_mount("sd0", "/", "elm", 0, 0) == 0)
{
rt_kprintf("File System initialized!\n");
}
else rt_kprintf("File System initialzation failed!\n");
#endif
#ifdef RT_USING_RTGUI
gui_init();
picture_show();
/* initial touch. */
{
rt_device_t device;
device = rt_device_find("touch");
if (device != RT_NULL)
{
rt_device_init(device);
}
}
#endif /* RT_USING_RTGUI */
}
/**
* @brief USBH_USR_MSC_Application
* Demo application for mass storage
* @param None
* @retval Staus
*/
int USBH_USR_MSC_Application( void )
{
// FRESULT res;
int ret;
if( diskinited )
{
return 0;
}
mscdev.type = RT_Device_Class_Block;
mscdev.init = msc_init;
mscdev.open = msc_open;
mscdev.close = msc_close;
mscdev.read = msc_read;
mscdev.write = msc_write;
mscdev.control = msc_control;
mscdev.user_data = RT_NULL;
diskinited = 1;
rt_device_register( &mscdev, "udisk", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE );
rt_device_init( &mscdev );
rt_thread_delay( RT_TICK_PER_SECOND / 10 );
//ret = dfs_mount( "udisk", "/udisk", "elm", 0, 0 );
if(0 == f_mount(USB, &fs))
{
rt_kprintf("\n f_mount USB OK!");
}
//rt_kprintf( "\ndfs_mount ret=%x now udisk start", ret );
return 0;
}
/**
* @brief USBH_USR_MSC_Application
* Demo application for mass storage
* @param None
* @retval Staus
*/
int USBH_USR_MSC_Application( void )
{
int ret;
if( diskinited )
{
return 0;
}
mscdev.type = RT_Device_Class_Block;
mscdev.init = msc_init;
mscdev.open = msc_open;
mscdev.close = msc_close;
mscdev.read = msc_read;
mscdev.write = msc_write;
mscdev.control = msc_control;
mscdev.user_data = RT_NULL;
diskinited = 1;
rt_device_register( &mscdev, "udisk", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE );
rt_device_init( &mscdev );
rt_thread_delay( RT_TICK_PER_SECOND / 10 );
ret = dfs_mount( "udisk", "/udisk", "elm", 0, 0 );
rt_kprintf( "dfs_mount ret=%x now udisk start\r\n", ret );
USB_find_status = USB_FIND;
Show_Menu_5_2_ExportData();
return 0;
}
/*RS485设备初始化*/
void RS485_init( void )
{
//rt_sem_init( &sem_RS485, "sem_RS485", 0, 0 );
rt_mq_init( &mq_RS485, "mq_RS485", &RS485_rawinfo[0], 128 - sizeof( void* ), RS485_RAWINFO_SIZE, RT_IPC_FLAG_FIFO );
dev_RS485.type = RT_Device_Class_Char;
dev_RS485.init = dev_RS485_init;
dev_RS485.open = dev_RS485_open;
dev_RS485.close = dev_RS485_close;
dev_RS485.read = dev_RS485_read;
dev_RS485.write = dev_RS485_write;
dev_RS485.control = dev_RS485_control;
rt_device_register( &dev_RS485, "RS485", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE );
rt_device_init( &dev_RS485 );
Cam_Device_init( );
rt_thread_init( &thread_RS485,
"RS485",
rt_thread_entry_RS485,
RT_NULL,
&thread_RS485_stack[0],
sizeof( thread_RS485_stack ), 9, 5 );
rt_thread_startup( &thread_RS485 );
}
/***********************************************************
* Function:
* Description:
* Input:
* Input:
* Output:
* Return:
* Others:
***********************************************************/
void mma8451_driver_init( void )
{
dev_mma8451.type = RT_Device_Class_Char;
dev_mma8451.init = mma8451_init;
dev_mma8451.open = mma8451_open;
dev_mma8451.close = mma8451_close;
dev_mma8451.read = mma8451_read;
dev_mma8451.write = mma8451_write;
dev_mma8451.control = mma8451_control;
dev_mma8451.user_data = RT_NULL;
rt_device_register( &dev_mma8451, "sensor", RT_DEVICE_FLAG_RDWR );
rt_device_init( &dev_mma8451 );
}
/* init 485 */
void _485_startup(void)
{
Device_485.type = RT_Device_Class_Char;
Device_485.init = Device_485_init;
Device_485.open = Device_485_open;
Device_485.close = Device_485_close;
Device_485.read = Device_485_read;
Device_485.write = Device_485_write;
Device_485.control = Device_485_control;
rt_device_register( &Device_485, "485", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE );
rt_device_init( &Device_485 );
}
static err_t eth_netif_device_init(struct netif *netif)
{
struct eth_device *ethif;
ethif = (struct eth_device*)netif->state;
if (ethif != NULL)
{
rt_device_t device;
/* get device object */
device = (rt_device_t) ethif;
if (rt_device_init(device) != RT_EOK)
{
return ERR_IF;
}
/* copy device flags to netif flags */
netif->flags = ethif->flags;
/* set default netif */
if (netif_default == NULL)
netif_set_default(ethif->netif);
#if LWIP_DHCP
if (ethif->flags & NETIF_FLAG_DHCP)
{
/* if this interface uses DHCP, start the DHCP client */
dhcp_start(ethif->netif);
}
else
#endif
{
/* set interface up */
netif_set_up(ethif->netif);
}
#ifdef LWIP_NETIF_LINK_CALLBACK
netif_set_link_up(ethif->netif);
#endif
return ERR_OK;
}
return ERR_IF;
}
/* init gsm */
void _gsm_startup(void)
{
rt_err_t result;
// 二. RT 相关初始化
//------------- sem init ---------------------------------
// 创建DF 读写信号量
rt_sem_init( &sem_DF, "sem_DF", 0, 0 );
rt_sem_release( &sem_DF);
rt_mq_init( &mq_GSM, "mq_GSM", &GSM_rawinfo[0], 1400 - sizeof( void * ), GSM_RAWINFO_SIZE, RT_IPC_FLAG_FIFO );
//--------- timer_gsm ----------
// 1. create timer 100ms=Dur
timer_gsm = rt_timer_create("tim_gsm", timeout_gsm, RT_NULL, 100, RT_TIMER_FLAG_PERIODIC); //| RT_TIMER_FLAG_SOFT_TIMER);
// 2. start timer
if(timer_gsm != RT_NULL)
rt_timer_start(timer_gsm);
result = rt_thread_init(&gsm_thread,
"GsmThrd",
gsm_thread_entry, RT_NULL,
&gsm_thread_stack[0], sizeof(gsm_thread_stack),
Prio_GSM, 10);
if (result == RT_EOK)
{
rt_thread_startup(&gsm_thread);
}
Device_GSM.type = RT_Device_Class_Char;
Device_GSM.init = Device_GSM_init;
Device_GSM.open = Device_GSM_open;
Device_GSM.close = Device_GSM_close;
Device_GSM.read = Device_GSM_read;
Device_GSM.write = Device_GSM_write;
Device_GSM.control = Device_GSM_control;
rt_device_register( &Device_GSM, "GsmDev", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE );
rt_device_init( &Device_GSM );
}
void rt_hw_usart_init()
{
/*初始化接收缓冲区*/
rt_ringbuffer_init(&rb_vuart,vuart_rxbuf,VUART_RXBUF_SIZE);
dev_vuart.type = RT_Device_Class_Char;
dev_vuart.init = dev_vuart_init;
dev_vuart.open = dev_vuart_open;
dev_vuart.close = dev_vuart_close;
dev_vuart.read = dev_vuart_read;
dev_vuart.write = dev_vuart_write;
dev_vuart.control = dev_vuart_control;
dev_vuart.rx_indicate = RT_NULL;
dev_vuart.tx_complete = RT_NULL;
rt_device_register( &dev_vuart, "vuart", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STREAM );
rt_device_init( &dev_vuart );
}
static err_t eth_netif_device_init(struct netif *netif)
{
struct eth_device *ethif;
ethif = (struct eth_device*)netif->state;
if (ethif != RT_NULL)
{
rt_device_t device;
/* get device object */
device = (rt_device_t) ethif;
if (rt_device_init(device) != RT_EOK)
{
return ERR_IF;
}
/* copy device flags to netif flags */
netif->flags = (ethif->flags & 0xff);
/* set default netif */
if (netif_default == RT_NULL)
netif_set_default(ethif->netif);
#if LWIP_DHCP
/* set interface up */
netif_set_up(ethif->netif);
/* if this interface uses DHCP, start the DHCP client */
dhcp_start(ethif->netif);
#else
/* set interface up */
netif_set_up(ethif->netif);
#endif
if (!(ethif->flags & ETHIF_LINK_PHYUP))
{
/* set link_up for this netif */
netif_set_link_up(ethif->netif);
}
return ERR_OK;
}
return ERR_IF;
}
static err_t netif_device_init(struct netif *netif)
{
struct eth_device *ethif;
ethif = (struct eth_device*)netif->state;
if (ethif != NULL)
{
rt_device_t device;
/* get device object */
device = (rt_device_t) ethif;
if (rt_device_init(device) != RT_EOK)
{
return ERR_IF;
}
return ERR_OK;
}
return ERR_IF;
}
int device_test(const char * device_name)
{
rt_device_t device = RT_NULL;
// step 1:find device
device = rt_device_find(device_name);
if( device == RT_NULL)
{
rt_kprintf("device %s: not found!\r\n");
return RT_ERROR;
}
// step 2:init device
if (!(device->flag & RT_DEVICE_FLAG_ACTIVATED))
{
rt_err_t result;
result = rt_device_init(device);
if (result != RT_EOK)
{
rt_kprintf("To initialize device:%s failed. The error code is %d\r\n",
device->parent.name, result);
return result;
}
else
{
device->flag |= RT_DEVICE_FLAG_ACTIVATED;
}
}
// step 3: device test
switch( device->type )
{
case RT_Device_Class_Block :
rt_kprintf("block device!\r\n");
return _block_device_test(device);
default:
rt_kprintf("unkown device type : %02X",device->type);
return RT_ERROR;
}
}
void gui_init()
{
extern void rtgui_touch_hw_init(void);
extern rt_err_t load_setup(void);
rtgui_rect_t rect;
rt_device_t lcd;
/* 初始化LCD驱动 */
ra8875_init();
lcd = rt_device_find("lcd");
if (lcd != RT_NULL)
{
rt_device_init(lcd);
rtgui_graphic_set_device(lcd);
/* 初始化RT-Thread/GUI server */
rtgui_system_server_init();
/* 注册面板 */
rect.x1 = 0;
rect.y1 = 0;
rect.x2 = 800;
rect.y2 = 480;
rtgui_panel_register("main", &rect);
rtgui_panel_set_default_focused("main");
/* 初始化键盘驱动 */
// rt_hw_key_init();
/* 初始化触摸屏驱动 */
// load_setup(); //touch装载默认值
// rtgui_touch_hw_init();
rt_device_init_all();
/* 初始化workbench */
workbench_init();
}
}
/*gps设备初始化*/
void gps_init( void )
{
//rt_sem_init( &sem_gps, "sem_gps", 0, 0 );
//rt_mq_init( &mq_gps, "mq_gps", &gps_rawinfo[0], 128 - sizeof( void* ), GPS_RAWINFO_SIZE, RT_IPC_FLAG_FIFO );
rt_thread_init( &thread_gps,
"gps",
rt_thread_entry_gps,
RT_NULL,
&thread_gps_stack[0],
sizeof( thread_gps_stack ), Prio_GPS, 6 );
rt_thread_startup( &thread_gps );
dev_gps.type = RT_Device_Class_Char;
dev_gps.init = dev_gps_init;
dev_gps.open = dev_gps_open;
dev_gps.close = dev_gps_close;
dev_gps.read = dev_gps_read;
dev_gps.write = dev_gps_write;
dev_gps.control = dev_gps_control;
rt_device_register( &dev_gps, "gps", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE );
rt_device_init( &dev_gps );
}
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);
}
}
}
rt_err_t rt_usb_device_init(const char* udc_name)
{
rt_device_t udc;
udevice_t udevice;
uconfig_t cfg;
uclass_t cls;
RT_ASSERT(udc_name != RT_NULL);
udc = rt_device_find(udc_name);
if(udc == RT_NULL)
{
rt_kprintf("can't find usb device controller %s\n", udc_name);
return -RT_ERROR;
}
/* create and startup usb device thread */
rt_usbd_core_init();
/* create a device object */
udevice = rt_usbd_device_create(ustring);
/* set usb controller driver to the device */
rt_usbd_device_set_controller(udevice, (udcd_t)udc);
/* create a configuration object */
cfg = rt_usbd_config_create();
#ifdef RT_USB_DEVICE_MSTORAGE
/* create a mass storage class object */
cls = rt_usbd_class_mstorage_create(udevice);
/* add the class to the configuration */
rt_usbd_config_add_class(cfg, cls);
#endif
#ifdef RT_USB_DEVICE_CDC
/* create a cdc class object */
cls = rt_usbd_class_cdc_create(udevice);
/* add the class to the configuration */
rt_usbd_config_add_class(cfg, cls);
#endif
/* set device descriptor to the device */
#ifdef RT_USB_DEVICE_COMPOSITE
rt_usbd_device_set_descriptor(udevice, &compsit_desc);
#else
rt_usbd_device_set_descriptor(udevice, cls->dev_desc);
#endif
/* add the configuration to the device */
rt_usbd_device_add_config(udevice, cfg);
/* set default configuration to 1 */
rt_usbd_set_config(udevice, 1);
/* initialize usb device controller */
rt_device_init(udc);
return RT_EOK;
}
static void keypress(unsigned int key)
{
switch(key)
{
case KEY_MENU:
pMenuItem=&Menu_5_other;
pMenuItem->show();
concuss_screen=0;
break;
case KEY_OK:
if(concuss_screen==0)
{
concuss_screen=1;
if( jt808_param.id_0x005D != concuss_step )
{
jt808_param.id_0x005D = concuss_step;
param_save(1);
rt_device_init( &dev_mma8451 );
}
#if NEED_TODO
JT808Conf_struct.concuss_step=concuss_step;
Api_Config_Recwrite_Large(jt808,0,(u8*)&JT808Conf_struct,sizeof(JT808Conf_struct));
#endif
concuss_dis[9]=concuss_step/10+'0';
concuss_dis[10]=concuss_step%10+'0';
lcd_fill(0);
lcd_text12(20,3,"震动级别设置成功",16,LCD_MODE_SET);
lcd_text12(30,19,(char *)concuss_dis,sizeof(concuss_dis),LCD_MODE_SET);
lcd_update_all();
}
break;
case KEY_UP:
if(concuss_screen==0)
{
if(concuss_step==0)
concuss_step=79;
else if(concuss_step>=1)
concuss_step--;
concuss_dis[9]=concuss_step/10+'0';
concuss_dis[10]=concuss_step%10+'0';
lcd_fill(0);
lcd_text12(30,10,(char *)concuss_dis,sizeof(concuss_dis),LCD_MODE_SET);
lcd_update_all();
}
break;
case KEY_DOWN:
if(concuss_screen==0)
{
concuss_step++;
if(concuss_step>79)
concuss_step=0;
concuss_dis[9]=concuss_step/10+'0';
concuss_dis[10]=concuss_step%10+'0';
lcd_fill(0);
lcd_text12(30,10,(char *)concuss_dis,sizeof(concuss_dis),LCD_MODE_SET);
lcd_update_all();
}
break;
}
}
