AVR Z-LINK®

serialPortHAL.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
/* === Includes ============================================================ */
#include"serialPortHAL.h"
/* ==== Macros ============================================================= */
/* === Typedefs ============================================================ */
/* === Variables =========================================================== */
rxDataBlock_t rxData;
rxState_t rxState;

const unsigned char __flash OK[ ] = "OK\r\n";

const unsigned char __flash ERROR[] = "ERROR: 0x";

const unsigned char __flash ASSOCIATION_NOTIFICATION[] = "+N";

const unsigned char __flash DISASSOCIATION_NOTIFICATION[] = "+D";

const unsigned char __flash NEW_DATA_NOTIFICATION[] = "+T: ";

const unsigned char __flash CRNL[]      = "\r\n";

const uint8_t __flash hexTable[] = "0123456789ABCDEF";

/* === Prototypes ========================================================== */
static void sendSymbol( const unsigned char symbol );
static void sendStringWithLength( const unsigned char *string, const uint8_t strLength );
static uint8_t errToHex( uint8_t hexNibble );
/* === Implementation ====================================================== */

void serialInterfaceInitialization( void ){
  
#ifdef UART
        
        uartInitialization( BR_38400 );
#else
        ftdiInitialization( );
#endif
}


void rxReset( void ){
        
        unsigned char dummy = 0x00;
        
        RECEIVER_OFF;
        
        rxState = SOC;
        
        rxData.rx_i = dummy;
        rxData.ATCommand[ rxData.rx_i ] = dummy;
        rxData.parameters[ rxData.rx_i ] = dummy;
        rxData.numberOfReceivedParameters = dummy;
        rxData.receptionComplete = false;
        rxData.error = NO_ERROR;

#ifdef UART     
        //Following loop is used to ensure that the rx FIFO is flushed.
        //Sometimes it gets cloged up with old data.
        for( ;  UCSR0A & ( 1 << RXC0 ); ){
                
                dummy = UDR0;  
        }
#endif

        RECEIVER_ON;
}

unsigned char * getATCommand( void ){

        return  ( unsigned char * )rxData.ATCommand;
}

rxError_t getError( void ){

        return rxData.error;
}


bool dataAvailable( void ){

        return rxData.receptionComplete;
}

unsigned char * getParameterNumber( paramter_t parameterNumber ){
        
        if( parameterNumber < NUMBER_OF_PARAMETERS ){
  
                return rxData.parameter[ parameterNumber ];
        }
  
  
        else{
  
                return NULL_PARAMETER;
        }
}

#pragma inline
static void sendSymbol( const unsigned char symbol ){
        
#ifdef UART
        
        uartSendSymbol( symbol );
#else
        ftdiSendSymbol( symbol );
#endif
}


void sendString( const unsigned char *string ){

  for( ; *string != '\0'; ){
    
        sendSymbol( *string++ );
        }

        return;
}

void sendFlashString( const unsigned char __flash *string ){

  for( ; *string != '\0'; ){
    
    sendSymbol( *string++ );
  }

  return;
}


void sendOK( void ){

  sendFlashString( OK );

  return;
}



void sendERROR( const chatError_t err ){

        sendFlashString( ERROR );
          
        //Convert from err to ascii hex:
        sendSymbol( errToHex( (err & 0xF0) >> 4 ) );    //MSB
        sendSymbol( errToHex( err & 0x0F ) );   //LSB
        
        sendFlashString( CRNL );

        return;
}


static uint8_t errToHex( uint8_t hexNibble ){

        return hexTable[ hexNibble ];
}

void sendAssociationNotification( void ){
        
        sendFlashString( ASSOCIATION_NOTIFICATION );
        sendFlashString( CRNL );

        return;
}

void sendDisAssociationNotification( void ){
        
        sendFlashString( DISASSOCIATION_NOTIFICATION );
        sendFlashString( CRNL );

        return;
}


