/*******************************************************************************
* Function Name: UART_UartGetByte
********************************************************************************
*
* Summary:
* Retrieves the next data element from the receive buffer, returns the
* received byte and error condition.
* - The RX software buffer is disabled: returns the data element retrieved
* from the RX FIFO. Undefined data will be returned if the RX FIFO is
* empty.
* - The RX software buffer is enabled: returns data element from the
* software receive buffer.
*
* Parameters:
* None
*
* Return:
* Bits 7-0 contain the next data element from the receive buffer and
* other bits contain the error condition.
*
* Side Effects:
* The errors bits may not correspond with reading characters due to RX FIFO
* and software buffer usage.
* RX software buffer is disabled: The internal software buffer overflow
* is not returned as status by this function.
* Check SCB_rxBufferOverflow to capture that error condition.
*
*******************************************************************************/
uint32 UART_UartGetByte(void)
{
uint32 rxData;
uint32 tmpStatus;
#if (UART_CHECK_RX_SW_BUFFER)
{
UART_DisableInt();
}
#endif
if (0u != UART_SpiUartGetRxBufferSize())
{
/* Enables interrupt to receive more bytes: at least one byte is in
* buffer.
*/
#if (UART_CHECK_RX_SW_BUFFER)
{
UART_EnableInt();
}
#endif
/* Get received byte */
rxData = UART_SpiUartReadRxData();
}
else
{
/* Reads a byte directly from RX FIFO: underflow is raised in the case
* of empty. Otherwise the first received byte will be read.
*/
rxData = UART_RX_FIFO_RD_REG;
/* Enables interrupt to receive more bytes.
* The RX_NOT_EMPTY interrupt is cleared by the interrupt routine
* in case the byte was received and read by code above.
*/
#if (UART_CHECK_RX_SW_BUFFER)
{
UART_EnableInt();
}
#endif
}
/* Get and clear RX error mask */
tmpStatus = (UART_GetRxInterruptSource() & UART_INTR_RX_ERR);
UART_ClearRxInterruptSource(UART_INTR_RX_ERR);
/* Puts together data and error status:
* MP mode and accept address: 9th bit is set to notify mark.
*/
rxData |= ((uint32) (tmpStatus << 8u));
return (rxData);
}
/*******************************************************************************
* Function Name: UART_UartCyBtldrCommRead
********************************************************************************
*
* Summary:
* Allows the caller to read data from the bootloader host (the host writes the
* data). The function handles polling to allow a block of data to be completely
* received from the host device.
*
* Parameters:
* pData: Pointer to storage for the block of data to be read from the
* bootloader host
* size: Number of bytes to be read.
* count: Pointer to the variable to write the number of bytes actually
* read.
* timeOut: Number of units in 10 ms to wait before returning because of a
* timeout.
*
* Return:
* Returns CYRET_SUCCESS if no problem was encountered or returns the value
* that best describes the problem. For more information refer to the
* "Return Codes" section of the System Reference Guide.
*
*******************************************************************************/
cystatus UART_UartCyBtldrCommRead(uint8 pData[], uint16 size, uint16 * count, uint8 timeOut)
{
cystatus status;
uint32 byteCount;
uint32 timeoutMs;
uint32 i;
status = CYRET_BAD_PARAM;
if ((NULL != pData) && (size > 0u))
{
status = CYRET_TIMEOUT;
timeoutMs = ((uint32) 10u * timeOut); /* Convert from 10mS check to 1mS checks */
/* Wait with timeout 1mS for packet end */
byteCount = 0u;
do
{
/* Check packet start */
if (0u != UART_SpiUartGetRxBufferSize())
{
/* Wait for end of packet */
do
{
byteCount = UART_SpiUartGetRxBufferSize();
CyDelayUs(UART_UART_BYTE_TO_BYTE);
}
while (byteCount != UART_SpiUartGetRxBufferSize());
byteCount = UART_BYTES_TO_COPY(byteCount, size);
*count = (uint16) byteCount;
status = CYRET_SUCCESS;
break;
}
CyDelay(UART_WAIT_1_MS);
--timeoutMs;
}
while (0u != timeoutMs);
/* Get data from RX buffer into bootloader buffer */
for (i = 0u; i < byteCount; ++i)
{
pData[i] = (uint8) UART_SpiUartReadRxData();
}
}
return (status);
}
/*******************************************************************************
* Function Name: UART_UartGetChar
********************************************************************************
*
* Summary:
* Retrieves the next data element from the receive buffer.
* This function is designed for ASCII characters and returns a char
* where 1 to 255 are valid characters and 0 indicates an error occurred or
* no data present.
* - The RX software buffer is disabled: returns the data element
* retrieved from the RX FIFO.
* Undefined data will be returned if the RX FIFO is empty.
* - The RX software buffer is enabled: returns the data element from
* the software receive buffer.
*
* Parameters:
* None
*
* Return:
* The next data element from the receive buffer.
* ASCII character values from 1 to 255 are valid.
* A returned zero signifies an error condition or no data available.
*
* Side Effects:
* The errors bits may not correspond with reading characters due to RX FIFO
* and software buffer usage.
* RX software buffer is enabled: The internal software buffer overflow
* does not treat as an error condition.
* Check SCB_rxBufferOverflow to capture that error condition.
*
*******************************************************************************/
uint32 UART_UartGetChar(void)
{
uint32 rxData = 0u;
/* Reads data only if there is data to read */
if (0u != UART_SpiUartGetRxBufferSize())
{
rxData = UART_SpiUartReadRxData();
}
if (UART_CHECK_INTR_RX(UART_INTR_RX_ERR))
{
rxData = 0u; /* Error occurred: returns zero */
UART_ClearRxInterruptSource(UART_INTR_RX_ERR);
}
return (rxData);
}
void BLE_Status()
{
char Comand[10] = "AT";
uint16 Inc = 0;
UART_UartPutString(Comand);
while(UART_SpiUartGetRxBufferSize() == 0)
{
Inc++;
if(Inc>1000) return;
}
Inc = 0;
while(UART_SpiUartGetRxBufferSize() > 0)
{
Comand[Inc] = (char)UART_SpiUartReadRxData();
Inc++;
}
Add_To_DDR(Comand);
Print_DDR();
}
/*******************************************************************************
* Function Name: CyBtldrCommRead
********************************************************************************
*
* Summary:
* Receives the command.
*
* Parameters:
* pData: A pointer to the area to store the block of data received
* from the device.
* size: Maximum size of the read buffer
* count: Pointer to an unsigned short variable to write the number
* of bytes actually read.
* timeOut: Number of units to wait before returning because of a timeOut.
* Timeout is measured in 10s of ms.
*
* Return:
* cystatus: This function will return CYRET_SUCCESS if at least one byte is received
* successfully within the timeout interval. If no data is received this
* function will return CYRET_EMPTY.
*
* Theory:
* 'receivedDataCount' is updated with number of bytes received in the UART RX
* interrupt routine. This variable is used to check whether some data is received
* within the timeout period specified in *.cydwr. If data is received before the timeout,
* the control will remain in another loop waiting for more data until no data is
* received for a BYTE2BYTE_TIME_OUT(2 ms) interval.
*
* Note: Increase the BYTE2BYTE_TIME_OUT to 10 ms for baud rates less than 9600.
*
* BYTE2BYTE_TIME_OUT is used for detecting timeout marking end of block data from host.
* This has to be set to a value which is greater than the expected maximum delay
* between two bytes during a block/packet transmission from the host.
* You have to account for the delay in hardware converters while calculating this value,
* if you are using any USB-UART bridges.
*******************************************************************************/
cystatus CyBtldrCommRead(uint8 * pData, uint16 Size, uint16 * Count, uint8 TimeOut)
{
uint16 cntr,dataIndexCntr;
uint16 tempCount,oldDataCount;
cystatus status = CYRET_EMPTY;
/* Check whether data is received within the timeout period.
* Timeout period is in units of 10ms.
* If at least one byte is received within the timeout interval, wait for more data */
for (cntr = 0; cntr < TimeOut*10; cntr++)
{
receivedDataCount = UART_SpiUartGetRxBufferSize();
/* If at least one byte is received within the timeout interval enter the next loop
* waiting for more data reception */
if(receivedDataCount!=0)
{
/* Wait for more data until 2 ms byte to byte time out interval receivedDataCount
* variable is updated in on each data reception. If no data is received during the
* last 2 ms (BYTE2BYTE_TIME_OUT) then it is considered as end of transmitted data
* block (packet) from the host and the program execution will break from the data
* awaiting loop with status=CYRET_SUCCESS */
do{
oldDataCount = receivedDataCount;
CyDelay(BYTE2BYTE_TIME_OUT);
receivedDataCount = UART_SpiUartGetRxBufferSize();
}while(receivedDataCount > oldDataCount);
status = CYRET_SUCCESS;
break;
}
/* If no data is received, give a delay of 1ms and check again until the Timeout specified in .cydwr. */
else
{
CyDelay(1);
}
}
/* Initialize the data read indexes and Count value*/
*Count = 0;
dataIndexCntr = 0;
/* If receivedDataCount>0 , move the received data to the pData buffer */
while(receivedDataCount > 0)
{
tempCount=receivedDataCount;
*Count =(*Count ) + tempCount;
/* Check if buffer overflow will occur before moving the data */
if(*Count < Size)
{
for (cntr = 0;((cntr < tempCount) ); cntr++)
{
/* Read the data and move it to the pData buffer */
pData[dataIndexCntr++] = UART_SpiUartReadRxData();
}
/* Disable the interrupts before updating the receivedDataCount and
* re-enable the interrupts after updating */
CyGlobalIntDisable;
/* subtract the read data count from received data count */
receivedDataCount=receivedDataCount-tempCount;
CyGlobalIntEnable;
/* Check if the last data received is End of packet(0x17)
* If not wait for additional 5ms */
if(pData[dataIndexCntr-1]!= END_OF_PACKET)
CyDelay(5);
}
/* If there is no space to move data, break from the loop */
else
{
*Count=(*Count)-tempCount;
UART_SpiUartClearRxBuffer();
status = CYRET_EMPTY;
break;
}
}
return status;
}
