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);
}
}
}
