自学教程：C++ uart_printf函数代码示例

/** * Outputs link status on serial console */static void link_status(struct netif *arg){/*{{{*/#if LWIP_IPV6    TimerHandle_t poll_timer;#endif    uart_printf("IP address of interface %c%c set to %hd.%hd.%hd.%hd/n",            arg->name[0], arg->name[1],            ip4_addr1_16(&arg->ip_addr),            ip4_addr2_16(&arg->ip_addr),            ip4_addr3_16(&arg->ip_addr),            ip4_addr4_16(&arg->ip_addr));    uart_printf("Netmask of interface %c%c set to %hd.%hd.%hd.%hd/n",            arg->name[0], arg->name[1],            ip4_addr1_16(&arg->netmask),            ip4_addr2_16(&arg->netmask),            ip4_addr3_16(&arg->netmask),            ip4_addr4_16(&arg->netmask));    uart_printf("Gateway of interface %c%c set to %hd.%hd.%hd.%hd/n",            arg->name[0], arg->name[1],            ip4_addr1_16(&arg->gw),            ip4_addr2_16(&arg->gw),            ip4_addr3_16(&arg->gw),            ip4_addr4_16(&arg->gw));    uart_printf("Hostname of interface %c%c set to %s/n",            arg->name[0], arg->name[1], arg->hostname);#if LWIP_IPV6    poll_timer = xTimerCreate        ( "poll_ipv6_addr",          1000 / portTICK_PERIOD_MS,          pdTRUE,          arg,          poll_ip6_addr);    xTimerStart(poll_timer, 0);#endif}/*}}}*/

/** * Print DIMM configuration */void spd_print_dimm_presence(void){	unsigned char i, reading;	/* walk through all dimms */	for (i = 0; i < SDRAM_MAX_DIMMS; i++)	{		uart_printf("DDR3 DIMM %d: ", i + 1);		/* if payload power is not active - read out SPD EEPROM's */		if (!signal_read(&sig_payload_power))		{			/* try to read DIMM SPD register */			if (spd_read_register(i, SDRAM_SPD_REVISION, &reading) == E_OK)			{				/* get memory size */				spd_get_memory_values(i);			}		}		/* if memory size value not zero */		if (ddr_modules[i].populated != 0)		{			uart_printf("%d MB ", ddr_modules[i].value);			uart_printf(" Type: %d/n", ddr_modules[i].voltage);		}		else		{			uart_printf("not populated/n");		}	}}

int uart_close(uart_socket_t *u){	if(!u){		uart_printf("uart_close(): u is NULL!/r/n");		return -1;	}	/* Close uart socket */	if(lwip_close(u->fd) == -1){		uart_printf("%s(): close uart failed!", __func__);	}	/* Delete uart_action task */	u->fd = -1;	RtlUpSema(&u->action_sema);	RtlMsleepOS(20);	/* Free uart related semaphore */	RtlFreeSema(&u->action_sema);	RtlFreeSema(&u->tx_sema);	RtlFreeSema(&u->dma_tx_sema);		/* Free serial */	serial_free(&u->sobj);		RtlMfree((u8 *)u, sizeof(uart_socket_t));	return 0;}

/** * send a message to the ShMM * */void bmc_make_request(unsigned char netfn, unsigned char cmd, unsigned char *data, unsigned char datalen){	ipmbMSG_t *request;	if (!(request = msg_malloc()))	{		uart_printf("ERR: %s: Not enough memory for request msg./n", __func__);		return;	}	request->rsSA = 0x20;	request->rqSA = global_data.bmc_ipmb_addr;	request->rsLUN = event_receiver_lun;	request->rqSeq = get_seq_counter();	request->rqLUN = 0;	request->orig_channel = MSG_CHANNEL_BMC;	request->dest_channel = MSG_CHANNEL_IPMB0;	request->cmd = cmd;	request->netFN = netfn;	request->data_len = datalen;	memcpy(request->data, data, datalen);	if (xQueueSend(msg_hub_rx_queue, &request, QUEUE_BLOCK_10) != pdPASS)	{		uart_printf("ERR: %s: msg_hub_rx_queue full/n", __func__);		mon_queues |= MON_QUEUE_MSG_HUB_RX;		msg_free(request);	}}

/** @brief Function handle qdec events. */static void qdec_event_handler(nrf_drv_qdec_event_t event) {    if (event.type == NRF_QDEC_EVENT_REPORTRDY) {        m_accdblread = event.data.report.accdbl;        m_accread = event.data.report.acc;        if (m_accdblread==0) {        	m_value += m_accread;	}        if (m_value<0) {		m_value = 0;	} else if (m_value>100) {		m_value=100;	}        if (m_value != m_last_value) {        	uart_printf("report dbl=%u acc=%d",m_accdblread,m_accread);                if (m_accread>0) {			uart_printf("/x1B[1;32m"); // GREEN                } else {			uart_printf("/x1B[1;31m"); // RED		}        	uart_printf(" val=%d/n/r",m_value);		m_last_value = m_value;		uart_printf("/x1B[0m"); // DEFAULT color	}    }}

void PVDTset(){	RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);	PWR_PVDLevelConfig(PWR_PVDLevel_2V8);	//PWR_PVDLevelConfig(PWR_PVDLevel_2V6);	PWR_PVDCmd(ENABLE);	while(1)	{				if(PWR_GetFlagStatus(PWR_FLAG_PVDO))		{			uart_printf("VDD<2.8V=PWR->CSR/r/n");			break;		}	}	uart_printf("PWR->CSR=0x%x/r/n",PWR->CSR);		while(1)	{		if(PWR_GetFlagStatus(PWR_FLAG_PVDO)==0)		{			uart_printf("VDD>2.8V=PWR->CSR/r/n");			break;		}	}}

static void cli_command_set(char *args){	char *token;	cli_strip_spaces(&args);	token = args;	if(cli_strip_word(&args)) {		uart_printf("1 Incorrect format, set prompt [/"text/"]/n");		return;	}	if(strcmp(token, "prompt") == 0) {		++args;		cli_strip_spaces(&args);		token = args;		if(cli_strip_quotes(&args)) {			uart_printf("2 Incorrect format, set prompt [/"text/"]/n");			return;		}		++token;		cli_set_prompt(token);	}	else {		uart_printf("3 Incorrect format, set prompt [/"text/"]/n");		return;	}}

// Print stat to UARTvoid stat_dump(void){    unsigned i, ts = rtc_current();    uart_printf("%u %u" UART_EOL, g_stat_group, ts);    for (i = 0; i < MAX_GR_ROLES; ++i)    {        struct stat_buffer const* b = &g_stat_buff[i];        struct stat_entry const* s = &b->e[b->ei];        uart_printf("%u %u %u %u %u ",             s->epoch,            s->reports_total,            s->reports_received,            s->first_report_ts,            s->last_report_ts        );        struct report_packet const* r = &s->last_report;        uart_printf("%u %u %u %u %u %u" UART_EOL,             r->sn,            r->ts,            r->bt_pressed,            r->bt_pressed_ts,            r->bt_released_ts,            r->vcc_mv        );    }    uart_tx_flush();}

//Magic.void uart_list_devs(void){   	const char* directory = "/dev/";   	DIR* dir = opendir(directory);   	if (dir){		struct dirent* de = 0;		while ((de = readdir(dir)) != 0){			if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)				continue;					int pid = -1;			int res = sscanf(de->d_name, "%d", &pid);			char* instr = strstr(de->d_name, "tty");			if (instr){				uart_printf(CLR_CANCEL,0,"Reading dir: %s /n",de->d_name);				char filename[256] = {0};				sprintf(filename, "%s/%s", directory, de->d_name);				int fd = open (filename, O_RDWR | O_NONBLOCK);				if (fd != -1){					int serinfo;					if (ioctl (fd, TIOCMGET, &serinfo) != -1){						uart_printf(CLR_CANCEL,0,"Must be a serial device./n");					}					close(fd);				}			}		}		closedir(dir); 	}}

// transmit to the host new dcd/dsr, it's value based on button.void cdc_serial_state_task(void){   cdc_serial_state_t newState;   static cdc_serial_state_t lastState;   memset(&newState, 0x00, sizeof(newState));   newState.bRxCarrier = BUTTON_PRESSED();   newState.bTxCarrier = newState.bRxCarrier;   if (memcmp(&newState, &lastState, sizeof(newState)) != 0)   {      uart_printf("/r/nNew button state being sent: ");      //change in state, send it.      if (usb_cdc_serial_state(newState))      {         //state was sent ok, save it in memory so we don't resend it.         memcpy(&lastState, &newState, sizeof(lastState));         uart_printf("OK");      }      else      {         uart_printf("FAIL");      }      uart_printf("/r/n");   }}

void ftl_trim(UINT32 const lba, UINT32 const num_sectors){	ASSERT(num_sectors > 0);	uart_printf("Num sectors: %u", num_sectors);	uart_printf("SATA_WBUF_PTR: %u", GETREG(SATA_WBUF_PTR));	uart_printf("g_ftl_write_buf_id: %u", g_ftl_write_buf_id);	UINT32 next_write_buf_id = (g_ftl_write_buf_id + num_sectors) % NUM_WR_BUFFERS;	for (UINT32 i=0;i<num_sectors;i++)	{		for (UINT32 j=0;j<512/8;j=j+2)		{			UINT32 address = read_dram_32(WR_BUF_PTR(g_ftl_write_buf_id)+j*sizeof(UINT32));			UINT32 reg2 = read_dram_32(WR_BUF_PTR(g_ftl_write_buf_id)+(j+1)*sizeof(UINT32));			UINT32 count = reg2 & 0xFFFF0000; // Count stored in the first four words.			// If count is zero. We continue, but also, if address is 48bit.			// We shouldn't get these unless it is an error.			if (count == 0 || (reg2 & 0x0000FFFF) > 0) //				continue;//			uart_print_hex(address);//			uart_print_hex(count);		}		g_ftl_write_buf_id = (g_ftl_write_buf_id + 1) % NUM_WR_BUFFERS;	}	SETREG(BM_STACK_WRSET, next_write_buf_id);	// change bm_read_limit	SETREG(BM_STACK_RESET, 0x02);				// change bm_read_limi}

//Interface between fifo and uart_writevoid uart_write_start(uart_s* uart){		if (!(uart->txfifo)){		uart_printf(CLR_CANCEL,0,"Uart has no txfifo./n");		return;	}		//Use a buffer to flatten the fifo.	uint8_t* buff = (uint8_t*)malloc(uart->txfifo->size);	//Empty the fifo	int i = 0;	while(fifo_get(uart->txfifo,&buff[i])){		i++;	};		uart_printf(CLR_CANCEL,0,"uart_write_start (len %i): /n",i );	#if(UARTDEBUG) 	printf("Written:/n");	printf_hex_block(buff,i,1);	printf("/n");	#endif		//Write em out:	uart_write(uart,buff,i);			//free buffer.	free(buff);}

static void cli_command_switch(char *args){	char *token;	int value;	cli_strip_spaces(&args);	token = args;	if(cli_strip_decimal_number(&args)) {		uart_printf("1 Incorrect format, switch [n] [/"text/"]/n");		return;	}	value = atoi(token);	if(value < 0 || value >= MACRO_MAX) {		uart_printf("2 Incorrect format, switch [n] [/"text/"]/n");		return;	}	++args;	cli_strip_spaces(&args);	token = args;	if(cli_strip_quotes(&args)) {		uart_printf("3 Incorrect format, switch [n] [/"text/"]/n");		return;	}	macro_set(value, ++token);}

void uart_socket_example(void *param){	char tx_data[] = {0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06};	uart_set_str uartset;	struct timeval tv;	fd_set readfds;	int read_len = 0, count = 0;	int ret = 0;	char rxbuf[512];	int uart_fd;	uart_socket_t *uart_socket = NULL;	uartset.BaudRate = 9600;	uartset.number = 8;	uartset.StopBits = 0;	uartset.FlowControl = 0;	uartset.parity = 0;	strcpy(uartset.UartName, "uart0");	uart_socket = uart_open(&uartset);	if(uart_socket == NULL){		uart_printf("Init uart socket failed!/n");		goto Exit;	}	uart_fd = uart_socket->fd;	uart_printf("/nOpen uart socket: %d/n", uart_fd);	while(1)	{		FD_ZERO(&readfds);		FD_SET(uart_fd, &readfds);		tv.tv_sec = 0;		tv.tv_usec = 20000;		if(count++ == 50){			uart_write(uart_socket, tx_data, sizeof(tx_data));			//uart_print_data("TX:", tx_data, sizeof(tx_data));			count = 0;		}		ret = select(uart_fd + 1, &readfds, NULL, NULL, &tv);		//uart_printf("[%d] select ret = %x count=%d/n", xTaskGetTickCount(), ret, count);			if(ret > 0)		{			if(FD_ISSET(uart_fd, &readfds))			{				read_len = uart_read(uart_socket, rxbuf, sizeof(rxbuf));				if(read_len > 0)				{					uart_print_data("RX:", rxbuf, read_len);					if(rtl_strncmp(rxbuf, "close", 5) == 0)						break;				}			}			//else for other sockets		}	}	uart_printf("Exit uart socket example!/n");	uart_close(uart_socket);Exit:	vTaskDelete(NULL);}

static void get_transmitter_uptime(void){    if (!g_report_packets) {        uart_printf(UART_EOL);    } else {        uart_printf("%u" UART_EOL, last_report_age() + g_last_report.sn * MEASURING_PERIOD);    }    uart_tx_flush();}

//打印舵机角度void steering_show(void) {    int i;    int data[22];    steering_get(data);    uart_printf("/r/n");    for(i=0 ; i<22 ; i++)        uart_printf("%d:%d/r/n", i+1, data[i]);}

uart_socket_t* uart_open(uart_set_str *puartpara){	PinName uart_tx = PA_7;//PA_4; //PA_7	PinName uart_rx = PA_6;//PA_0; //PA_6	uart_socket_t *u;	u = (uart_socket_t *)RtlZmalloc(sizeof(uart_socket_t));	if(!u){		uart_printf("%s(): Alloc memory for uart_socket failed!/n", __func__);		return NULL;	}		/*initial uart */	serial_init(&u->sobj, uart_tx,uart_rx);	serial_baud(&u->sobj,puartpara->BaudRate);	serial_format(&u->sobj, puartpara->number, (SerialParity)puartpara->parity, puartpara->StopBits);	/*uart irq handle*/	serial_irq_handler(&u->sobj, uart_irq, (int)u);	serial_irq_set(&u->sobj, RxIrq, 1);	serial_irq_set(&u->sobj, TxIrq, 1);#if UART_SOCKET_USE_DMA_TX   	serial_send_comp_handler(&u->sobj, (void*)uart_send_stream_done, (uint32_t)u);#endif	/*alloc a socket*/ 	u->fd = lwip_allocsocketsd();	if(u->fd == -1){		uart_printf("Failed to alloc uart socket!/n");		goto Exit2;	}	/*init uart related semaphore*/	RtlInitSema(&u->action_sema, 0);	RtlInitSema(&u->tx_sema, 1);	RtlInitSema(&u->dma_tx_sema, 1);		/*create uart_thread to handle send&recv data*/	{#define	UART_ACTION_STACKSIZE 512#define	UART_ACTION_PRIORITY	1		if(xTaskCreate(uart_action_handler, ((const char*)"uart_action"), UART_ACTION_STACKSIZE, u, UART_ACTION_PRIORITY, NULL) != pdPASS){			uart_printf("%s xTaskCreate(uart_action) failed", __FUNCTION__);			goto Exit1;		}	}	return u;Exit1:	/* Free uart related semaphore */	RtlFreeSema(&u->action_sema);	RtlFreeSema(&u->tx_sema);		RtlFreeSema(&u->dma_tx_sema);		Exit2:	RtlMfree((u8*)u, sizeof(uart_socket_t));	return NULL;}

void dual_print_reg_dump(unsigned int dual_id, unsigned int *ptr_isp_reg){    if (ptr_isp_reg)    {        uart_printf("%s %s %s/r/n", DUAL_REG_DUMP_HEADER, DUAL_DUMP_START, DUAL_DUMP_VERSION);        uart_printf("%s DEBUG.DUAL_LOG_ID = 0x%08X/r/n", DUAL_REG_DUMP_HEADER, dual_id);        DUMP_ISP_REG_MAP(DUAL_CPP_CODE_PRINTF_REG, uart_printf, ptr_isp_reg,);        uart_printf("%s %s/r/n", DUAL_REG_DUMP_HEADER, DUAL_DUMP_END);            }}

void cli_loop(void){	char buffer[CLI_BUFFER_SIZE];	char c;	int buffer_pos;	uart_printf("%s", cli_prompt);	buffer_pos = 0;	while(1) {		//wait until a character is available		while((c = uart_getchar()) == 0) { ; }		//new line means end of the command		if(c == '/n') {			//only process a command if something was entered			if(buffer_pos) {				buffer[buffer_pos] = '/0';				cli_process_command(buffer);			}			buffer_pos = 0;			memset(buffer, 0, CLI_BUFFER_SIZE);			uart_printf("%s", cli_prompt);		}		//there is more to come...		else if(isgraph(c) || isspace(c)) {			buffer[buffer_pos++] = c;		}		//		else if(c == ASCII_DEL) {			if(buffer_pos) {				buffer_pos--;				buffer[buffer_pos] = '/0';			}		}		//ignore for now		else {			continue;		}		//is the command too long?		if(buffer_pos >= CLI_BUFFER_SIZE) {			uart_printf("/n--Error--, command is too long. Command ignored./n");						buffer_pos = 0;			memset(buffer, 0, CLI_BUFFER_SIZE);			uart_printf("%s", cli_prompt);		}	}}

static  void  App_TaskStart (void *p_arg){    OS_ERR  os_err;    (void)p_arg;                                                /* See Note #1.                                         */    BSP_Init();                                                 /* Start BSP and tick initialization.                   */    BSP_Tick_Init();                                            /* Start Tick Initialization.                           */	    BSP_UART_Init(BSP_UART_DEFAULT,                             /* Start UART Initialization                            */	                BSP_BUSCLK,	                9600);    BSP_LCD_Init();                                             /* Initialize the seven-segment display panel.          */#if OS_CFG_STAT_TASK_EN > 0u    OSStatTaskCPUUsageInit(&os_err);                            /* Compute CPU capacity with no task running            */#endif#ifdef  CPU_CFG_INT_DIS_MEAS_EN    CPU_IntDisMeasMaxCurReset();#endif    APP_TRACE_INFO(("Creating Application Events.../n/r"));    App_ObjCreate();                                            /* Create Applicaton kernel objects.                    */    APP_TRACE_INFO(("Creating Application Tasks.../n/r"));    App_TaskCreate();                                           /* Create Application tasks.                            */    while (DEF_TRUE) {                                          /* Task body, always written as an infinite loop.       */        OSTimeDlyHMSM(0, 0, 2, 0,                      OS_OPT_TIME_HMSM_STRICT, &os_err);//		  BSP_UART_Send_String(BSP_UART_1,//				             "Hello/n");        uart_printf("Hello world/n");        OSTimeDly(10, OS_OPT_TIME_HMSM_STRICT, &os_err);        uart_printf("os_err = %d/n", os_err);			  //			  while (BSP_SW_Read (BSP_SW_1) != DEF_ON) {//					  OSTimeDly(1, OS_OPT_TIME_HMSM_STRICT, &os_err);//				}//				BSP_LED_Toggle(BSP_LED_RED);//				//				BSP_UART_Send_String(BSP_UART_1,//				                     "Hello/n");//				//				while (BSP_SW_Read (BSP_SW_1) == DEF_OFF) {//			      OSTimeDly(1, OS_OPT_TIME_HMSM_STRICT, &os_err);//				}    }}

void irtm_print_ekey_info(void){	/* print table header */	uart_printf("+=======================================================================+/n");	uart_printf("|Ch |Type/t|Extension/t|Ports/t/t|Group/t|Asym M/t|Status |/n");	uart_printf("+=======================================================================+/n");	uart_printf("SOON AVAIABLE/n");	/* print table bottom */	uart_printf("+=======================================================================+");}

// get log vbn from log block mapping tableUINT32 get_log_vbn (UINT32 const bank, UINT32 const logLbn){    uart_printf("get_log_vbn(bank=%d, log_lbn=%d)", bank, log_lbn);    uart_printf("/treading BMT: log_lbn=%d=>vbn=%d", log_lbn, Read_log_bmt(bank, log_lbn));#if OPTION_DEBUG_LOG    if (logLbn < LOG_BLK_PER_BANK)        return Read_log_bmt(bank, logLbn);    return INVALID;#else    return Read_log_bmt(bank, logLbn);#endif}

// fill entire dataspacestatic void fillup_dataspace(void){    UINT32 lba = 0;    UINT32 const num_sectors = SECTORS_PER_PAGE * NUM_BANKS;    uart_printf("start fill entire data space");    while (lba < (NUM_LSECTORS - num_sectors))    {        ftl_write(lba, num_sectors);        lba += num_sectors;    }    uart_printf("complete!");}

/** @brief Function initialization and configuration of QDEC driver instance. */static void qdec_config(void) {	uint32_t err_code;        nrf_drv_qdec_config_t qdec_config = NRF_DRV_QDEC_DEFAULT_CONFIG;	// Initialize hardware	err_code = nrf_drv_qdec_init(&qdec_config, qdec_event_handler);	APP_ERROR_CHECK(err_code);    	printf("QDEC testing started/n");	uart_printf("nrf_drv_qdec_init/n/r");	nrf_drv_qdec_enable(); // Event and corresponding interrupt are enabled.	uart_printf("nrf_drv_qdec_enable /n/r");}

static void cli_command_echo(char *args){	char *token;	cli_strip_spaces(&args);	token = args;	if(cli_strip_quotes(&args)) {		uart_printf("Incorrect format, echo [/"text/"]/n");		return;	}	uart_printf("%s/n", ++token);}

static void format(void){    UINT32 bank, vblock, vcount_val;    ASSERT(NUM_MISC_META_SECT > 0);    ASSERT(NUM_VCOUNT_SECT > 0);    uart_printf("Total FTL DRAM metadata size: %d KB", DRAM_BYTES_OTHER / 1024);    uart_printf("VBLKS_PER_BANK: %d", VBLKS_PER_BANK);    uart_printf("LBLKS_PER_BANK: %d", NUM_LPAGES / PAGES_PER_BLK / NUM_BANKS);    uart_printf("META_BLKS_PER_BANK: %d", META_BLKS_PER_BANK);    //----------------------------------------    // initialize DRAM metadata    //----------------------------------------    mem_set_dram(PAGE_MAP_ADDR, NULL, PAGE_MAP_BYTES);    mem_set_dram(VCOUNT_ADDR, NULL, VCOUNT_BYTES);    //----------------------------------------    // erase all blocks except vblock #0    //----------------------------------------	for (vblock = MISCBLK_VBN; vblock < VBLKS_PER_BANK; vblock++)	{		for (bank = 0; bank < NUM_BANKS; bank++)		{            vcount_val = VC_MAX;            if (is_bad_block(bank, vblock) == FALSE)			{				nand_block_erase(bank, vblock);                vcount_val = 0;            }            write_dram_16(VCOUNT_ADDR + ((bank * VBLKS_PER_BANK) + vblock) * sizeof(UINT16),                          vcount_val);        }    }    //----------------------------------------    // initialize SRAM metadata    //----------------------------------------    init_metadata_sram();    // flush metadata to NAND    logging_pmap_table();    logging_misc_metadata();    write_format_mark();	led(1);    uart_print("format complete");}

int main(void){    int status;    memset(RX_BUF,0,4);    led_init();    nRF24L01_init();    motor_init();			//电机初始化    QuadCopter_init(&QuadCopter);    uart_init(115200);    status = nRF_Check(); 	   	 	/*检测NRF模块与MCU的连接*/    if(status == SUCCESS)			/*判断连接状态*/        uart_printf("/r/n      NRF与MCU连接成功！/r/n");    else        uart_printf("/r/n  NRF与MCU连接失败，请重新检查接线。/r/n");    nRF_RX_Mode();    LED_OFF;    while(1)    {        nRF_RX_Mode();        nRF_Rx_Dat(RX_BUF);        status=RX_BUF[2];        switch(status)        {        case Q_ON:            LED_ON;            QuadCopter.Status=Q_ON;            QuadCopter.BaseSpeed=300;            motor_speed(QuadCopter.BaseSpeed,QuadCopter.BaseSpeed,QuadCopter.BaseSpeed,QuadCopter.BaseSpeed ) ;            break;        case Q_UP:            QuadCopter_up(&QuadCopter);            break;        case Q_DOWN:            QuadCopter_down(&QuadCopter);            break;        case Q_OFF:            LED_OFF;            QuadCopter.Status=Q_OFF;            motor_speed(0,0,0,0 ) ;            break;        default:            break;        }    }}

//Reads data into uart's fifo.int uart_read_start(uart_s* uart, int timeout){	if (!uart->rxfifo){		uart_printf(CLR_CANCEL,0,"Uart has no rxfifo/n");		return -1;	}	uart_printf(CLR_CANCEL,2,"uart_read_start/n");	if (!uart->opened){		uart_open(uart);	}	//Wiggle	/*	int status = TIOCM_CTS;	ioctl (uart->fd, TIOCMBIS, &status);	ioctl (uart->fd, TIOCMBIC, &status);	*/	//Use a buffer to flatten the fifo.	uint8_t* buff = (uint8_t*)malloc(uart->rxfifo->size);	int n = uart_read(uart,buff,512,timeout);	//Some debug data:	uart_printf(CLR_CANCEL,1,"Received %i characters/n",n);	#if(UARTDEBUG)	if (n){	printf_hex_block(buff,n,1);	}	#endif	if (n == -1){		free(buff);		return -1;	}	//Store in fifo.	int i =0;	int r=n;	while(r--){				fifo_putc(uart->rxfifo,buff[i]);		i++;	}	uart_printf(CLR_CANCEL,1,"Done/n");	free(buff);	return n;}

void __attribute__((interrupt("IRQ")))dm9000_isr(void){	unsigned char int_status,Rx_ready;	unsigned short Rx_status,Rx_len;	int i;	if(EINT0PEND & (1 << 7)){ //dm9000		int_status = ior(0xfe);		if(int_status & 1){ //rx			Rx_ready = ior(0xf0);			Rx_ready = ior(0xf0);			if(Rx_ready == 1){				DM9000_INDEX = 0xf2;				Rx_status = DM9000_DATA16;				Rx_len = DM9000_DATA16;				for(i = 0;i < (Rx_len + 1) / 2;i++){					((unsigned short*)Net_Rxbuf)[i] = DM9000_DATA16;				}				///				uart_puts(Net_Rxbuf + 42);			}			iow(0xfe,1);		}		if(int_status & 2){//tx			if(ior(0x01) & (4 | 8)){				uart_printf("dm9000 send complete/n");			}			iow(0xfe,2);		}		EINT0PEND = (1 << 7);	}	VIC0ADDRESS = 0;	VIC1ADDRESS = 0;}

// TODO: double check datasheet, could be faster (smaller delays)void humidity_sensor_read(Humidity_Sensor h, char *read_data, uint16_t max_bytes) {  if (h.write) {} // stop complaining  i2c_start(AM2315_TWI_ADDRESS_WRITE); // Sensor doesn't respond to start signal  _delay_ms(2); // TODO: wait could be shorter?  i2c_stop(); // should be woke now  if(i2c_start(AM2315_TWI_ADDRESS_WRITE)) {// tell it to generate the temp and hum    uart_puts_P(PSTR("Couldn't communicate with humidity sensor/r/n"));    return;  }  i2c_write(READREGCODE);  i2c_write(BEGINREG);  i2c_write(NUMREGTOREAD);  i2c_stop();  _delay_ms(10); // TODO: wait could be shorter?  uint8_t ret[NUMBYTESTOSTORE];  i2c_start(AM2315_TWI_ADDRESS_READ); // now read the data  for (int i = 0; i < NUMBYTESTOSTORE - 1; i++) ret[i] = i2c_read(1);  ret[NUMBYTESTOSTORE - 1] = i2c_read(0); // this reads and sends a CRC signal  i2c_stop();  if (ret[0] != READREGCODE || ret[1] != NUMREGTOREAD) {    uart_puts_P(PSTR("Error reading humidity sensor/r/n"));    return;  }  // note that both these values are 10 times what they should be but  // representing with floating point is a terrible idea so we manipulate the  // print statement instead  uint16_t hum = ((ret[2] << 8) | ret[3]);  uint16_t temp = ((ret[4] << 8) | ret[5]); // NOTE that leading bit is sign  uart_printf("Humidity is %d.%d %%RH and Temperature is %s%d.%d C/r/n",      hum / 10, hum % 10, // hum / 10 first, then last digit goes after '.'      ret[4] & 0x80 ? "-" : "", // handle the sign (if leading is set, then neg)      (temp & 0x7f) / 10, temp % 10); // same as humidity except don't count b15  snprintf(read_data, max_bytes, "%d.%d %%RH/r/n", hum / 10, hum % 10);}