void sendDataNotification( uint8_t length, unsigned char *data ){
        
        uint8_t i, ii, dataLength;
        unsigned char valueReversed[ 3 ];
        unsigned char asciiValue[ 4 ];
        
        dataLength = length;
        
        //Make sure that only 3 iterations are made.
        for( i = ii = 0; (ii < 3) && ( dataLength != 0 ) ; ii++ ){
        
                i = dataLength % 10;
                dataLength = dataLength / 10;
                
                valueReversed[ ii ] = i + '0';
        }
        
        asciiValue[ ii ] = '\0';        //Terminate string
        
        //Reverse the order of digits.
        for( i = 0, ii; ii > 0 ; ii--, i++ ){
        
                asciiValue[ i ] = valueReversed[ ii - 1 ];  
        }
        
        
        sendFlashString( NEW_DATA_NOTIFICATION );
        sendString( asciiValue );
        //sendStringWithLength( asciiValue, length );   //Dummy...hardcoded.
        sendSymbol( ',' );
        sendStringWithLength( data, length );
        sendFlashString( CRNL );

        return;
}

static void sendStringWithLength( const unsigned char *string, const uint8_t strLength ){
  
  uint8_t i;
  
  for( i = 0; i < strLength; i++ ){
    
    sendSymbol( *string++ );
  }

  return;
}

#ifdef UART
        ISR( USART0_RX_vect ){
        
        uint8_t receivedData;
        
        receivedData = ( uint8_t )UDR0; //Collect data.
#else
        ISR( INT7_vect ){
          
        unsigned char receivedData;
        
        receivedData = ( uint8_t )*FTDI_Fifo;   //Collect data.
#endif

        switch( rxState ){
        
                case SOC:
                  
                  if( rxData.rx_i <= LENGTH_OF_COMMAND ){
                        
                        if( receivedData == PARAMETER_PREAMBLE_A ){
                                
                                rxData.ATCommand[ rxData.rx_i ] = '\0';
                                rxState = PARAM_PREAMBLE;
                        }
                        
                        else if( receivedData == EOC_DELIMITER ){
                                
                                rxData.ATCommand[ rxData.rx_i ] = '\0';
                                rxState = EOC;
                        }
                        
                        else{
                        
                                rxData.ATCommand[ rxData.rx_i++ ] = receivedData;  
                        }
                  }
                  
                  else{
                  
                        RECEIVER_OFF;
                        rxData.error = BUFFER_OVERFLOW;
                        rxData.receptionComplete = true;                
                  }
                
                break;
                
                case PARAM_PREAMBLE:
                  
                  if( receivedData == PARAMETER_PREAMBLE_B ){
                        
                        rxData.rx_i = 0;
                        rxData.parameter[ rxData.numberOfReceivedParameters++ ] = \
                                          &rxData.parameters[ rxData.rx_i ];
                        rxState = COLLECT_PARAMETERS;
                  }
                  
                  else{
                  
                        RECEIVER_OFF;
                        rxData.error = UNKNOWN_SEQUENCE;
                        rxData.receptionComplete = true;                                
                  }
                  
                break;
                
                case COLLECT_PARAMETERS:
                        
                  
                        if( ( rxData.rx_i < LENGTH_OF_PARAMETER_BUFFER )&& 
                                ( rxData.numberOfReceivedParameters < NUMBER_OF_PARAMETERS ) )
                        {
                        
                                if( receivedData == PARAMETER_DELIMITER ){
                          
                                        rxData.parameters[ rxData.rx_i++ ] = '\0';
                                        rxData.parameter[ rxData.numberOfReceivedParameters++ ] = \
                                          &rxData.parameters[ rxData.rx_i ];
                                }
                                
                                
                                else if( receivedData == EOC_DELIMITER ){
                                        
                                        rxData.parameters[ rxData.rx_i ] = '\0';
                                        rxState = EOC;
                                }
                                
                                else{
                        
                                        rxData.parameters[ rxData.rx_i++ ] = receivedData;  
                                }
                  }
                  
                  else{
                  
                        RECEIVER_OFF;
                        rxData.error = BUFFER_OVERFLOW;
                        rxData.receptionComplete = true;                
                  }  
                break;
                
                case EOC:
                        
                        RECEIVER_OFF;
                        
                        if( receivedData != '\n' ){
                        
                                rxData.error = UNKNOWN_EOC_SEQUENCE;  
                        }
                        
                        rxData.receptionComplete = true;
                break;
                
                default:
                        
                        RECEIVER_OFF;
                        rxData.error = UNKNOWN_RX_STATE;
                        rxData.receptionComplete = true;
                break;
        }
}