void vSerialPutString( xComPortHandle pxPort, const signed char * const pcString, unsigned short usStringLength ) { ( void ) pxPort; /* Output uxStringLength bytes starting from pcString. */ XUartLite_Send( &xUartLiteInstance, ( unsigned char * ) pcString, usStringLength ); }
int uart_send(u8* sendBuffer, u8 size){ if(XUartLite_IsSending(&uart_device)) return 0; int SentCount = XUartLite_Send(&uart_device, sendBuffer, size); return SentCount; }
/** * * This function is the handler which performs processing to receive data from * the UartLite. It is called from an interrupt context such that the amount of * processing performed should be minimized. It is called data is present in * the receive FIFO of the UartLite such that the data can be retrieved from * the UartLite. The size of the data present in the FIFO is not known when * this function is called. * * This handler provides an example of how to handle data for the UartLite, * but is application specific. * * @param CallBackRef contains a callback reference from the driver, in * this case it is the instance pointer for the UartLite driver. * @param EventData contains the number of bytes sent or received for sent * and receive events. * * @return None. * * @note None. * ****************************************************************************/ void RecvHandler_UART_1(void *CallBackRef, unsigned int EventData) { unsigned int num_of_chars; num_of_chars = XUartLite_Recv(&UART_Inst_Ptr_1, RxBuffer_1, BUF_SIZE); while(XUartLite_IsSending(&UART_Inst_Ptr_1)); XUartLite_Send(&UART_Inst_Ptr_1, RxBuffer_1, num_of_chars); if(UART_DBG) xil_printf("UART1: Received %d bytes: %02X \r\n",num_of_chars,*RxBuffer_1); }
void WirelessSendHandler(void *CallBackRef, unsigned int EventData) { unsigned char c; wireless.send_in_progress = 0; if(!QueueIsEmpty(&(wireless.write_queue))) { wireless.send_in_progress = 1; c = QueuePop(&(wireless.write_queue)); XUartLite_Send(&wireless.uart, &c, 1); } }
/* getData() ** ** Parameters: ** serPort: The HardwareSerial port (Serial1, Serial2, etc) from ** MPIDE that will be used to communicate with the PmodBT2 ** ** Return Value: ** The type of sentence that was recieved. ** ** Errors: ** none ** ** Description: ** Does a read of data. finishes when a value of decimal ** 10 (ASCII <LF>) is detected. Reads the first three characters to ** verify the packet starts with $GP, then checks the next three ** to decide which struct to parse the data into. */ int BT2_sendData(PmodBT2* InstancePtr, char* sendData, int size) { char recv[500]={0}; int i=0; int count = 0; unsigned int ReceivedCount = 0; while(i<size){ i+= XUartLite_Send(&InstancePtr->BT2Uart, sendData, size); //while(XUartLite_IsSending(&InstancePtr->BT2Uart)); } return i;//Return the type of sentence that was sent }
void vSerialPutString( xComPortHandle pxPort, const signed char * const pcString, unsigned short usStringLength ) { const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 150UL ); ( void ) pxPort; /* Note this is the currently sending task. */ xUARTSendingTask = xTaskGetCurrentTaskHandle(); /* Output uxStringLength bytes starting from pcString. */ XUartLite_Send( &xUartLiteInstance, ( unsigned char * ) pcString, usStringLength ); /* Wait in the Blocked state (so not using any CPU time) for the Tx to complete. */ ulTaskNotifyTake( pdTRUE, xMaxBlockTime ); }
void SendHandler(void *CallBackRef, unsigned int EventData) { // delete the bytes which were sent previously if (EventData % sizeof(uint32_t)) { LOG_DEBUG("ERROR: sent data not word aligned!!!\n"); } cbuffer_deletefront(tx_buffer, EventData / sizeof(uint32_t)); if (cbuffer_size(tx_buffer)) { unsigned int to_send = cbuffer_contiguous_data_size(tx_buffer) * sizeof(uint32_t); XUartLite_Send(&UartLite, (u8*)&(tx_buffer->data[tx_buffer->pos]), to_send); LOG_DEBUG("SendHandler _Send %x\n", to_send); currently_sending = 1; } else { LOG_DEBUG("SendHandler Idling\n"); currently_sending = 0; } LOG_DEBUG("SendHandler SENT INTR %x\n", EventData); }
signed portBASE_TYPE xSerialPutChar( xComPortHandle pxPort, signed char cOutChar, TickType_t xBlockTime ) { const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 150UL ); portBASE_TYPE xReturn; ( void ) pxPort; ( void ) xBlockTime; /* Note this is the currently sending task. */ xUARTSendingTask = xTaskGetCurrentTaskHandle(); XUartLite_Send( &xUartLiteInstance, ( unsigned char * ) &cOutChar, sizeof( cOutChar ) ); /* Wait in the Blocked state (so not using any CPU time) for the Tx to complete. */ xReturn = ulTaskNotifyTake( pdTRUE, xMaxBlockTime ); return xReturn; }
int Wireless_Send(Skaro_Wireless * w, char command, char length, char * data){ unsigned char top; CPU_MSR msr = DISABLE_INTERRUPTS(); QueuePush(&(w->write_queue), (void *)(uint32)command); QueuePush(&(w->write_queue),(void *)(uint32)length); int i; for(i = 0; i < length; i++){ QueuePush(&w->write_queue, (void *)(uint32)data[i]); } // If there is no send in progress, initiate a send if (!(w->send_in_progress)) { // We are about to send it, so pop it off top = (unsigned char)(uint32)QueuePop(&(w->write_queue)); w->send_in_progress = 1; XUartLite_Send(&(w->uart), &top, 1); } RESTORE_INTERRUPTS(msr); return 1; }
/** * * This function does a minimal test on the UartLite device and driver as a * design example. The purpose of this function is to illustrate * how to use the XUartLite component. * * This function sends data and expects to receive the same data through the * UartLite. The user must provide a physical loopback such that data which is * transmitted will be received. * * This function uses interrupt driver mode of the UartLite device. The calls * to the UartLite driver in the handlers should only use the non-blocking * calls. * * @param DeviceId is the Device ID of the UartLite Device and is the * XPAR_<uartlite_instance>_DEVICE_ID value from xparameters.h. * * @return XST_SUCCESS if successful, otherwise XST_FAILURE. * * @note * * This function contains an infinite loop such that if interrupts are not * working it may never return. * ****************************************************************************/ int UartLiteIntrExample(u16 DeviceId) { int Status; int Index; /* * Initialize the UartLite driver so that it's ready to use. */ Status = XUartLite_Initialize(&UartLite, DeviceId); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Perform a self-test to ensure that the hardware was built correctly. */ Status = XUartLite_SelfTest(&UartLite); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Connect the UartLite to the interrupt subsystem such that interrupts can * occur. This function is application specific. */ Status = SetupInterruptSystem(&UartLite); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Setup the handlers for the UartLite that will be called from the * interrupt context when data has been sent and received, specify a * pointer to the UartLite driver instance as the callback reference so * that the handlers are able to access the instance data. */ XUartLite_SetSendHandler(&UartLite, SendHandler, &UartLite); XUartLite_SetRecvHandler(&UartLite, RecvHandler, &UartLite); /* * Enable the interrupt of the UartLite so that interrupts will occur. */ XUartLite_EnableInterrupt(&UartLite); /* * Initialize the send buffer bytes with a pattern to send and the * the receive buffer bytes to zero to allow the receive data to be * verified. */ for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) { SendBuffer[Index] = Index; ReceiveBuffer[Index] = 0; } /* * Start receiving data before sending it since there is a loopback. */ XUartLite_Recv(&UartLite, ReceiveBuffer, TEST_BUFFER_SIZE); /* * Send the buffer using the UartLite. */ XUartLite_Send(&UartLite, SendBuffer, TEST_BUFFER_SIZE); /* * Wait for the entire buffer to be received, letting the interrupt * processing work in the background, this function may get locked * up in this loop if the interrupts are not working correctly. */ while ((TotalReceivedCount != TEST_BUFFER_SIZE) || (TotalSentCount != TEST_BUFFER_SIZE)) { } /* * Verify the entire receive buffer was successfully received. */ for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) { if (ReceiveBuffer[Index] != SendBuffer[Index]) { return XST_FAILURE; } } return XST_SUCCESS; }
int main(void) { LOG_INFO("UART CTP FE echo test\n"); init_platform(); tx_buffer = cbuffer_new(); rx_buffer = cbuffer_new(); int Status; u16 DeviceId = UARTLITE_DEVICE_ID; /* * Initialize the UartLite driver so that it's ready to use. */ Status = XUartLite_Initialize(&UartLite, DeviceId); if (Status != XST_SUCCESS) { LOG_ERROR ("Error: could not initialize UART\n"); return XST_FAILURE; } XUartLite_ResetFifos(&UartLite); /* * Perform a self-test to ensure that the hardware was built correctly. */ Status = XUartLite_SelfTest(&UartLite); if (Status != XST_SUCCESS) { LOG_ERROR ("Error: self test failed\n"); return XST_FAILURE; } /* * Connect the UartLite to the interrupt subsystem such that interrupts can * occur. This function is application specific. */ Status = SetupInterruptSystem(&UartLite); if (Status != XST_SUCCESS) { LOG_ERROR ("Error: could not setup interrupts\n"); return XST_FAILURE; } /* * Setup the handlers for the UartLite that will be called from the * interrupt context when data has been sent and received, specify a * pointer to the UartLite driver instance as the callback reference so * that the handlers are able to access the instance data. */ XUartLite_SetSendHandler(&UartLite, SendHandler, &UartLite); XUartLite_SetRecvHandler(&UartLite, RecvHandler, &UartLite); /* * Enable the interrupt of the UartLite so that interrupts will occur. */ XUartLite_EnableInterrupt(&UartLite); // bootstrap the READ LOG_DEBUG("Bootstrapping READ\n"); XUartLite_Recv(&UartLite, (u8*)&rx_tmp_buffer, sizeof(uint32_t)); LOG_INFO("Starting loop\n"); /* LOG_DEBUG("Sending 'wtf!'\n"); currently_sending = 1; char help[4] = "wtf!"; unsigned int ret = XUartLite_Send(&UartLite, (u8*)help, 4); LOG_DEBUG("WTF send complete return: %x\n", ret); */ /* echo received data forever */ unsigned int heartbeat = 0; while (1) { if (heartbeat++ % (1 << 8)) { //LOG_DEBUG("bump %x\n", heartbeat); } while (cbuffer_size(rx_buffer) && cbuffer_freespace(tx_buffer)) { uint32_t data = cbuffer_pop_front(rx_buffer); //LOG_DEBUG("Echoing data word %x\n", data); cbuffer_push_back(tx_buffer, data); } if (!currently_sending && cbuffer_size(tx_buffer)) { LOG_DEBUG("\nREINT SEND\n"); currently_sending = 1; /* if (XUartLite_IsSending(&UartLite)) { LOG_DEBUG("UART STAT: sending\n"); } else { LOG_DEBUG("UART STAT: idle\n"); } */ unsigned int to_send = cbuffer_contiguous_data_size(tx_buffer) * sizeof(uint32_t); u8* output_ptr = (u8*)&(tx_buffer->data[tx_buffer->pos]); //LOG_DEBUG("REINIT %x\n", to_send); //LOG_DEBUG("SENDADDR %x\n", output_ptr); XUartLite_Send(&UartLite, output_ptr, to_send); } } }