/*******************************************************************************
    * 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);
    }
Exemple #4
0
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();
}
Exemple #5
0
/*******************************************************************************
* 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;
}