void rt_hw_uart_init(void) { struct rt_uart_lpc* uart; #ifdef RT_USING_UART0 /* get uart device */ uart = &uart0_device; uart0_device.UART = LPC_UART0; uart0_device.UART_IRQn = UART0_IRQn; /* device initialization */ uart->parent.type = RT_Device_Class_Char; rt_memset(uart->rx_buffer, 0, sizeof(uart->rx_buffer)); uart->read_index = uart->save_index = 0; /* device interface */ uart->parent.init = rt_uart_init; uart->parent.open = rt_uart_open; uart->parent.close = rt_uart_close; uart->parent.read = rt_uart_read; uart->parent.write = rt_uart_write; uart->parent.control = RT_NULL; uart->parent.user_data = RT_NULL; rt_device_register(&uart->parent, "uart0", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STREAM | RT_DEVICE_FLAG_INT_RX); #endif #ifdef RT_USING_UART1 /* get uart device */ uart = &uart1_device; uart1_device.UART = (LPC_UART_TypeDef *)LPC_UART1; uart1_device.UART_IRQn = UART1_IRQn; /* device initialization */ uart->parent.type = RT_Device_Class_Char; rt_memset(uart->rx_buffer, 0, sizeof(uart->rx_buffer)); uart->read_index = uart->save_index = 0; /* device interface */ uart->parent.init = rt_uart_init; uart->parent.open = rt_uart_open; uart->parent.close = rt_uart_close; uart->parent.read = rt_uart_read; uart->parent.write = rt_uart_write; uart->parent.control = RT_NULL; uart->parent.user_data = RT_NULL; rt_device_register(&uart->parent, "uart1", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STREAM | RT_DEVICE_FLAG_INT_RX); #endif }
/** * @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; }
int gd32_hw_lcd_init(void) { _rt_framebuffer = rt_malloc_align(sizeof(rt_uint16_t) * RT_HW_LCD_WIDTH * RT_HW_LCD_HEIGHT, 32); if (_rt_framebuffer == RT_NULL) return -1; /* no memory yet */ lcd_config(); tli_config(); tli_layer_enable(LAYER0); tli_reload_config(TLI_FRAME_BLANK_RELOAD_EN); tli_enable(); _lcd_info.bits_per_pixel = LCD_BITS_PER_PIXEL; _lcd_info.pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565; _lcd_info.framebuffer = (void *)_rt_framebuffer; _lcd_info.width = RT_HW_LCD_WIDTH; _lcd_info.height = RT_HW_LCD_HEIGHT; lcd.type = RT_Device_Class_Graphic; lcd.init = NULL; lcd.open = NULL; lcd.close = NULL; lcd.read = NULL; lcd.write = NULL; lcd.control = rt_lcd_control; lcd.user_data = (void *)&_lcd_info; /* register lcd device to RT-Thread */ rt_device_register(&lcd, "lcd", RT_DEVICE_FLAG_RDWR); return 0; }
/* LCD BL P5_4 */ void rt_hw_lcd_init(void) { rt_uint16_t * _rt_framebuffer = RT_NULL; // _rt_framebuffer = rt_malloc_align(sizeof(rt_uint16_t)*RT_HW_LCD_HEIGHT*RT_HW_LCD_WIDTH, 8); // if (_rt_framebuffer == RT_NULL) return; /* no memory yet */ _rt_framebuffer = (rt_uint16_t *)0xA0000000; _lcd_info.bits_per_pixel = 16; _lcd_info.pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565; _lcd_info.framebuffer = (void*)_rt_framebuffer; _lcd_info.width = RT_HW_LCD_WIDTH; _lcd_info.height = RT_HW_LCD_HEIGHT; /* init device structure */ lcd.type = RT_Device_Class_Graphic; lcd.init = rt_lcd_init; lcd.open = RT_NULL; lcd.close = RT_NULL; lcd.control = rt_lcd_control; lcd.user_data = (void*)&_lcd_info; /* register lcd device to RT-Thread */ rt_device_register(&lcd, "lcd", RT_DEVICE_FLAG_RDWR); }
/** * This function initializes console * */ void rt_hw_console_init(void) { rt_cga_init(); rt_serial_init(); init_keyboard(); /* install keyboard isr */ rt_hw_interrupt_install(INTKEYBOARD, rt_console_isr, RT_NULL, "kbd"); rt_hw_interrupt_umask(INTKEYBOARD); rt_hw_interrupt_install(INTUART0_RX, rt_console_isr, RT_NULL, "COM1"); rt_hw_interrupt_umask(INTUART0_RX); console_device.type = RT_Device_Class_Char; console_device.rx_indicate = RT_NULL; console_device.tx_complete = RT_NULL; console_device.init = rt_console_init; console_device.open = rt_console_open; console_device.close = rt_console_close; console_device.read = rt_console_read; console_device.write = rt_console_write; console_device.control = rt_console_control; console_device.user_data = RT_NULL; /* register a character device */ rt_device_register(&console_device, "console", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM); }
void rt_hw_dc_init(void) { rt_device_t dc = rt_malloc(sizeof(struct rt_device)); if (dc == RT_NULL) { rt_kprintf("dc == RT_NULL\n"); return; /* no memory yet */ } _dc_info.bits_per_pixel = 16; _dc_info.pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565P; _dc_info.framebuffer = (rt_uint8_t*)HW_FB_ADDR; _dc_info.width = FB_XSIZE; _dc_info.height = FB_YSIZE; /* init device structure */ dc->type = RT_Device_Class_Graphic; dc->init = rt_dc_init; dc->open = RT_NULL; dc->close = RT_NULL; dc->control = rt_dc_control; dc->user_data = (void*)&_dc_info; /* register Display Controller device to RT-Thread */ rt_device_register(dc, "dc", RT_DEVICE_FLAG_RDWR); }
void fm25_hw_init() { int i = 0xFFFFF; fm25_spi_cfg(); while(i--); //spi_config(); CS_LOW(); spi_readwrite( FM25_WRDI ); CS_HIGH(); spi_flash_device.type = RT_Device_Class_Block; spi_flash_device.init = fm25_init; spi_flash_device.open = fm25_open; spi_flash_device.close = fm25_close; spi_flash_device.read = fm25_read; spi_flash_device.write = fm25_write; spi_flash_device.control = fm25_control; /* no private */ spi_flash_device.user_data = RT_NULL; rt_device_register(&spi_flash_device, "fram0", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE); }
void rt_hw_rtc_init(void) { rtc.type = RT_Device_Class_RTC; RTC_Init(LPC_RTC); if (RTC_ReadGPREG(LPC_RTC,0) != FIRST_DATA) { rt_kprintf("rtc is not configured\n"); rt_kprintf("please configure with set_date and set_time\n"); } else { } RTC_Cmd(LPC_RTC,ENABLE); /* register rtc device */ rtc.init = RT_NULL; rtc.open = rt_rtc_open; rtc.close = RT_NULL; rtc.read = rt_rtc_read; rtc.write = RT_NULL; rtc.control = rt_rtc_control; /* no private */ rtc.user_data = RT_NULL; rt_device_register(&rtc, "rtc", RT_DEVICE_FLAG_RDWR); #ifdef RT_USING_FINSH { extern void list_date(void); list_date(); } #endif return; }
int rt_hw_lcd_init(const char *name) { struct lcd_device *dev; if(rt_device_find(name)) { return -RT_EIO; } dev = rt_malloc(sizeof(struct lcd_device)); if(!dev) { return RT_ENOMEM; } dev->rtdev.type = RT_Device_Class_Graphic; dev->rtdev.rx_indicate = RT_NULL; dev->rtdev.init = rt_lcd_init; dev->rtdev.open = RT_NULL; dev->rtdev.close = RT_NULL; dev->rtdev.read = RT_NULL; dev->rtdev.write = RT_NULL; dev->rtdev.control = rt_lcd_control; dev->rtdev.user_data = RT_NULL; /* initialize mutex */ rt_mutex_init(&dev->lock, name, RT_IPC_FLAG_FIFO); rt_device_register(&dev->rtdev, name, RT_DEVICE_FLAG_RDWR); return RT_EOK; }
/*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 ); }
static void sdlfb_hw_init(void) { /* set video driver for VC++ debug */ //_putenv("SDL_VIDEODRIVER=windib"); //if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_AUDIO) < 0) if (SDL_Init(SDL_INIT_VIDEO) < 0) { fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError()); exit(1); } _device.parent.init = sdlfb_init; _device.parent.open = sdlfb_open; _device.parent.close = sdlfb_close; _device.parent.read = RT_NULL; _device.parent.write = RT_NULL; _device.parent.control = sdlfb_control; _device.width = SDL_SCREEN_WIDTH; _device.height = SDL_SCREEN_HEIGHT; _device.screen = SDL_SetVideoMode(_device.width, _device.height, 16, SDL_SWSURFACE | SDL_DOUBLEBUF); if (_device.screen == NULL) { fprintf(stderr, "Couldn't set video mode: %s\n", SDL_GetError()); exit(1); } SDL_WM_SetCaption("RT-Thread/GUI Simulator", NULL); rt_device_register(RT_DEVICE(&_device), "sdl", RT_DEVICE_FLAG_RDWR); sdllock = rt_mutex_create("fb", RT_IPC_FLAG_FIFO); }
int stm32_hw_lcd_init(void) { _rt_framebuffer = rt_malloc_align(sizeof(rt_uint16_t) * RT_HW_LCD_WIDTH * RT_HW_LCD_HEIGHT, 32); if (_rt_framebuffer == RT_NULL) return -1; /* no memory yet */ LTDC_CLK_Config(); MX_LTDC_Init(); lcd_backlight_init(); MX_DMA2D_Init(); _lcd_info.bits_per_pixel = LCD_BITS_PER_PIXEL; _lcd_info.pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565; // RTGRAPHIC_PIXEL_FORMAT_ARGB888 _lcd_info.framebuffer = (void *)_rt_framebuffer; _lcd_info.width = RT_HW_LCD_WIDTH; _lcd_info.height = RT_HW_LCD_HEIGHT; /* init device structure */ lcd.type = RT_Device_Class_Graphic; lcd.init = rt_lcd_init; lcd.open = rt_lcd_open; lcd.close = rt_lcd_close; lcd.read = NULL; lcd.write = NULL; lcd.control = rt_lcd_control; lcd.user_data = (void *)&_lcd_info; /* register lcd device to RT-Thread */ rt_device_register(&lcd, "lcd", RT_DEVICE_FLAG_RDWR); return 0; }
rt_err_t ads7843_init(const char * name, const char * spi_device_name) { rt_spi_device = (struct rt_spi_device *)rt_device_find(spi_device_name); if(rt_spi_device == RT_NULL) { rt_kprintf("spi device %s not found!\r\n", spi_device_name); return -RT_ENOSYS; } /* config spi */ { struct rt_spi_configuration cfg; cfg.data_width = 8; cfg.mode = RT_SPI_MODE_0 | RT_SPI_MSB; /* SPI Compatible: Mode 0 and Mode 3 */ cfg.max_hz = 2 * 1000 * 1000; rt_spi_configure(rt_spi_device, &cfg); } /* register device */ ads7843_device.type = RT_Device_Class_Block; ads7843_device.init = RT_NULL; ads7843_device.open = RT_NULL; ads7843_device.close = RT_NULL; ads7843_device.read = ads7843_read; ads7843_device.write = RT_NULL; ads7843_device.control = RT_NULL; /* no private */ ads7843_device.user_data = RT_NULL; rt_device_register(&ads7843_device, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE); return RT_EOK; }
void rt_hw_sd_mmc_init() { if (sd_mmc_spi_internal_init()) { rt_uint8_t *sector = rt_malloc(MMC_SECTOR_SIZE); sd_mmc_spi_read_open(0); if (sd_mmc_spi_read_sector_to_ram(sector)) { if (dfs_filesystem_get_partition(&sd_mmc_partition, sector, 0) != RT_EOK) { sd_mmc_partition.offset = 0; sd_mmc_partition.size = 0; } } else { sd_mmc_partition.offset = 0; sd_mmc_partition.size = 0; } sd_mmc_spi_read_close(); rt_free(sector); rt_device_register(&sd_mmc_device, "sd0", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE); } else { rt_kprintf("Failed to initialize SD/MMC card.\n"); } }
void rt_hw_rtc_init(void) { rtc.type = RT_Device_Class_RTC; if (BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5) { rt_kprintf("rtc is not configured\n"); rt_kprintf("please configure with set_date and set_time\n"); if ( RTC_Configuration() != 0) { rt_kprintf("rtc configure fail...\r\n"); return ; } } else { /* Wait for RTC registers synchronization */ RTC_WaitForSynchro(); } /* register rtc device */ rtc.init = RT_NULL; rtc.open = rt_rtc_open; rtc.close = RT_NULL; rtc.read = rt_rtc_read; rtc.write = RT_NULL; rtc.control = rt_rtc_control; /* no private */ rtc.user_data = RT_NULL; rt_device_register(&rtc, "rtc", RT_DEVICE_FLAG_RDWR); return; }
void rt_hw_console_init(void) { struct rt_lm3s_serial* serial; serial = &serial1; serial->parent.type = RT_Device_Class_Char; serial->hw_base = UART0_BASE; serial->baudrate = 115200; rt_memset(serial->rx_buffer, 0, sizeof(serial->rx_buffer)); serial->read_index = serial->save_index = 0; /* enable UART0 clock */ MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); /* set UART0 pinmux */ MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); /* Configure the UART for 115,200, 8-N-1 operation. */ MAP_UARTConfigSetExpClk(UART0_BASE, MAP_SysCtlClockGet(), serial->baudrate, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); serial->parent.init = rt_serial_init; serial->parent.open = rt_serial_open; serial->parent.close = rt_serial_close; serial->parent.read = rt_serial_read; serial->parent.write = rt_serial_write; serial->parent.control = rt_serial_control; serial->parent.user_data= RT_NULL; rt_device_register(&serial->parent, "uart1", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM); }
/* * serial register */ rt_err_t rt_hw_serial_register(struct rt_serial_device *serial, const char *name, rt_uint32_t flag, void *data) { struct rt_device *device; RT_ASSERT(serial != RT_NULL); device = &(serial->parent); device->type = RT_Device_Class_Char; device->rx_indicate = RT_NULL; device->tx_complete = RT_NULL; device->init = rt_serial_init; device->open = rt_serial_open; device->close = rt_serial_close; device->read = rt_serial_read; device->write = rt_serial_write; device->control = rt_serial_control; device->user_data = data; /* register a character device */ return rt_device_register(device, name, flag); }
/***************************************************************************//** * @brief * Register USART device * * @details * * @note * * @param[in] device * Pointer to device descriptor * * @param[in] name * Device name * * @param[in] flag * Configuration flags * * @param[in] usart * Pointer to USART device descriptor * * @return * Error code ******************************************************************************/ rt_err_t rt_hw_usart_register( rt_device_t device, const char *name, rt_uint32_t flag, struct efm32_usart_device_t *usart) { RT_ASSERT(device != RT_NULL); if ((flag & RT_DEVICE_FLAG_DMA_RX) || (flag & RT_DEVICE_FLAG_INT_TX)) { RT_ASSERT(0); } if (usart->state & USART_STATE_SYNC) { device->type = RT_Device_Class_SPIBUS; } else { device->type = RT_Device_Class_Char; } device->rx_indicate = RT_NULL; device->tx_complete = RT_NULL; device->init = rt_usart_init; device->open = rt_usart_open; device->close = rt_usart_close; device->read = rt_usart_read; device->write = rt_usart_write; device->control = rt_usart_control; device->user_data = usart; /* register a character device */ return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag); }
/***************************************************************************//** * @brief * Register IIC device * * @details * * @note * * @param[in] device * Pointer to device descriptor * * @param[in] name * Device name * * @param[in] flag * Configuration flags * * @param[in] iic * Pointer to IIC device descriptor * * @return * Error code ******************************************************************************/ rt_err_t rt_hw_iic_register( rt_device_t device, const char *name, rt_uint32_t flag, struct efm32_iic_device_t *iic) { RT_ASSERT(device != RT_NULL); if ((flag & RT_DEVICE_FLAG_DMA_TX) || (flag & RT_DEVICE_FLAG_DMA_RX) || (flag & RT_DEVICE_FLAG_INT_TX)) { RT_ASSERT(0); } device->type = RT_Device_Class_Unknown; device->rx_indicate = RT_NULL; device->tx_complete = RT_NULL; device->init = rt_iic_init; device->open = rt_iic_open; device->close = rt_iic_close; device->read = rt_iic_read; device->write = rt_iic_write; device->control = rt_iic_control; device->user_data = iic; /* register a character device */ return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag); }
rt_err_t rt_hw_sdcard_init(const char * spi_device_name) { int size; rt_uint32_t id, total_block; struct sdcard_device * sd; struct rt_device * device; sd = &_sdcard; device = &(sd->parent); lock = rt_mutex_create("lock", RT_IPC_FLAG_FIFO); /* open sd card file, if not exist, then create it */ sd->file = fopen(SDCARD_SIM, "rb+"); if (sd->file == NULL) { /* create a file to simulate sd card */ sd->file = fopen(SDCARD_SIM, "wb+"); fseek(sd->file, 0, SEEK_END); size = ftell(sd->file); fseek(sd->file, 0, SEEK_SET ); if (size < SDCARD_SIZE) { int i; unsigned char* ptr; ptr = (unsigned char*) malloc (1024 * 1024); if (ptr == NULL) { SD_TRACE("malloc error, no memory!\n"); return RT_ERROR; } memset(ptr, 0x0, 1024 * 1024); fseek(sd->file, 0, SEEK_SET); for(i=0; i<(SDCARD_SIZE / (1024*1024)); i++) fwrite(ptr, 1024 * 1024, 1, sd->file); free(ptr); } } fseek(sd->file, 0, SEEK_SET); device->type = RT_Device_Class_Block; device->init = rt_sdcard_init; device->open = rt_sdcard_open; device->close = rt_sdcard_close; device->read = rt_sdcard_read; device->write = rt_sdcard_write; device->control = rt_sdcard_control; device->user_data = NULL; rt_device_register(device, "sd0", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE); return RT_EOK; }
rt_err_t codec_hw_init(void) { rt_device_t dev; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC, ENABLE); RCC_APB1PeriphClockCmd(CODEC_I2S_RCC_APB1, ENABLE); RCC_AHBPeriphClockCmd(CODEC_I2S_RCC_AHB, ENABLE); NVIC_Configuration(); GPIO_Configuration(); I2S_Configuration(I2S_AudioFreq_44k); dev = (rt_device_t) &codec; dev->type = RT_Device_Class_Sound; dev->rx_indicate = RT_NULL; dev->tx_complete = RT_NULL; dev->init = codec_init; dev->open = codec_open; dev->close = codec_close; dev->read = RT_NULL; dev->write = codec_write; dev->control = codec_control; dev->user_data = RT_NULL; /* set read_index and put index to 0 */ codec.read_index = 0; codec.put_index = 0; /* unselect */ codec_set_csb(); /* register the device */ return rt_device_register(&codec.parent, "snd", RT_DEVICE_FLAG_WRONLY | RT_DEVICE_FLAG_DMA_TX); }
void rt_hw_uart_init(void) { // init uart set_baudrate(115200); IOWR_ALTERA_AVALON_UART_CONTROL(RS232_BASE, 0x80);//接收中断使能 IOWR_ALTERA_AVALON_UART_STATUS(RS232_BASE, 0x0); // clean status alt_irq_register(RS232_IRQ, NULL, uart_isr); // register device uart_device.type = RT_Device_Class_Char; /* device interface */ uart_device.init = rt_uart_init; uart_device.open = rt_uart_open; uart_device.close = rt_uart_close; uart_device.read = rt_uart_read; uart_device.write = rt_uart_write; uart_device.control = rt_uart_control; uart_device.user_data = RT_NULL; uart_device.rx_indicate = RT_NULL; uart_device.tx_complete = RT_NULL; rt_device_register(&uart_device, "uart", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STREAM | RT_DEVICE_FLAG_INT_RX); }
/* Keep old drivers compatible in RT-Thread */ Int32 eth_device_init_with_flag(struct eth_device *dev, char *name, UInt8 flags) { struct netif* netif; netif = (struct netif*) malloc (sizeof(struct netif)); if (netif == NULL) { printf("malloc netif failed\n"); return -RT_ERROR; } memset(netif, 0, sizeof(struct netif)); /* set netif */ dev->netif = netif; /* device flags, which will be set to netif flags when initializing */ dev->flags = flags; /* link changed status of device */ dev->link_changed = 0x00; dev->parent.type = RT_Device_Class_NetIf; /* register to RT-Thread device manager */ rt_device_register(&(dev->parent), name, RT_DEVICE_FLAG_RDWR); rt_sem_init(&(dev->tx_ack), name, 0, RT_IPC_FLAG_FIFO); /* set name */ netif->name[0] = name[0]; netif->name[1] = name[1]; /* set hw address to 6 */ netif->hwaddr_len = 6; /* maximum transfer unit */ netif->mtu = ETHERNET_MTU; /* get hardware MAC address */ rt_device_control(&(dev->parent), NIOCTL_GADDR, netif->hwaddr); /* set output */ netif->output = etharp_output; netif->linkoutput = ethernetif_linkoutput; /* if tcp thread has been started up, we add this netif to the system */ if (rt_thread_find("tcpip") != NULL) { struct ip_addr ipaddr, netmask, gw; #if !LWIP_DHCP IP4_ADDR(&ipaddr, RT_LWIP_IPADDR0, RT_LWIP_IPADDR1, RT_LWIP_IPADDR2, RT_LWIP_IPADDR3); IP4_ADDR(&gw, RT_LWIP_GWADDR0, RT_LWIP_GWADDR1, RT_LWIP_GWADDR2, RT_LWIP_GWADDR3); IP4_ADDR(&netmask, RT_LWIP_MSKADDR0, RT_LWIP_MSKADDR1, RT_LWIP_MSKADDR2, RT_LWIP_MSKADDR3); #else IP4_ADDR(&ipaddr, 0, 0, 0, 0); IP4_ADDR(&gw, 0, 0, 0, 0); IP4_ADDR(&netmask, 0, 0, 0, 0); #endif netifapi_netif_add(netif, &ipaddr, &netmask, &gw, dev, eth_netif_device_init, tcpip_input); } return RT_EOK; }
rt_err_t at24cxx_init(const char * device_name, const char * i2c_bus_name) { int i; struct rt_i2c_bus_device* i2c_bus_device; /* initialize mutex */ if (rt_mutex_init(&at24cxx_device.lock, device_name, RT_IPC_FLAG_FIFO) != RT_EOK) { rt_kprintf("init lock mutex failed\n"); return -RT_ENOSYS; } /* we got i2c bus */ i2c_bus_device = rt_i2c_bus_device_find(i2c_bus_name); if(i2c_bus_device == RT_NULL) { AT24CXX_TRACE("i2c device %s not found!\r\n", i2c_bus_device); return -RT_ENOSYS; } at24cxx_device.bus = i2c_bus_device; /* find match */ for(i=0;i<ARRAY_SIZE(at24cxx_attr_table);i++) { if(!rt_strcmp(at24cxx_attr_table[i].name, device_name)) { AT24CXX_TRACE("%s supported hardware:%s\r\n", __func__, device_name); at24cxx_device.attr = at24cxx_attr_table[i]; break; } } /* devices not supported */ if( i == ARRAY_SIZE(at24cxx_attr_table)) { return RT_ERROR; } at24cxx_device.geometry.bytes_per_sector = at24cxx_device.attr.page_size; at24cxx_device.geometry.block_size = at24cxx_device.attr.page_size; at24cxx_device.geometry.sector_count = at24cxx_device.attr.total_size/at24cxx_device.attr.page_size; /* register device */ at24cxx_device.parent.type = RT_Device_Class_Block; at24cxx_device.parent.init = init; at24cxx_device.parent.open = open; at24cxx_device.parent.close = close; at24cxx_device.parent.read = read; at24cxx_device.parent.write = write_page; at24cxx_device.parent.control = control; /* no private */ at24cxx_device.parent.user_data = RT_NULL; rt_device_register(&at24cxx_device.parent, device_name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE); return RT_EOK; }
/** * This function will define the susb host controller device, it will be register to the device * system. * * @return the error code, RT_EOK on successfully. */ void rt_hw_susb_init(void) { susb_hcd.parent.type = RT_Device_Class_USBHost; susb_hcd.parent.init = susb_init; susb_hcd.ops = &susb_ops; rt_device_register(&susb_hcd.parent, "susb", 0); }
/* ethernetif APIs */ Int32 eth_device_init(struct eth_device* dev, const char* name) { struct netif* netif; uip_ipaddr_t ipaddr; netif = (struct netif*) malloc (sizeof(struct netif)); if (netif == NULL) { printf("malloc netif failed\n"); return -RT_ERROR; } memset(netif, 0, sizeof(struct netif)); /* set netif */ dev->netif = netif; /* register to rt-thread device manager */ rt_device_register(&(dev->parent), name, RT_DEVICE_FLAG_RDWR); dev->parent.type = RT_Device_Class_NetIf; rt_sem_init(&(dev->tx_ack), name, 0, RT_IPC_FLAG_FIFO); /* set name */ netif->name[0] = name[0]; netif->name[1] = name[1]; /* set hw address to 6 */ netif->hwaddr_len = 6; /* maximum transfer unit */ netif->mtu = ETHERNET_MTU; /* broadcast capability */ netif->flags = NETIF_FLAG_BROADCAST; #if LWIP_IGMP /* igmp support */ netif->flags |= NETIF_FLAG_IGMP; #endif /* get hardware address */ rt_device_control(&(dev->parent), NIOCTL_GADDR, netif->hwaddr); /* set output */ netif->output = ethernetif_output; netif->linkoutput = ethernetif_linkoutput; /* add netif to lwip */ if (netif_add(netif, IP_ADDR_ANY, IP_ADDR_BROADCAST, IP_ADDR_ANY, dev, eth_init, eth_input) == NULL) { /* failed, unregister device and free netif */ rt_device_unregister(&(dev->parent)); rt_free(netif); return -RT_ERROR; } netif_set_default(netif); return RT_EOK; }
/***************************************************************************//** * @brief * Initialize OLED device * * @details * * @note * ******************************************************************************/ void bsp_hw_oled_init(void) { do { #if OLED_DEVICE_INTERFACE == INTERFACE_4WIRE_SPI /* Find SPI device */ spi_dev = rt_device_find(OLED_USING_DEVICE_NAME); if (spi_dev == RT_NULL) { oled_debug("OLED: Can't find device %s!\n", OLED_USING_DEVICE_NAME); break; } oled_debug("OLED: Find device %s\n", OLED_USING_DEVICE_NAME); #endif /* Register OLED device */ oled_device.type = RT_Device_Class_Graphic; oled_device.rx_indicate = RT_NULL; oled_device.tx_complete = RT_NULL; oled_device.init = board_oled_init; oled_device.open = miniStm32_oled_open; oled_device.close = miniStm32_oled_close; oled_device.read = RT_NULL; oled_device.write = RT_NULL; oled_device.control = miniStm32_oled_control; #if defined(RT_USING_GUIENGINE) oled_device.user_data = (void *)&oled_ops; #else oled_device.user_data = RT_NULL; #endif if (rt_device_register( &oled_device, OLED_DEVICE_NAME, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE //RT_DEVICE_FLAG_DMA_TX ) != RT_EOK) { break; } #if defined(RT_USING_GUIENGINE) /* Set as rtgui graphic driver */ if (rtgui_graphic_set_device(&oled_device) != RT_EOK) { break; } #endif oled_debug("OLED: H/W init OK!\n"); return; } while(0); oled_debug("OLED err: H/W init failed!\n"); }
int rt_hw_hp_rtc_init(void) { rt_err_t ret = RT_EOK; ret = rt_device_register(&device, "rtc", RT_DEVICE_FLAG_RDWR); if(ret != RT_EOK) { return ret; } rt_device_open(&device, RT_DEVICE_OFLAG_RDWR); return RT_EOK; }
/*********************************************************** * 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 ); }