//********************************
//********************************
//********** INTERRUPTS **********
//********************************
//********************************
void __ISR(_UART_1_VECTOR, ipl5) Uart1InterruptHandler (void) 		//(ipl# must match the priority level assigned to the irq where its enabled)
{
	static BYTE data;
	static BYTE status;
	static WORD tx_checksum;
	static WORD rx_checksum;
	static WORD checksum_recevied;
	static WORD w_temp;
	static WORD rx_length_received;

	Nop();

	if (
	(INTGetEnable(INT_SOURCE_UART_TX(COMMS_UART_NAME))) &&
	(INTGetFlag(INT_SOURCE_UART_TX(COMMS_UART_NAME)))
	)
	{
		//----------------------------------
		//----------------------------------
		//---------- TX INTERRUPT ----------
		//----------------------------------
		//----------------------------------

		while (UARTTransmitterIsReady(COMMS_UART_NAME))
		{
			//if (comms_tx_byte == 0)		//Done in start tx function
			//{
			//	//----- SEND BYTE 0 -----
			//	comms_tx_chksum = (WORD)comms_tx_buffer[0];
			//	COMMS_TX_REG = (WORD)comms_tx_buffer[comms_tx_byte++];
			//}
			if (comms_tx_byte < comms_tx_no_of_bytes_to_tx)
			{
				//----- SEND NEXT DATA BYTE -----
				comms_tx_chksum += (WORD)comms_tx_buffer[comms_tx_byte];			//Add to checksum

				UARTSendDataByte(COMMS_UART_NAME, comms_tx_buffer[comms_tx_byte++]);
			}
			else if (comms_tx_byte == comms_tx_no_of_bytes_to_tx)
			{
				//----- SEND CHECKSUM HIGH -----
				UARTSendDataByte(COMMS_UART_NAME, (comms_tx_chksum >> 8));
				comms_tx_byte++;
			}
			else if (comms_tx_byte == (comms_tx_no_of_bytes_to_tx + 1))
			{
				//----- SEND CHECKSUM LOW -----
				UARTSendDataByte(COMMS_UART_NAME, (comms_tx_chksum & 0x00ff));
				comms_tx_byte++;

				//----- ALL BYTES SENT -----
				comms_tx_byte = 0;					//Reset tx byte counter (indicates we're done)
				comms_tx_no_of_bytes_to_tx = 0;

				//DISABLE TX IRQ
				INTEnable(INT_SOURCE_UART_TX(COMMS_UART_NAME), INT_DISABLED);
			}

		} //while (UARTTransmitterIsReady(COMMS_UART_NAME))
Exemple #2
0
void hal_uart_send_byte(hal_uart_port port, uint8_t data){
    assert(port >= HAL_UART_PORT_1 && port <= HAL_UART_NUMBER_OF_PORTS );
    UART_MODULE uart = logic_uart2phy_uart(port);
    /* block until transmiter can send data */
    while(!UARTTransmitterIsReady(uart));
    UARTSendDataByte(uart, data);
}
//*************************************
//*************************************
//********** COMMS TX PACKET **********
//*************************************
//*************************************
//Call with:
//	comms_tx_byte			Check this is zero before loading comms_tx_buffer (confirms last tx is complete)
//	comms_tx_buffer[]		The packet data to send with the command in byte 0:1.  The Length will automatically be added to bytes 2:3 by this function
//	packet_length			The number of data bytes excluding the checksum (which is automatically added by the tx function)
void comms_tx_packet (WORD packet_length)
{

	//Packet format:
	//	CommandH | CommandL | LengthH | LengthL | 0-# Data Bytes | Checksum H | Checksum L

	//Check last tx is complete
	if (comms_tx_byte)
		return;

	if (packet_length > COMMS_TX_BUFFER_LENGTH)
		return;

	//----- START TX -----
	comms_tx_no_of_bytes_to_tx = packet_length;		//no of bytes to tx (excluding checksum)

	//Set the length bytes
	comms_tx_buffer[2] = (BYTE)(packet_length >> 8);
	comms_tx_buffer[3] = (BYTE)(packet_length & 0x00ff);

	//comms_rx_no_of_bytes_to_rx = 0xfffe;		//If you want to reset rx
	//comms_rx_1ms_timeout_timer = ;

	comms_tx_byte = 0;

	comms_tx_chksum = (WORD)comms_tx_buffer[0];
	
	INTClearFlag(INT_SOURCE_UART_TX(COMMS_UART_NAME));
	UARTSendDataByte(COMMS_UART_NAME, comms_tx_buffer[comms_tx_byte++]);	//Manually trigger the first tx
	INTEnable(INT_SOURCE_UART_TX(COMMS_UART_NAME), INT_ENABLED);
}
Exemple #4
0
// Write a string over the serial port
int SendString(int id, const char *string)
{
    UART_MODULE uartX;
    switch(id)
    {
        case 1:
            uartX = UART1;
            break;
        case 2:
            uartX = UART2;
            break;
        case 3:
            uartX = UART3;
            break;
        case 4:
            uartX = UART4;
            break;
        default:
            uartX = UART1;
    }
    while(*string != '\0')
    {
      while(!UARTTransmitterIsReady(uartX));
      UARTSendDataByte(uartX, (char) *string);
      string++;
      while(!UARTTransmissionHasCompleted(uartX));
    }
    return 1;
}
Exemple #5
0
void PutCharacterBluetooth(const char character)
{
        while(!UARTTransmitterIsReady(UART_MODULE_ID2));

        UARTSendDataByte(UART_MODULE_ID2, character);

        while(!UARTTransmissionHasCompleted(UART_MODULE_ID2));
}
Exemple #6
0
void sendString(char* string){
    int i = 0;
    while(string[i]){
        while(!UARTTransmitterIsReady(UART1));
        UARTSendDataByte(UART1, string[i]);
        i++;
    }
}
void Serial2Write(uint8 data) // write to UART directly and wait to finish (hangs execution until finished)
{
	if(SerialConnected) // dont write anything to serial until connection made from client
	{
    UARTSendDataByte(UART2, data);
    while(!UARTTransmissionHasCompleted(UART2));
	}
}
Exemple #8
0
// Write a string over the serial port
void WriteString(UART_MODULE id, const char *string) {
  while(*string != '\0') {
  while(!UARTTransmitterIsReady(id));
  UARTSendDataByte(id, *string);
  string++;
  while(!UARTTransmissionHasCompleted(id));
  }
}
Exemple #9
0
		void tx(const void *src, size_t n) {
			size_t ui;
			for (ui = 0; ui < n; ++ui) {
				WDT::clear();
				while (!UARTTransmitterIsReady(module)) Nop();
				UARTSendDataByte(module, ((const BYTE *)src)[ui]);
			}
			//	while (!UARTTransmissionHasCompleted(module)) Nop(); // TODO: async
		}
// *****************************************************************************
// void SendDataBuffer(const UARTx, const char *buffer)
// Envoie sur le port serie la chaine de caractère
// @param    : UARTx : choix du port  
//                    UART1,UART2,UART3,UART4,UART5,UART6
//              buffer : chaine de caractère
// *****************************************************************************
void SendDataBuffer(const UARTx, const char *buffer)
{
    while(*buffer != '\n')
    {
        while(!UARTTransmitterIsReady(UARTx));
        UARTSendDataByte(UARTx, *buffer);
        buffer++; 
    }
    while(!UARTTransmissionHasCompleted(UARTx));
}
void WriteString(const char *string)
{
    while(*string != '\0')
    {
        while(!UARTTransmitterIsReady(UART_CMD_MODULE_ID));
        UARTSendDataByte(UART_CMD_MODULE_ID, *string);
        string++;
        while(!UARTTransmissionHasCompleted(UART_CMD_MODULE_ID));
    }
}
/*
*	Function Name:	void UARTiWriteBinaryData(void)
*	Description:	Writes a block of binary data to he selected uart.
*	Initiator: 		Keith Suhoza
*	Date: 			01/23/2012
*/
void UARTiWriteBinaryData(unsigned char *data_block, int length, UART_MODULE iUART)
{
  while( length)
  {
      while(!UARTTransmitterIsReady(iUART));
      UARTSendDataByte(iUART, *data_block++);
      while(!UARTTransmissionHasCompleted(iUART));
      length--;
  }
}
Exemple #13
0
void uart_print(BYTE *string)
{
    while(!string)
    {
        while(!UARTTransmitterIsReady(UART1));
        UARTSendDataByte(UART1, *string);
        string++;
        while(!UARTTransmissionHasCompleted(UART1));
    }
}
Exemple #14
0
//******************************************************************************
//Interrupt Request Routines
//******************************************************************************
void __ISR(_UART_1_VECTOR, IPL5AUTO) __UART1Interrupt(void)
{
    UINT8 rxByte = 0;
    UINT8 txByte = 0;
    int rslt = 0;

    if (INTGetFlag(INT_U1RX))
    {
        //Add received byte
        rxByte = UARTGetDataByte(UART1);
        FIFOUART1_pushRxQueue(&rxByte, 1);

        INTClearFlag(INT_U1RX);
    }
    if (INTGetFlag(INT_U1TX))
    {
        rslt = FIFOUART1_popTxQueue(&txByte);

        switch (rslt)
        {
            case 2: //Success, non-empty buffer
                UARTSendDataByte(UART1, txByte);
                break;

            case 1: //Success, empty buffer
                UARTSendDataByte(UART1, txByte);
                INTEnable(INT_U1TX, INT_DISABLED);
                break;

            case -1: //Queue is Overflowing
                //Reset the indexs
                FIFOUART1_TxBuffer_TxIndex = 0;
                FIFOUART1_TxBuffer_Index = 0;
            case -2: //Queue is Empty
            default: //unknown result
                INTEnable(INT_U1TX, INT_DISABLED);
                break;
        }

        INTClearFlag(INT_U1TX);
    }
}
void PutCharacter(const char character)
{
        while(!UARTTransmitterIsReady(UART2))
            ;

        UARTSendDataByte(UART2, character);


        while(!UARTTransmissionHasCompleted(UART2))
            ;
}
Exemple #16
0
void UARTSendString(UART_MODULE uart, const char *string)
{
    while(*string)
    {
        if (UARTTransmitterIsReady(uart))//Case where it doesn't matter whether if or while because location is only incremented when the byte is sent
        {
            UARTSendDataByte(uart, *string);
            while(!UARTTransmissionHasCompleted(uart)){}
            string++; //increment through the string
        }
    }
}
Exemple #17
0
void serial_transmit(void) {
    if (uart_tx_buf_written < uart_tx_buf_writing) {
        if (UARTTransmitterIsReady(UART1)) { // If the transmitter can handle another byte
            UARTSendDataByte(UART1, uart_tx_buf[uart_tx_buf_written++]); // Send a single byte from the output buffer
            uart_tx_buf_size--; // One less byte in the buffer
        }
    } else {
        // No data in the buffer, so reset the index
        uart_tx_buf_written = 0;
        uart_tx_buf_writing = 0;
    }
}
Exemple #18
0
void serialPutc(unsigned char serialPortIndex, char c) {
    UART_MODULE uart = getUartModule(serialPortIndex);

    while (!UARTTransmitterIsReady(uart)) {
    
    }
    
    UARTSendDataByte(uart, c);

    while (!UARTTransmissionHasCompleted(uart)) {
    
    }
}
/*
*	Function Name:	void UARTiWriteString(void)
*	Description:	Writes a full string out the selected uart.
*	Initiator: 		Robert Scaccia
*	Date: 			10/19/2011
*/
void UARTiWriteString(const char *ccpString, UART_MODULE iUART)
{
    static int ready_high_water = 0, completed_high_water = 0;
    int ready_count = 0, completed_count = 0;
    while(*ccpString != '\0')
    {
        while(!UARTTransmitterIsReady(iUART)) ready_count++;
        UARTSendDataByte(iUART, *ccpString);
        ccpString++;
        while(!UARTTransmissionHasCompleted(iUART)) completed_count++;
    }

    if(ready_count     > ready_high_water)     ready_high_water     = ready_count;
    if(completed_count > completed_high_water) completed_high_water = completed_count;
}
// *****************************************************************************
// void UARTTxBuffer(char *buffer, UINT32 size)
// *****************************************************************************
void SendDataBuffer(const char *buffer, UINT32 size)
{
    while(size)
    {
        while(!UARTTransmitterIsReady(UART2))
            ;

        UARTSendDataByte(UART2, *buffer);

        buffer++;
        size--;
    }

    while(!UARTTransmissionHasCompleted(UART2))
        ;
}
Exemple #21
0
void WriteStringBluetooth2(const char *string)
{
    int i=0;
    while(i<17)
    {
        while(!UARTTransmitterIsReady(UART_MODULE_ID2));

        UARTSendDataByte(UART_MODULE_ID2, *string);

        string++;

        i++;

        while(!UARTTransmissionHasCompleted(UART_MODULE_ID2));
    }

}
Exemple #22
0
void vUART1_ISR( void )
{
    static portBASE_TYPE
                xHigherPriorityTaskWoken;
    UART_DATA   rx_data;
    static int  i = 0;

    if( INTGetFlag( INT_U1RX ) )
    {
        INTClearFlag( INT_U1RX );
        
        /*----------------------------------------------------------------------
            Rx interrupt functionality
        ----------------------------------------------------------------------*/
        rx_data = UARTGetData( TARGET_UART );
        rx_buffer = rx_data.__data;
        
        xHigherPriorityTaskWoken = xTaskResumeFromISR( rx_task_handle );

        xSemaphoreGiveFromISR( inputByteBuffer, &xHigherPriorityTaskWoken );
        
        // set Rx task to resume
        portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );
    }
    else
    {
        if( INTGetFlag( INT_U1TX ) )
        {
            INTClearFlag( INT_U1TX );

            /*------------------------------------------------------------------
                Tx interrupt functionality
            ------------------------------------------------------------------*/
            // transmit tx_buffer
            if( tx_buffer[ i ] != '\0' )
                UARTSendDataByte( TARGET_UART, tx_buffer[ i++ ] );
            else
            {
                i = 0;
                
                xHigherPriorityTaskWoken = pdFALSE;
                xSemaphoreGiveFromISR( outputStringBuffer, &xHigherPriorityTaskWoken );
            }
        }
    }
}
Exemple #23
0
int SendCharacter(int id, const char character)
{
    UART_MODULE uartX;
    switch(id)
    {
        case 1:
            uartX = UART1;
            break;
        case 2:
            uartX = UART2;
            break;
        case 3:
            uartX = UART3;
            break;
        case 4:
            uartX = UART4;
            break;
        default:
            uartX = UART1;
    }
    while(!UARTTransmitterIsReady(uartX));
    UARTSendDataByte(uartX, character);
    while(!UARTTransmissionHasCompleted(uartX));
}
Exemple #24
0
void uart_putc(BYTE ch)
{
    while(!UARTTransmitterIsReady(UART1));
    UARTSendDataByte(UART1, ch);
}
Exemple #25
0
// *****************************************************************************
// Send a character to the Console serial port
// *****************************************************************************
void putConsole(char c)
{
    while (!UARTTransmitterIsReady(UART_CONSOLE));

    UARTSendDataByte(UART_CONSOLE, c);
}
/*******************************************************************************
 * ISR: UART 2 Interrupt.
 *
 * DESCRIPTIONS:
 * Interrupt vector for UART 2.
 *
 *******************************************************************************/
void __ISR(_UART_2_VECTOR, IPL7AUTO) UART2Interrupt(void)
{
    unsigned char ucReceivedData;

    xSystemState.bBluetoothBusy = 1;


    // Rx interrupt.
    if (INTGetEnable(INT_U2RX) && INTGetFlag(INT_U2RX)) {
        INTClearFlag(INT_U2RX);

        // Read out all data available.
        while (UARTReceivedDataIsAvailable(UART2)) {
            // Read the received data.
            ucReceivedData = UARTGetDataByte(UART2);

            // Make sure there is empty space in the buffer.
            if ((prv_xRx.uiBufferSize - prv_xRx.uiDataCount) > 0) {

                // Copy the data to the buffer.
                prv_xRx.pucBuffer[prv_xRx.uiWritePt] = ucReceivedData;

                // Increase the write pointer and data count.
                prv_vIncPointer(&prv_xRx.uiWritePt, prv_xRx.uiBufferSize);
                prv_xRx.uiDataCount++;

                portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
                xSemaphoreGiveFromISR(xBluetoothRxSemaphore, &xHigherPriorityTaskWoken);
            }
            else {
                xSystemError.bBluetoothError = 1;
            }
        }
    }



    // Tx interrupt.
    if (INTGetEnable(INT_U2TX) && INTGetFlag(INT_U2TX)) {
        // Loop until the Tx buffer is fully filled.
        while (UARTTransmitterIsReady(UART2)) {
            // If there is data to transmit...
            if (prv_xTx.uiDataCount > 0) {
                // Shift in the data to the transmit buffer.
                UARTSendDataByte(UART2, prv_xTx.pucBuffer[prv_xTx.uiReadPt]);

                // Increase the read pointer and decrease the data count.
                prv_vIncPointer(&prv_xTx.uiReadPt, prv_xTx.uiBufferSize);
                prv_xTx.uiDataCount--;
            }

            // Else, disable the transmit interrupt.
            else {
                INTEnable(INT_U2TX, INT_DISABLED);
                break;
            }
        }
    }



    // Error Interrupt.
    if (INTGetEnable(INT_U2E) && INTGetFlag(INT_U2E)) {
        INTClearFlag(INT_U2E);

        // Discard all data available.
        while (UARTReceivedDataIsAvailable(UART2)) {
            // Read the received data.
            ucReceivedData = UARTGetDataByte(UART2);
        }

        // Clear the overrun flag.
        if (UARTGetLineStatus(UART2) & UART_OVERRUN_ERROR) {
            U2STAbits.OERR = 0;
        }

        xSystemError.bBluetoothError = 1;
    }

}
Exemple #27
0
// Put a character over the serial port, called by WriteString
void PutCharacter(UART_MODULE id, const char character) {
  while(!UARTTransmitterIsReady(id));
  UARTSendDataByte(id, character);
  while(!UARTTransmissionHasCompleted(id));
}
Exemple #28
0
/*******************************************************************************
  Function:
    void ConsoleUartIntHandler(void)

  Remarks:
 UART 1 interrupt handler is set at priority level 2 with software context saving
 */
void ConsoleUartIntHandler(void)
{
    unsigned char byteReceived;

    // Is this an RX interrupt?
    if (INTGetFlag(INT_SOURCE_UART_RX(UART_CONSOLE)))
    {
        while (UARTReceivedDataIsAvailable(UART_CONSOLE) != 0)
        {
            byteReceived = UARTGetDataByte(UART_CONSOLE);
            //Console Interrupt - In Self Test Mode
            if(self_TESTMode == TRUE)
            {
                ConsoleMsgCallback_selfTest();
            }
            //Console Interrupt - RN1723 Command Mode
            else if(RN_UartCmdMode == 1)
            {
                //Exit console mode if 'ESC'
                if(byteReceived == ESC)
                {
                    RN_UartCmdMode = FALSE;
                    RN_DATA_MODE();
                    memset(consoleMsg, '\0', sizeof(consoleMsg));
                }
                else
                {
                    while(!UARTTransmitterIsReady(UART_WIFLY));
                    UARTSendDataByte(UART_WIFLY, byteReceived);
                }

            }
            else
            {
                PIC32_ConsoleMode = TRUE;
                putConsole(byteReceived);
                if(byteReceived == CR)
                {
                    PrintConsoleMenu();
                }
                else if(byteReceived == LF)
                {
                    //Ignore Line Feed
                }
                else if(byteReceived == BACKSPACE)
                {
                    consoleMsg[(strlen(consoleMsg)-1)] = '\0';
                }
                else if(byteReceived == ESC)
                {
                    PIC32_ConsoleMode = FALSE;
                    memset(consoleMsg, '\0', sizeof(consoleMsg));

                }
                else
                {
                    consoleMsg[strlen(consoleMsg)] = byteReceived;
                }

            }

        }

        // Clear the RX interrupt Flag
        INTClearFlag(INT_SOURCE_UART_RX(UART_CONSOLE));
    }

    // We don't care about the TX interrupt
    if (INTGetFlag(INT_SOURCE_UART_TX(UART_CONSOLE)) )
    {
        INTClearFlag(INT_SOURCE_UART_TX(UART_CONSOLE));
    }
}
Exemple #29
0
void hal_uart_interrupt_handler(hal_uart_port port) {
    UART_MODULE uart = logic_uart2phy_uart(port);
    assert(port >= HAL_UART_PORT_1 && port <= HAL_UART_NUMBER_OF_PORTS );
    /* get the txbuffer to send */
    struct txbuffer_struct *buffer = get_tx_buffer(port);
    /* If the source of interrupt is the TXInterrupt, start
     * transmitting the data in output queue. */
    if (INTGetFlag(INT_SOURCE_UART_TX(uart))) {
        /* Clear interrupt to prevent reentry */
        INTClearFlag(INT_SOURCE_UART_TX(uart));
        /* if queue is not empty, send tx data to uart while available. */
        while (buffer->nbytes > 0) {
            if (UARTTransmitterIsReady(uart)) {
                UARTSendDataByte(uart, buffer->buffer[buffer->counter++]);
                /* decrement buffer count after byte was transmitted */
                buffer->nbytes --;
            } else {
                break;
            }
        }
        /* if queue is empty, disable tx interrupt. */
        if (buffer->nbytes <= 0) {
            INTEnable(INT_SOURCE_UART_TX(uart), INT_DISABLED);
            if(on_data_sent[port]!=NULL)
                on_data_sent[port](port);
        }
    }

    /* detect uart rx errors */
    if(INTGetFlag(INT_SOURCE_UART_ERROR(uart))){
        uint8_t in_byte = 0x00;
        hal_uart_error error = HAL_UART_ERR_NONE;
        volatile UART_LINE_STATUS  lineStatus = UARTGetLineStatus(uart);
        /* detect framming error. (break)*/
        /* Framing error are only valid if data is available in buffer. */
        if(UART_FRAMING_ERROR & lineStatus){
            /* trigger an on_data_received_callback */
            error = HAL_UART_ERR_FRAMMING;
        }
        /* detect uart overrun errors. */
        if(UART_OVERRUN_ERROR & lineStatus)
        {
            error = HAL_UART_ERR_OVERRUN;
            /* TODO: Not sure what to do if buffer overruns (it means data
             * arrives faster than we are able to process. So just
             * clear error and continue with our lives as nothing happened.
             */
            UARTClearOverrunError(uart);
        }
        if(UART_PARITY_ERROR & lineStatus){
            error = HAL_UART_ERR_PARITY;
        }
        if(UARTReceivedDataIsAvailable(uart)){
            in_byte = UARTGetDataByte(uart);
        }
        if(on_data_received[port]!=NULL)
            on_data_received[port](port,in_byte,error);
        /* clear the error flag. */
        INTClearFlag(INT_SOURCE_UART_ERROR(uart));
    }
    
    /* If receive interrupt was triggered, feed user apps with data. */
    if (INTGetFlag(INT_SOURCE_UART_RX(uart))) {
        /* Clear interrupt to prevent reentry */
        INTClearFlag(INT_SOURCE_UART_RX(uart));
        /* Copy the received data into input buffer */
        while (UARTReceivedDataIsAvailable(uart)) {
            uint8_t c = UARTGetDataByte(uart);
            if(on_data_received[port]!=NULL)
                on_data_received[port](port, c,HAL_UART_ERR_NONE);
        }
    }
}
Exemple #30
0
void __ISR(_UART_2_VECTOR, IPL5SOFT) UART2_isr(void)
{
   uint8_t ErrFiFoFull = 0;
   uint8_t freeSize, TXsize;
   int8_t c;
   uint8_t i_cts = 0;
   BOOL  TxPossible;

   UART_LINE_STATUS lineStatus;



    // Is this an RX interrupt ?
    if ( INTGetFlag(INT_U2RX) && INTGetEnable(INT_U2RX) ) {


        // oui Test si erreur comm
        lineStatus = UARTGetLineStatus(UART2);

        if ( (lineStatus & (UART_PARITY_ERROR | UART_FRAMING_ERROR |
                            UART_OVERRUN_ERROR)) == 0) {
             // transfert dans le fifo de tous les caractères recu
             while (UARTReceivedDataIsAvailable(UART2))
             {
                 c = UARTGetDataByte(UART2);
                 PutCharInFifo ( &descrFifoRX, c);
             }
             INTClearFlag(INT_U2RX); // buffer is empty, clear interrupt flag

        } else {
             UART2ClearAllErrors();   // Macro C32
        }

         freeSize = GetWriteSpace ( &descrFifoRX);
         if (freeSize <= 6 )        // a cause d'un int pour 6 char
         {
            // Demande de ne plus émettre
            //RS232_RTS = 1;

            if (freeSize == 0) {
                 ErrFiFoFull = 1;    // pour debugging si probème ctrl flux
            }
        }
    } // end if RX

    // Is this an TX interrupt ?
    if(INTGetFlag(INT_U2TX) && INTGetEnable(INT_U2TX)  ) {


         TXsize = GetReadSize (&descrFifoTX);
         // i_cts = input(RS232_CTS);
         // On vérifie 3 conditions :
         //    Si CTS = 0 (autorisation d'émettre)
         //    Si il y a un caratères à émettre
         //    Si le txreg est bien disponible

         //i_cts = RS232_CTS;

         TxPossible = UARTTransmitterIsReady(UART2);
         //if ( (i_cts == 0) && ( TXsize > 0 ) && TxPossible )  {
         if (  ( TXsize > 0 ) && TxPossible )  {
             do {
                 GetCharFromFifo(&descrFifoTX, &c);

                 UARTSendDataByte(UART2, c);
                 //i_cts = RS232_CTS;
                 TXsize = GetReadSize (&descrFifoTX);
                 TxPossible = UARTTransmitterIsReady(UART2);

             //} while ( (i_cts == 0) && ( TXsize > 0 ) && TxPossible  );
             } while (  ( TXsize > 0 ) && TxPossible  );
            // Clear the TX interrupt Flag (Seulement aprés TX)
            INTClearFlag(INT_U2TX);
        } else {
           // disable TX interrupt
           INTEnable(INT_U2TX, INT_DISABLED);
        }
    }
} // UART_isr