rt_int32_t stm32f4xx_sdio_init(void) { struct rt_mmcsd_host *host; NVIC_InitTypeDef NVIC_InitStructure; host = mmcsd_alloc_host(); if (!host) { return -RT_ERROR; } stm32f4_sdio = rt_malloc(sizeof(struct stm32f4xx_sdio)); if (!stm32f4_sdio) { rt_kprintf("alloc stm32f4_sdio failed\n"); goto err; } rt_memset(stm32f4_sdio, 0, sizeof(struct stm32f4xx_sdio)); host->ops = &ops; host->freq_min = 375000; host->freq_max = 25000000; host->valid_ocr = VDD_32_33 | VDD_33_34; host->flags = MMCSD_BUSWIDTH_4 | MMCSD_MUTBLKWRITE; host->max_seg_size = 65535; host->max_dma_segs = 2; host->max_blk_size = 512; host->max_blk_count = 4096; stm32f4_sdio->host = host; SDIO_StructInit(&SDIO_InitStructure); /* SDIO Peripheral Low Level Init */ SD_LowLevel_Init(); NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); host->private_data = stm32f4_sdio; mmcsd_change(host); return 0; err: mmcsd_free_host(host); return -RT_ENOMEM; }
int lzo(char *srcfile, char *destfile) { int result; int fd; struct stat s; lzo_bytep in; lzo_bytep out; lzo_uint in_len, out_len; rt_memset(&s, 0, sizeof(struct stat)); stat(srcfile, &s); in_len = s.st_size; in = rt_malloc(in_len); if (in == RT_NULL) return -1; out = rt_malloc(LZO1X_WORST(in_len)); if (out == RT_NULL) return -1; fd = open(srcfile, O_RDONLY, 0); if(fd < 0) { result = -1; goto _exit; } read(fd, in, in_len); close(fd); result = lzo1x_1_compress(in, in_len, out, &out_len, wrkmem); if(result != LZO_E_OK) { rt_kprintf("internal error - compression failed: \nerr_code:(%d) %s, %s.\n", result, parse_lzo_error_code(result), "Please use the binary access"); goto _exit; } fd = open(destfile, O_WRONLY | O_BINARY | O_CREAT, 0); if(fd < 0) { result = -1; goto _exit; } write(fd, &in_len, sizeof(lzo_uint)); /* source file len */ write(fd, out, out_len); close(fd); rt_kprintf("compress lzo ok!\n"); result = 0; _exit: rt_free(in); rt_free(out); return result; }
int pthread_mutex_destroy(pthread_mutex_t *mutex) { if (!mutex || mutex->attr == -1) return EINVAL; /* it's busy */ if (mutex->lock.owner != RT_NULL) return EBUSY; rt_memset(mutex, 0, sizeof(pthread_mutex_t)); mutex->attr = -1; return 0; }
void calculate_array(uint8_t num) { uint16_t k = 0; uint16_t *p ; float sum = 0.0f; if(num >= scheme_max ) num = scheme_max - 1; rt_memset(array_buf, 0, array_num*2);//将数组清0 p = array_buf; linear_offset( p , 0, program_data[num].percent[0], program_data[num].t[0]*2); p += program_data[num].t[0]*2; for(k = 0; k < 15; k++)//0-14 { linear_offset( p , program_data[num].percent[k] , program_data[num].percent[k+1], (program_data[num].t[k+1] - program_data[num].t[k])*2); p += (program_data[num].t[k+1] - program_data[num].t[k])*2;//50us间隔 } for(k = 0; k <array_num; k++ ) { pwm_struct[num].p_array[k] = (float)array_buf[k]/1000; } pwm_struct[num].p_array[499] = 0.0f;//数组最后一字节为0; for(k = 499; k > 0; k--) { if(pwm_struct[num].p_array[k] > 0.0f) { pwm_struct[num].positive_pulse = k+1; break; } // pwm_struct[num].positive_pulse = 500; } // pwm_struct[num].negative_pulse = 20; for(k = 0; k < 500; k++) { sum += pwm_struct[num].p_array[k] * program_data[num].current_max ;//usSRegHoldBuf[current_peak]; } pwm_struct[num].negative_pulse = (uint16_t)(sum/12.5f) + 20; usSRegHoldBuf[frq_max] = 200000/(pwm_struct[num].negative_pulse + pwm_struct[num].positive_pulse); if(usSRegHoldBuf[frq_max] >1000) { usSRegHoldBuf[frq_max] = 1000; } pwm_struct[num].negative_pulse = 200000/usSRegHoldBuf[frq_max] - pwm_struct[num].positive_pulse; pwm_struct[num].mode = program_data[num].feedback_mode; }
rt_int32_t sdio_io_send_op_cond(struct rt_mmcsd_host *host, rt_uint32_t ocr, rt_uint32_t *cmd5_resp) { struct rt_mmcsd_cmd cmd; rt_int32_t i, err = 0; RT_ASSERT(host != RT_NULL); rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); cmd.cmd_code = SD_IO_SEND_OP_COND; cmd.arg = ocr; cmd.flags = RESP_SPI_R4 | RESP_R4 | CMD_BCR; for (i = 100; i; i--) { err = mmcsd_send_cmd(host, &cmd, 0); if (err) break; /* if we're just probing, do a single pass */ if (ocr == 0) break; /* otherwise wait until reset completes */ if (controller_is_spi(host)) { /* * Both R1_SPI_IDLE and MMC_CARD_BUSY indicate * an initialized card under SPI, but some cards * (Marvell's) only behave when looking at this * one. */ if (cmd.resp[1] & CARD_BUSY) break; } else { if (cmd.resp[0] & CARD_BUSY) break; } err = -RT_ETIMEOUT; mmcsd_delay_ms(10); } if (cmd5_resp) *cmd5_resp = cmd.resp[controller_is_spi(host) ? 1 : 0]; return err; }
static void finsh_wait_auth(void) { char ch; rt_bool_t input_finish = RT_FALSE; char password[FINSH_PASSWORD_MAX] = { 0 }; rt_size_t cur_pos = 0; /* password not set */ if (rt_strlen(finsh_get_password()) == 0) return; while (1) { rt_kprintf("Password for login: "******"*"); password[cur_pos++] = ch; } else if (ch == '\b' && cur_pos > 0) { /* backspace */ password[cur_pos] = '\0'; cur_pos--; rt_kprintf("\b \b"); } else if (ch == '\r' || ch == '\n') { rt_kprintf("\n"); input_finish = RT_TRUE; break; } } } if (!rt_strncmp(shell->password, password, FINSH_PASSWORD_MAX)) return; else { /* authentication failed, delay 2S for retry */ rt_thread_delay(2 * RT_TICK_PER_SECOND); rt_kprintf("Sorry, try again.\n"); cur_pos = 0; input_finish = RT_FALSE; rt_memset(password, '\0', FINSH_PASSWORD_MAX); } } }
static rt_err_t _rt_thread_init(struct rt_thread *thread, const char *name, void (*entry)(void *parameter), void *parameter, void *stack_start, rt_uint32_t stack_size, rt_uint8_t priority, rt_uint32_t tick) { /* init thread list */ rt_list_init(&(thread->tlist)); thread->entry = (void *)entry; thread->parameter = parameter; /* stack init */ thread->stack_addr = stack_start; thread->stack_size = (rt_uint16_t)stack_size; /* init thread stack */ rt_memset(thread->stack_addr, '#', thread->stack_size); thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter, (void *)((char *)thread->stack_addr + thread->stack_size - 4), (void *)rt_thread_exit); /* priority init */ RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX); thread->init_priority = priority; thread->current_priority = priority; /* tick init */ thread->init_tick = tick; thread->remaining_tick = tick; /* error and flags */ thread->error = RT_EOK; thread->stat = RT_THREAD_INIT; /* initialize cleanup function and user data */ thread->cleanup = 0; thread->user_data = 0; /* init thread timer */ rt_timer_init(&(thread->thread_timer), thread->name, rt_thread_timeout, thread, 0, RT_TIMER_FLAG_ONE_SHOT); return RT_EOK; }
void tcp_senddata(const char* url, int port, int length) { struct hostent *host; int sock, err, result, timeout, index; struct sockaddr_in server_addr; rt_uint8_t *buffer_ptr; /* 通过函数入口参数url获得host地址(如果是域名,会做域名解析) */ host = gethostbyname(url); /* 创建一个socket,类型是SOCKET_STREAM,TCP类型 */ if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) { /* 创建socket失败 */ rt_kprintf("Socket error\n"); return; } /* 神奇内存 */ buffer_ptr = rt_malloc(length); /* 构造发生数据 */ for (index = 0; index < length; index ++) buffer_ptr[index] = index & 0xff; timeout = 100; /* 设置发送超时时间100ms */ lwip_setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)); /* 初始化预连接的服务端地址 */ server_addr.sin_family = AF_INET; server_addr.sin_port = htons(port); server_addr.sin_addr = *((struct in_addr *)host->h_addr); rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero)); /* 连接到服务端 */ err = connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)); rt_kprintf("TCP thread connect error code: %d\n", err); while(1) { /* 发送数据到sock连接 */ result = send(sock, buffer_ptr, length, MSG_DONTWAIT); if(result == -1) //数据发送错误处理 { rt_kprintf("TCP thread send error: %d\n", result); lwip_close(sock); //关闭连接,重新创建连接 rt_thread_delay(10); if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) rt_kprintf("TCP Socket error:%d\n",sock); err = connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)); rt_kprintf("TCP thread connect error code: %d\n", err); } } }
void nand_erase(int start, int end) { int page; flag=1; rt_memset(buf, 0, PAGE_DATA_SIZE); rt_memset(spare, 0, 16); for(; start <= end; start ++) { page = start * 32; nand_mtd_erase_block(RT_NULL, start); nand_mtd_read(RT_NULL, page, buf, PAGE_DATA_SIZE, spare, 16); if (spare[0] != 0xFF) { rt_kprintf("block %d is bad, mark it bad\n", start); if (spare[4] == 0xFF) { spare[4] = 0x00; nand_mtd_write(RT_NULL, page, RT_NULL, 0, spare, 16); } } } }
/* Miscellaneous Functions */ DRESULT disk_ioctl(BYTE drv, BYTE ctrl, void *buff) { rt_device_t device = disk[drv]; if (device == RT_NULL) return RES_ERROR; if (ctrl == GET_SECTOR_COUNT) { struct rt_device_blk_geometry geometry; rt_memset(&geometry, 0, sizeof(geometry)); rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry); *(DWORD *)buff = geometry.sector_count; if (geometry.sector_count == 0) return RES_ERROR; } else if (ctrl == GET_SECTOR_SIZE) { struct rt_device_blk_geometry geometry; rt_memset(&geometry, 0, sizeof(geometry)); rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry); *(WORD *)buff = geometry.bytes_per_sector; } else if (ctrl == GET_BLOCK_SIZE) /* Get erase block size in unit of sectors (DWORD) */ { struct rt_device_blk_geometry geometry; rt_memset(&geometry, 0, sizeof(geometry)); rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry); *(DWORD *)buff = geometry.block_size/geometry.bytes_per_sector; } return RES_OK; }
static void _rtgui_listctrl_get_scrollbar_rect(struct rtgui_listctrl* ctrl, rtgui_rect_t* rect) { rtgui_widget_get_rect(RTGUI_WIDGET(ctrl), rect); if (ctrl->items_count > rtgui_rect_height(*rect)/rtgui_theme_get_selected_height()) { rect->x1 = rect->x2 - 8; } else { /* no scrollbar */ rt_memset(rect, 0, sizeof(rtgui_rect_t)); } }
static void lua_msh(int argc, char **argv) { rt_thread_t lua_thread; const char* device_name = finsh_get_device(); rt_device_t device = rt_device_find(device_name); if (device == RT_NULL) { rt_kprintf("%s not find\n", device_name); return; } dev4lua.device = device; /*prepare parameters*/ struct para *parameters = rt_malloc(sizeof(struct para)); if ( parameters == NULL ){ rt_kprintf("malloc failed at file: %s,line: %d", __FILE__, __LINE__); return; } //parameters->argc = 2; parameters->argc = argc; char **arg = parameters->argv; arg[0] = "lua"; if (argc > 1){ rt_size_t len = strnlen(argv[1], 50); arg[1] = rt_malloc(len + 1); if (arg[1] == NULL ){ rt_kprintf("malloc failed at file: %s,line: %d", __FILE__, __LINE__); return; } rt_memset(arg[1], 0, len+1); strncpy(arg[1], argv[1], len); }else{ arg[1] = NULL; } arg[2] = NULL; /* Run lua interpreter in separate thread */ lua_thread = rt_thread_create("lua_msh", (void (*)(void *))(finsh_lua), (void*)parameters, 10240, rt_thread_self()->current_priority + 1, 20); if (lua_thread != RT_NULL) { rt_thread_startup(lua_thread); } return; }
/** * @ingroup Fd * * This function will put the file descriptor. */ void fd_put(struct dfs_fd *fd) { RT_ASSERT(fd != RT_NULL); dfs_lock(); fd->ref_count --; /* clear this fd entry */ if (fd->ref_count == 0) { rt_memset(fd, 0, sizeof(struct dfs_fd)); } dfs_unlock(); };
/** * This function will contiguously allocate enough space for count objects * that are size bytes of memory each and returns a pointer to the allocated * memory. * * The allocated memory is filled with bytes of value zero. * * @param count number of objects to allocate * @param size size of the objects to allocate * * @return pointer to allocated memory / NULL pointer if there is an error */ void *rt_calloc(rt_size_t count, rt_size_t size) { void *p; RT_DEBUG_NOT_IN_INTERRUPT; /* allocate 'count' objects of size 'size' */ p = rt_malloc(count * size); /* zero the memory */ if (p) rt_memset(p, 0, count * size); return p; }
void rtgui_touch_hw_init(void) { rt_err_t result = RT_FALSE; rt_device_t device = RT_NULL; struct rt_device_graphic_info info; touch = (struct rtgui_touch_device *)rt_malloc(sizeof(struct rtgui_touch_device)); if (touch == RT_NULL) return; /* no memory yet */ /* clear device structure */ rt_memset(&(touch->parent), 0, sizeof(struct rt_device)); touch->calibrating = RT_FALSE; touch->min_x = X_MIN; touch->max_x = X_MAX; touch->min_y = Y_MIN; touch->max_y = Y_MAX; touch->eventpost_func = RT_NULL; touch->eventpost_param = RT_NULL; /* init device structure */ touch->parent.type = RT_Device_Class_Unknown; touch->parent.init = rtgui_touch_init; touch->parent.control = rtgui_touch_control; touch->parent.user_data = RT_NULL; device = rt_device_find("lcd"); if (device == RT_NULL) return; /* no this device */ /* get graphic device info */ result = rt_device_control(device, RTGRAPHIC_CTRL_GET_INFO, &info); if (result != RT_EOK) { /* get device information failed */ return; } touch->width = info.width; touch->height = info.height; /* create 1/8 second timer */ touch->poll_timer = rt_timer_create("touch", touch_timer_fire, RT_NULL, RT_TICK_PER_SECOND/8, RT_TIMER_FLAG_PERIODIC); /* register touch device to RT-Thread */ rt_device_register(&(touch->parent), "touch", RT_DEVICE_FLAG_RDWR); }
void uffs_setup_storage(struct uffs_StorageAttrSt *attr, struct rt_mtd_nand_device *nand) { rt_memset(attr, 0, sizeof(struct uffs_StorageAttrSt)); // attr->total_blocks = nand->end_block - nand->start_block + 1;/* no use */ attr->page_data_size = nand->page_size; /* page data size */ attr->pages_per_block = nand->pages_per_block; /* pages per block */ attr->spare_size = nand->oob_size; /* page spare size */ attr->ecc_opt = RT_CONFIG_UFFS_ECC_MODE; /* ecc option */ attr->ecc_size = 0; /* ecc size is 0 , the uffs will calculate the ecc size*/ attr->block_status_offs = attr->ecc_size; /* indicate block bad or good, offset in spare */ attr->layout_opt = RT_CONFIG_UFFS_LAYOUT; /* let UFFS do the spare layout */ }
/** * this function will close a file descriptor. * * @param fd the file descriptor to be closed. * * @return 0 on successful, -1 on failed. */ int dfs_file_close(struct dfs_fd* fd) { int result = 0; if (fd != RT_NULL && fd->fs->ops->close != RT_NULL) result = fd->fs->ops->close(fd); /* close fd error, return */ if ( result < 0 ) return result; rt_free(fd->path); rt_memset(fd, 0, sizeof(struct dfs_fd)); return result; }
rtgui_xml_t* rtgui_xml_create(rt_size_t buffer_size, rtgui_xml_event_handler_t handler, void* user) { rtgui_xml_t* xml = (rtgui_xml_t*) rtgui_malloc(sizeof(struct rtgui_xml)); rt_memset(xml, 0, sizeof(rtgui_xml_t)); xml->event_handler = handler; xml->user = user; /* create buffer */ xml->buffer_size = buffer_size; xml->buffer = (char*)rtgui_malloc(xml->buffer_size); return xml; }
int32_t _vsm_get_local_status(vam_stastatus_t *local) { t_nmea_rmc recvGPS; if(recvGPS.isTrue){ nmea_get(&recvGPS, 1); local->pos.latitude = recvGPS.latitude; local->pos.longitude = recvGPS.longitude ; local->speed = recvGPS.speed ; } else{ rt_memset(local,0,sizeof(local)); } return RT_EOK ; }
rt_err_t mmcsd_send_app_op_cond(struct rt_mmcsd_host *host, rt_uint32_t ocr, rt_uint32_t *rocr) { struct rt_mmcsd_cmd cmd; rt_uint32_t i; rt_err_t err = RT_EOK; rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); cmd.cmd_code = SD_APP_OP_COND; if (controller_is_spi(host)) cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */ else cmd.arg = ocr; cmd.flags = RESP_SPI_R1 | RESP_R3 | CMD_BCR; for (i = 100; i; i--) { err = mmcsd_send_app_cmd(host, RT_NULL, &cmd, 3); if (err) break; /* if we're just probing, do a single pass */ if (ocr == 0) break; /* otherwise wait until reset completes */ if (controller_is_spi(host)) { if (!(cmd.resp[0] & R1_SPI_IDLE)) break; } else { if (cmd.resp[0] & CARD_BUSY) break; } err = -RT_ETIMEOUT; mmcsd_delay_ms(10); //delay 10ms } if (rocr && !controller_is_spi(host)) *rocr = cmd.resp[0]; return err; }
void rti_free_hook(void *ptr) { rt_uint32_t index; struct rti_memtrace_item *item; /* get hash item index */ index = ((rt_uint32_t)ptr) % MEMTRACE_HASH_SIZE; if (item_hash[index] != RT_NULL) { item = item_hash[index]; if (item->mb_ptr == ptr) { /* delete item from list */ item_hash[index] = item->next; } else { /* find ptr in list */ while (item->next != RT_NULL && item->next->mb_ptr != ptr) item = item->next; /* delete item from list */ if (item->next != RT_NULL) { struct rti_memtrace_item *i; i = item->next; item->next = item->next->next; item = i; } else { /* not found */ return; } } /* reduce allocated size */ mem_info.allocated_size -= item->mb_len; /* clear item */ rt_memset(item, 0, sizeof(struct rti_memtrace_item)); /* add item to the free list */ item->next = item_free; item_free = item; } }
void radio_rtgui_init(void) { rtgui_rect_t rect; // rtgui_color_t c=0xff; rtgui_system_server_init(); /* register dock panel */ rect.x1 = 0; rect.y1 = 0; rect.x2 = 320; rect.y2 = 25; rtgui_panel_register("info", &rect); rtgui_panel_set_nofocused("info"); /* register main panel */ rect.x1 = 0; rect.y1 = 25; rect.x2 = 320; rect.y2 = 240; rtgui_panel_register("main", &rect); rtgui_panel_set_default_focused("main"); _rtgui_lcd_driver.name = "lcd"; _rtgui_lcd_driver.byte_per_pixel = 2; _rtgui_lcd_driver.width = 320; _rtgui_lcd_driver.height = 240; _rtgui_lcd_driver.draw_hline = lcd_draw_hline; _rtgui_lcd_driver.draw_raw_hline = lcd_draw_raw_hline; _rtgui_lcd_driver.draw_vline = lcd_draw_vline; _rtgui_lcd_driver.get_pixel = lcd_get_pixel; _rtgui_lcd_driver.set_pixel = lcd_set_pixel; _rtgui_lcd_driver.screen_update = lcd_update; _rtgui_lcd_driver.get_framebuffer = lcd_get_framebuffer; sep4020_lcd_init(); rt_memset((char*)pVideoBuffer,0xff,320*240*2); // rt_memcpy((char*)pVideoBuffer,pic,320*240*2); //TESTING IMAGE /* add lcd driver into graphic driver */ rtgui_graphic_driver_add(&_rtgui_lcd_driver); }
static void lpccan_init_alut_ram(void) { //Reset CANAF value LPC_CANAF->AFMR = 0x01; //clear ALUT RAM rt_memset((void *)LPC_CANAF_RAM->mask, 0, 2048); LPC_CANAF->SFF_sa = 0; LPC_CANAF->SFF_GRP_sa = 0; LPC_CANAF->EFF_sa = 0; LPC_CANAF->EFF_GRP_sa = 0; LPC_CANAF->ENDofTable = 0; LPC_CANAF->AFMR = 0x00; // Set AF Mode CAN_SetAFMode(CAN_NORMAL); }
rt_err_t rt_spi_release(struct rt_spi_device *device) { rt_err_t result; struct rt_spi_message message; RT_ASSERT(device != RT_NULL); RT_ASSERT(device->bus != RT_NULL); rt_memset(&message, 0, sizeof(message)); message.cs_release = 1; result = device->bus->ops->xfer(device, &message); return result; }
void *rt_calloc(rt_size_t count, rt_size_t size) { void *ptr; rt_size_t total_size; total_size = count * size; ptr = rt_malloc(total_size); if (ptr != RT_NULL) { /* clean memory */ rt_memset(ptr, 0, total_size); } return ptr; }
/** * This function will initialize hardware interrupt */ void rt_hw_interrupt_init() { rt_int32_t index; rt_memset(irq_handle_table, 0x00, sizeof(irq_handle_table)); for (index = 0; index < JZ47XX_MAX_INTR; index ++) { irq_handle_table[index].handler = (rt_isr_handler_t)rt_hw_interrupt_handler; } /* init interrupt nest, and context in thread sp */ rt_interrupt_nest = 0; rt_interrupt_from_thread = 0; rt_interrupt_to_thread = 0; rt_thread_switch_interrupt_flag = 0; }
rt_int32_t mmcsd_spi_read_ocr(struct rt_mmcsd_host *host, rt_int32_t high_capacity, rt_uint32_t *ocr) { struct rt_mmcsd_cmd cmd; rt_int32_t err; rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); cmd.cmd_code = SPI_READ_OCR; cmd.arg = high_capacity ? (1 << 30) : 0; cmd.flags = RESP_SPI_R3; err = mmcsd_send_cmd(host, &cmd, 0); *ocr = cmd.resp[1]; return err; }
rt_int32_t mmcsd_spi_use_crc(struct rt_mmcsd_host *host, rt_int32_t use_crc) { struct rt_mmcsd_cmd cmd; rt_int32_t err; rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); cmd.cmd_code = SPI_CRC_ON_OFF; cmd.flags = RESP_SPI_R1; cmd.arg = use_crc; err = mmcsd_send_cmd(host, &cmd, 0); if (!err) host->spi_use_crc = use_crc; return err; }
static void _rtgui_form_constructor(struct rtgui_form *form) { rt_memset(form, 0, sizeof(*form)); /* form中元素已全部清零, 下面只需要对初值不为零的进行初始化 */ /* set default widget rect and set event handler */ rtgui_widget_set_event_handler(RTGUI_WIDGET(form),rtgui_form_event_handler); RTGUI_WIDGET(form)->flag |= RTGUI_WIDGET_FLAG_FOCUSABLE; form->form_rect.x1 = ~0; RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(form)) = white; RTGUI_WIDGET_TEXTALIGN(RTGUI_WIDGET(form)) = RTGUI_ALIGN_CENTER_VERTICAL; return; }
/** * Create a UDP PCB. * * @return The UDP PCB which was created. NULL if the PCB data structure * could not be allocated. * * @see udp_remove() */ struct udp_pcb * udp_new(void) { struct udp_pcb *pcb; pcb = memp_malloc(MEMP_UDP_PCB); /* could allocate UDP PCB? */ if (pcb != NULL) { /* UDP Lite: by initializing to all zeroes, chksum_len is set to 0 * which means checksum is generated over the whole datagram per default * (recommended as default by RFC 3828). */ /* initialize PCB to all zeroes */ rt_memset(pcb, 0, sizeof(struct udp_pcb)); pcb->ttl = UDP_TTL; } return pcb; }