uart.c

Ir a la documentación de este archivo.

//******************************************************************************
//  Nombre:       uart.c
//  Versión:      1.0
//  Descripción:  Módulo encargado de transmitir y recibir los datos. Es la capa
//                física del sistema que permite la interacción entre el módulo gsm
//                y el microcontrolador.
//                Incluye funciones para poder elegir el caracter deseado, y la cantidad
//                de veces que tiene que aparecer, para considerar el mensaje como completo.
//                Además, tiene funciones que se encargan de toda la inicialización,
//                así también como del envío de datos.
//  Autores:      Juan Martín Ortega, Ramiro Barrón, Andrea Cukerman
//                IIE, Facultad de Ingeniería, UdelaR
//                Uruguay
//  Fecha:        Junio 2012
//******************************************************************************

#include <stdio.h>
#include <string.h>
#include <stdio.h>
#include "uart.h"

#define P3TXD0 4 
#define P3RXD0 5 
static char eofl;

static int number_eofl;

static int eofl_RX;

static buffer TXbuffer;

static int flagRX;

static int flagTX;


buffer RXbuffer;

void initUART()
  {
  P3OUT |= (1 << P3TXD0);                    // Se configura puerto de UART
  P3DIR |= (1 << P3TXD0);
  P3SEL |= (1 << P3TXD0 | 1 << P3RXD0);

  UCA0CTL1 = UCSSEL_2;                       // Se selecciona SMCLK como reloj de USCI A0 
  UCA0BR0 = 104;                             
  UCA0BR1 = 0;                               // 1MHz 9600
  UCA0MCTL = UCBRS0;                         // Modulation UCBRSx = 1
  UCA0CTL1 &= ~UCSWRST;                      // Se inicializa máquina de estados de USCI
  IE2 |= UCA0RXIE;                           // Se habilitan interrupciones de RX
  }// end initUART()

void init_UART()
  {
  flagTX = 0;                     // Resetea bandera de transmisión
  flagRX = 0;                     // Resetea bandera de recepción
  TXbuffer.indice = 1;            // Setea índice de transmisión en 1
  RXbuffer.indice = 0;            // Setea índice de recepción en 1
  initUART();                     // Inicializa la UART
  }//end init_UART()

void set_eofl(char end_of_line)
  {
  eofl = end_of_line;       // Configura el caracter de fin de trama.
  }// end set_eofl(char end_of_line)

void set_number_eofl(int number_end_of_line)
  {
  number_eofl = number_end_of_line;     // Configura la cantidad de fin de trama a esperar.
  }// end set_number_eofl(int number_end_of_line)

#pragma vector = USCIAB0RX_VECTOR
__interrupt void ISR_Rx()
  {
  if(UCA0RXBUF == eofl) eofl_RX++;                                          // Verifica si el caracter recibido es el definido como fin de trama. Si lo es, incrementa el contador de finales de trama
  RXbuffer.datos[RXbuffer.indice] = UCA0RXBUF;                              // Copia al buffer de recepción el caracter recibido
  RXbuffer.indice++;                                                        // Incrementa el índice del buffer de recepción
  if((RXbuffer.indice==8) && !strncmp(RXbuffer.datos, "\r\nRING\r\n", 8))   // Se comprueba que lo recibido no sea a raiz de una llamada de voz.
    {                                                                       // Si lo fue, se descarta el mensaje, 
    RXbuffer.indice = 0;                                                    // se resetea el índice, y 
    eofl_RX = 0;                                                            // el contador de finales de trama.
    }
  if(number_eofl == eofl_RX)                                                // Verifica si la cantidad de finales de trama recibidas es la esperada
    {                                                                       // SI LO ES
    flagRX = 1;                                                             // Se levanta la bandera de recepción indicando que hay un mensaje, 
    eofl_RX = 0;                                                            // Se resetea el contador de finales de trama
    RXbuffer.datos[RXbuffer.indice] = (char)0x00;                           // Se agrega el caracter NULL
    RXbuffer.indice = 0;                                                    // Se resetea el índice del buffer de recepción
    }
  }//end ISR de RX

#pragma vector = USCIAB0TX_VECTOR
__interrupt void ISR_Tx()
  {    
  if (TXbuffer.datos[TXbuffer.indice] == 0x00)    // Verfica si el caracter a transmitir es el caracter NULL
    {                                             // SI ES EL CARACTER NULL
    TXbuffer.indice = 1;                          // Setea el índice de transmisión en uno
    IE2 &= ~UCA0TXIE;                             // Deshabilita interrupciones de transmisión
    flagTX = 1;                                   // Prende la bandera de transmisión
    }
  else
    {                                             // SI NO ES EL CARACTER NULL
    UCA0TXBUF = TXbuffer.datos[TXbuffer.indice];  // Carga en el registro de transmisión el caracter a transmitir
    TXbuffer.indice++;                            // Incrementa el índice de transmisión
    }
  }//end ISR de TX

void cargarTXbuffer(char *string1)
  {
  strcpy(TXbuffer.datos, string1);      // Carga el buffer de transmisión con la cadena a enviar
  UCA0TXBUF = TXbuffer.datos[0];        // Envía el primer caracter
  IE2 |= UCA0TXIE;                      // Habilita interrupciones de transmisión
  }//end cargarTXbuffer()

int get_flagRX()
  {
  return flagRX;        // Devuelve bandera de recepción
  }//end get_flagRX()

void reset_flagRX()
  {
    flagRX = 0;         // Resetea la bandera de recepción
  }// end reset_flagRX()