util.c

Go to the documentation of this file.

/*
       File: util.h
 Programmer: Ricardo Castro
Description: some util stuff for comunication and other propose
   revision: 0.06
*/

#include <stdlib.h> 
#include <ctype.h>
#include "util.h"

/******************************************************************
* USART_Init
*
* Args: unsigned int uiBaud = Baund Rate
*           unsigned char ucConf = configuration mask
* Description: Initialize USART, wiht baud and ucConf
*
*******************************************************************/
void USART_Init(unsigned int uiBaud, unsigned char ucConf)
{
  UCSRB = 0;                            //disable while setting baud rate
  
  UBRRH = (unsigned char)(uiBaud>>8);
  UBRRL = (unsigned char)uiBaud;
    
  UCSRC = (1<<URSEL)|ASYNC_MODE| ucConf; 
  // URSEL is necessary for accessing register UCSRC
  
  UCSRB = (1<<RXEN)|(1<<TXEN); // Rx enable Tx Enable
}

/******************************************************************
* TxChar
*
* Args: unsigned Char ucData = data to transmit
* Description: transmit(when possible) ucData
******************************************************************/
void TxChar( unsigned char ucData)
{
   while ( !( UCSRA & (1<<UDRE)) )  /* Wait for empty transmit buffer */
       ;
           
   UDR = ucData; /* Put data into buffer, sends the data */
}

/******************************************************************
* TxStr
*
* Args: const char * strBuff = String buffer to send
* Description: transmit(when possible) strBuff(end with '\0'
******************************************************************/
void TxStr(const char * strBuff)
{
        uint8_t i=0;
        
        while( '\0'!=strBuff[i] ){         // while not end of string
                TxChar(strBuff[i]);   // send char  
                i++;                                               // next char
        }
}

/******************************************************************
* _TxStr_P
* (This is a internal funcion that should not be called. 
*  Please use TxStr_P macro)
*
* Args: const char * str_flash = pointer to flash memory where the string is stored
*
* Description: Transmit(when possible) str_flash (end with '\0'). The string
* must be defined on Flash memory. 
******************************************************************/
void _TxStr_P(const char *str_flash)
{
  char c;

  while ('\0' != ( c = pgm_read_byte(str_flash++) ) )
                TxChar(c);
}

/******************************************************************
* TxUint
*
* Args: uint16_t number = unsigned int (16 bits) to send
* Description: transmit(when possible) unsigned integer (16 bits)
*******************************************************************/
void TxUint(uint16_t number)
{
  char str[8];
  itoa(number, &str[0],10); // the last argument is the base
  TxStr(&str[0]);
}

/******************************************************************
* TxEol
*
* Description: Transmit end of line
******************************************************************/
void TxEol(void)
{
        TxChar('\n');
        TxChar(13);
}

/******************************************************************          
* RxChar
*
* Description: return received byte
******************************************************************/
unsigned char RxChar( void )
{
        /* Wait for data to be received */
        while ( !(UCSRA & (1<<RXC)) )
                ;
        /* Get and return received data from buffer */
        return UDR;
}

/******************************************************************          
* TxHex
* 
* Args: unsigned char ucData = data to send
* Description: Send the byte in hexadecimal format
******************************************************************/
void TxHex(unsigned char ucData){
        unsigned char tmp;
        TxChar('0');
        TxChar('x');
        tmp = (ucData>>4)&0x0F;  // get the msb nibble          
        if(tmp < 0x0a){             // numeric value
                TxUint(tmp);
        }
        else{                                           // alfa-numeric value
                TxChar(0x61 + tmp - 0x0a);
        }
        tmp = ucData&0x0F;                      // get the lsb nibble   
        if(tmp < 0x0a){
                TxUint(tmp);
        }
        else{
                TxChar(0x61 + tmp - 0x0a);
        }
                
}

// util stuff

/******************************************************************
* delay
*
* Args: unsigned int(16 bits) d = delay in ms
* Descritpion: delay at least d miliseconds with clock frequency
*              around 14.7456Mhz
*
******************************************************************/
void delay(uint16_t d){
        uint16_t i;
        
        for(i=0; i<d; i++)
                _delay_loop_2(3685); // _delay loop=~ d*4+3+4cycles
                                                          // (3685 * 4 +7)/14745600=~1ms
}
/******************************************************************
* delay_u
*
* Args: unsigned int(16 bits) d = delay in us
* Descritpion: delay at least d microseconds with clock frequency
*              around 14.7456Mhz
*
******************************************************************/
void delay_u(uint16_t d){
        uint16_t i;
        
        for(i=0; i<d; i++)
                _delay_loop_2(2); // _delay loop=~ d*4+3+4cycles
                                                          // ( * 4 +7)/14745600=~1us
}

---