Hello there. Iám New to MSP430 Microcontrollers. So facing many difficulties in building my project. After tons of problem solving in CCSV 6.1. Iám recently facing with error as, MSP430: GEL: Encountered a problem loading file Could not open file. Please help.
//******************************************************************************
// MSP430x5xx Demo - Software Toggle P1.0
//
// Description; Toggle P1.0 by xor'ing P1.0 inside of a software loop.
// ACLK = n/a, MCLK = SMCLK = default DCO
//
// MSP430FR59xx
// -----------------
// /|\| XIN|-
// | | |
// --|RST XOUT|-
// | |
// | P1.0|-->LED
//
// M. Pfeiffer
// Texas Instruments, Inc
// August 2013
// Built with IAR Embedded Workbench Version: 5.52.1
//******************************************************************************
#include "msp430.h"
#include "math.h"
#include "BCUart.h"
#include <stdlib.h>
#include <strings.h>
#include <stdio.h>
uint8_t bcUartRcvBuf[BC_RXBUF_SIZE];
uint16_t bcUartRcvBufIndex = 0;
uint8_t bcUartRxThreshReached = 0;
#define WRITE 0x00
#define READ 0x80
#define MULTIBYTE_TRANSFER 0x40
#define BW_RATE_REGISTER 0x2c
#define NO_POWER_SAVING 0x00
#define HZ6_25 0x06
#define DATA_FORMAT_REGISTER 0x31
#define DATA_FORMAT_VALUE 0x8b
#define FIFO_CONTROL_REGISTER 0x38
#define FIFO_CONTROL_VALUE 0x00
#define DATA_REG 0x32
#define POWER_CONTROL_REGISTER 0x2d
#define POWER_CONTROL_VALUE 0x08
#define INT_ENABLE_REGISTER 0x2e
#define INT_ENABLE_VALUE 0x80
#define INT_MAP_REGISTER 0x2f
#define INT_MAP_VALUE 0x7f
#define SIGN_BIT 9
#define ACCEL_MASK 0x01ff
char DATAX0 = 0x32; //X-Axis Data 0
char DATAX1 = 0x33; //X-Axis Data 1
char DATAY0 = 0x34; //Y-Axis Data 0
char DATAY1 = 0x35; //Y-Axis Data 1
char DATAZ0 = 0x36; //Z-Axis Data 0
char DATAZ1 = 0x37; //Z-Axis Data 1
unsigned char key1,key2,byte;
unsigned char data[10];
unsigned int vectors[3];
float scale_x,scale_y,scale_z;
double ANGLE_x,ANGLE_y,ANGLE_z;
unsigned char calibration_flag;
int calibration_timer,sample_1;
void transmit(unsigned char a);
void putText(char *t);
void transmit_on_serial(void);
int array1[100],j;
unsigned char dis_data[5];
void send(void);
void init_devices(void);
void clock_init(void);
void timera_init(void);
void spi_init(void);
unsigned char SPI_RW(unsigned char ch);
void init_adxl(void);
void setup_accelerometer(void) ;
void adc_init(void);
void uart0_9600_init(void);
void init_cc2500(void);
void read_adxl(void);
void read_accel(void);
void process_adxl(void);
void calibrate_accel(void);
void delay_ms(uint16_t x);
void display_x();
void conversion(unsigned int temp_data);
long BackChannel_BaudRate;
#define cs1 BIT7
#define cs1_hi() (P2OUT |= cs1);
#define cs1_lo() (P2OUT &= ~cs1);
#define cs2 BIT0
#define cs2_hi() (P4OUT |= cs1);
#define cs2_lo() (P4OUT &= ~cs1);
char init_msg[] = "Wireless Sensor Network #";
double Rt,vout,temprature;
int main(void)
{
calibration_flag = 1;
WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer
PMMCTL0 = PMMPW; // Open PMM Module
PM5CTL0 &= ~LOCKLPM5; // Clear locked IO Pins
P1DIR |= 0x01; // Set P1.0 to output direction
P1DIR &= ~BIT1; // Set P1.1 to input
init_devices();
void bcUartInit(void);
__enable_interrupt();
putText(&init_msg[0]);
cs2_lo();
SPI_RW2(0x34); // Receive data SRX Command
cs2_hi();
char *str1 ="SLAVE1";
if(UCB1RXBUF == *str1)
{
void send(void);
}
else if(P2IN & BIT3==0)
{
void receive(void);
}
else{}
void BackChannel_Write(char text[]);
}
void send(void)
{
for(;;)
{
volatile unsigned int i; // volatile to prevent optimization
P1OUT ^= 0x01; // Toggle P1.0 using exclusive-OR
i = 10000; // SW Delay
do i--;
while (i != 0);
vout = 3.3 * sample_1 / 4095;
Rt = (3.3 * 3300 / vout) - 3300;
temprature = 1/ ((0.0014 + 0.000237 * (log(Rt)/log(2.718))) + 0.000000099 * (log(Rt)/log(2.718))* (log(Rt)/log(2.718))* (log(Rt)/log(2.718)));
temprature = (temprature - 32)/1.8;
display_x();
char *str2="HALT";
if(UCB1RXBUF==*str2)
{
break;
}
}
}
void init_devices(void)
{
timera_init();
spi_init();
init_adxl();
adc_init();
init_cc2500(); // Initialise cc2500
}
/*____________________________________________________________________________*/
//timera_init(): Intialise timer-A for 10ms interval with 8MHz crystal
/*____________________________________________________________________________*/
void timera_init(void)
{
/* Configure Timer A to trigger interrupt once per second */
TA0CCTL0 = CCIE; // Timer 0 TA0CCR0 interrupt enabled
TA0CCR0 = 40000; // 10ms interval
TA0CTL = TASSEL_2 + ID_1 + MC_1; // Start TimerA, SMCLK,/2 clock, Up mode
}
/*____________________________________________________________________________*/
// Interrupt Service Routines --- 10ms Timer-A0 ISR
/*____________________________________________________________________________*/
#pragma vector=TIMER0_A0_VECTOR
__interrupt void TimerA0_ISR(void)
{
P7SEL &= ~BIT4;
P7DIR &= ~BIT0;
if(P7IN & BIT4==0)
{
read_accel();
calibration_timer++;
if(calibration_timer>10 && calibration_flag==1)
{
calibration_timer = 0;
calibration_flag = 0;
calibrate_accel();
}
array1[j] = sample_1;
j++;
if(j>10)
j=0;
}
}
void transmit(unsigned char a)
{
// while (!(UCA1IFG&UCTXIFG)); // USCI_A0 TX buffer ready?
// UCA0TXBUF = a; // TX -> RXed character
// while (!(UCA1IFG&UCTXIFG)); // USCI_A0 TX buffer ready?
//If interrupts are not used, poll for flags
//if (!( UCA0IE) & UCTXIE))
//Poll for transmit interrupt flag
while (!(UCB1IFG&UCTXIFG));
UCB1TXBUF = a;
}
/*____________________________________________________________________________*/
// Echo back RXed character, confirm TX buffer is ready first
/*____________________________________________________________________________*/
#pragma vector=USCI_A0_VECTOR
__interrupt void USCI_A0_ISR(void)
{
switch(__even_in_range(UCA0IV,4))
{
case 0:break; // Vector 0 - no interrupt
case 2: // Vector 2 - RXIFG
// do_seperation();
while (!(UCA0IFG&UCTXIFG)); // USCI_A0 TX buffer ready?
UCA0TXBUF = UCA0RXBUF; // TX -> RXed character
while (!(UCA0IFG&UCTXIFG)); // USCI_A0 TX buffer ready?
break;
case 4:break; // Vector 4 - TXIFG
default: break;
}
}
/*____________________________________________________________________________*/
//spi_init():Intialise SPI.SPI is working on 8MHz.
/*____________________________________________________________________________*/
void spi_init(void)
{
/*
//P2.7 UCA0CLK
//P3.2 UCA0STE
//P3.0 UCA0SIMO
//P3.1 UCA0SOMI
//P2.5/TA2.2
cs1_lo();
P3SEL |= BIT0 + BIT1 + BIT2;
P2SEL |= BIT7;
P3DIR |= BIT0 + BIT2;
P2DIR |= BIT7;
P3DIR &= ~BIT1;
cs1_hi();
UCB0CTL1 |= UCSWRST;
UCB0CTL0 = 0xE9;//UCCKPH + UCCKPL + UCMSB + UCMST + UCMODE1 + UCSYNC + UCSSEL_1;
UCB0CTL1 |= 0x80;
UCB0BR0 = 1;//same as system clock
UCB0CTL1 = 0;
UCB0CTL1 &= ~UCSWRST;
*/
//P4.0 PM_UCB1STE
//P4.1 PM_UCB1SIMO
//P4.2 PM_UCB1SOMI
//P4.3 PM_UCB1CLK
cs2_lo();
P4SEL |= BIT0 + BIT1 + BIT2 + BIT3 ;
P4DIR |= BIT0 + BIT1 + BIT3;
P4DIR &= ~BIT2;
cs2_hi();
UCB1CTL1 |= UCSWRST;
UCB1CTL0 = 0xE9;//UCCKPH + UCCKPL + UCMSB + UCMST + UCMODE1 + UCSYNC + UCSSEL_1;
UCB1CTL1 |= 0x80;
UCB1BR0 = 1;//same as system clock
UCB1CTL1 = 0;
UCB1CTL1 &= ~UCSWRST;
}
unsigned char SPI_RW(unsigned char ch)
{
unsigned char d;
// UCB0TXBUF = ch; //write
// while(!(UCB0IFG & UCTXIFG));
// while(!(UCB0IFG & UCRXIFG)); //read
// d = UCB0RXBUF;
UCB0TXBUF = ch; //write
while(!(UCB0IFG & UCTXIFG));
while(!(UCB0IFG & UCRXIFG)); //read
d = UCB0RXBUF;
return(d);
}
unsigned char SPI_RW2(unsigned char ch)
{
unsigned char d;
// UCA1TXBUF = ch; //write
// while(!(UCA1IFG & UCTXIFG));
// while(!(UCA1IFG & UCRXIFG)); //read
// d = UCA1RXBUF;
UCB1TXBUF = ch; //write
while(!(UCB1IFG & UCTXIFG));
while(!(UCB1IFG & UCRXIFG)); //read
d = UCB1RXBUF;
return(d);
}
void init_adxl(void)
{
cs1_lo();
SPI_RW(0x0A); // command write
SPI_RW(0x2D); // address
SPI_RW(0x0C); // data (Standby Mode)
cs1_hi();
cs1_lo();
SPI_RW(0x0A); // command write
SPI_RW(0x20); // address
SPI_RW(0xFA); // data
cs1_hi();
cs1_lo();
SPI_RW(0x0A);
SPI_RW(0x21);
SPI_RW(0x00);
cs1_hi();
cs1_lo();
SPI_RW(0x0A);
SPI_RW(0x23);
SPI_RW(0x96);
cs1_hi();
cs1_lo();
SPI_RW(0x0A);
SPI_RW(0x24);
SPI_RW(0x00);
cs1_hi();
cs1_lo();
SPI_RW(0x0A);
SPI_RW(0x25);
SPI_RW(0x1E);
cs1_hi();
cs1_lo();
SPI_RW(0x0A);
SPI_RW(0x22);
SPI_RW(0xC8);
cs1_hi();
cs1_lo();
SPI_RW(0x0A);
SPI_RW(0x27);
SPI_RW(0x3F);
cs1_hi();
cs1_lo();
SPI_RW(0x0A);
SPI_RW(0x28);
SPI_RW(0x07);
cs1_hi();
cs1_lo();
SPI_RW(0x0A);
SPI_RW(0x29);
SPI_RW(0x04);
cs1_hi();
cs1_lo();
SPI_RW(0x0A);
SPI_RW(0x2A);
SPI_RW(0xD7);
cs1_hi();
cs1_lo();
SPI_RW(0x0A);
SPI_RW(0x2C);
SPI_RW(0x83);
cs1_hi();
cs1_lo();
SPI_RW(0x0A);
SPI_RW(0x2D);
SPI_RW(0x0E); // Measurement Mode
cs1_hi();
}
void init_cc2500(void) // configuring CC2500
{
cs2_lo();
SPI_RW2(0x00); // address
SPI_RW2(0x29); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x01); // address
SPI_RW2(0x2E); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x02); // address
SPI_RW2(0x06); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x03); // address
SPI_RW2(0x07); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x04); // address
SPI_RW2(0xD3); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x05); // address
SPI_RW2(0x91); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x06); // address
SPI_RW2(0xFF); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x07); // address
SPI_RW2(0x04); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x08); // address
SPI_RW2(0x05); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x09); // address
SPI_RW2(0x00); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x0A); // address
SPI_RW2(0x03); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x0B); // address
SPI_RW2(0x0A); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x0C); // address
SPI_RW2(0x00); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x0D); // address
SPI_RW2(0x5D); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x0E); // address
SPI_RW2(0x44); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x0F); // address
SPI_RW2(0xEC); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x10); // address
SPI_RW2(0x2D); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x11); // address
SPI_RW2(0x3B); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x12); // address
SPI_RW2(0x73); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x13); // address
SPI_RW2(0x23); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x14); // address
SPI_RW2(0x3B); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x15); // address
SPI_RW2(0x01); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x16); // address
SPI_RW2(0x07); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x17); // address
SPI_RW2(0x30); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x18); // address
SPI_RW2(0x18); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x19); // address
SPI_RW2(0x1D); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x1A); // address
SPI_RW2(0x1C); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x1B); // address
SPI_RW2(0xC7); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x1C); // address
SPI_RW2(0x00); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x1D); // address
SPI_RW2(0xB0); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x1E); // address
SPI_RW2(0x87); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x1F); // address
SPI_RW2(0x6B); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x20); // address
SPI_RW2(0xF8); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x21); // address
SPI_RW2(0xB6); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x22); // address
SPI_RW2(0x10); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x23); // address
SPI_RW2(0xEA); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x24); // address
SPI_RW2(0x0A); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x25); // address
SPI_RW2(0x00); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x26); // address
SPI_RW2(0x11); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x27); // address
SPI_RW2(0x41); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x28); // address
SPI_RW2(0x00); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x29); // address
SPI_RW2(0x59); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x2A); // address
SPI_RW2(0x7F); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x2B); // address
SPI_RW2(0x3F); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x2C); // address
SPI_RW2(0x88); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x2D); // address
SPI_RW2(0x31); // data
cs2_hi(); cs2_lo();
SPI_RW2(0x2E); // address
SPI_RW2(0x0B); // data
cs2_hi();
}
void receive(void) // receive data wirelessly
{
for(;;)
{
cs2_lo();
SPI_RW2(0xFF); // Read Address
SPI_RW2(0x00); // dummy Data byte to read
cs2_hi();
cs2_lo();
SPI_RW2(0x3A); // FLUSH rxfifo
cs2_hi();
cs2_lo();
SPI_RW2(0x36); // turn cc2500 into idle
cs2_hi();
cs2_lo();
SPI_RW2(0x33); // calibrate cc2500
cs2_hi();
if(P2IN & BIT3==1)
break;
}
}
void read_adxl(void)
{
unsigned int i;
cs1_lo();
SPI_RW(0xF2);
for(i=0; i<6; i++)
{
SPI_RW(0x00);
data[i] = UCB0RXBUF; //Digital output data is formatted as 16-bit twos complement
}
cs1_hi();
vectors[0] = (((unsigned int)data[1]<<8)|(unsigned int)data[0]);
vectors[0] = (~vectors[0] & 0x1FFF) +1;
vectors[1] = (((unsigned int)data[3]<<8)|(unsigned int)data[2]);
vectors[1] = (~vectors[1] & 0x1FFF) +1;
vectors[2] = (((unsigned int)data[5]<<8)|(unsigned int)data[4]);
vectors[2] = (~vectors[2] & 0x1FFF) +1;
process_adxl();
}
void read_accel(void)
{
cs1_lo();
delay_ms(5);
SPI_RW(READ | MULTIBYTE_TRANSFER | DATA_REG);
vectors[0] = SPI_RW(0); // x low byte
vectors[0] = vectors[0] | (SPI_RW(0) << 8); // x high byte
vectors[1] = SPI_RW(0); // y low byte
vectors[1] = vectors[1] | (SPI_RW(0) << 8); // y high byte
vectors[2] = SPI_RW(0); // z low byte
vectors[2] = vectors[2] | (SPI_RW(0) << 8); // z high byte
delay_ms(5);
cs1_hi();
delay_ms(5);
process_adxl();
}
#define scale_factor 3.9072 // 0.0039072
void process_adxl(void)
{
int neg_x = 0,neg_y = 0, neg_z = 0;
neg_x = ( vectors[0] & 0x1FFF )- 4095;
scale_x = (float)neg_x * scale_factor;
neg_y = (vectors[1] & 0x1FFF)- 4095;
scale_y = (float)neg_y * scale_factor;
neg_z = (vectors[2] & 0x1FFF)- 4095;
scale_z = (float)neg_z * scale_factor;
// ANGLE_x = asin((scale_x*180)/3.14);
//ANGLE_y = asin((scale_y*180)/3.14);
// ANGLE_z = sin((scale_z*180)/3.14);
//convert accelerometer value to G
}
void calibrate_accel(void) {
cs1_lo();
SPI_RW(0x1E);
SPI_RW(vectors[0]);
SPI_RW(vectors[0]>>8);
cs1_hi();
cs1_lo();
SPI_RW(0x1F);
SPI_RW(vectors[1]);
SPI_RW(vectors[1]>>8);
cs1_hi();
cs1_lo();
SPI_RW(0x20);
SPI_RW(vectors[2]);
SPI_RW(vectors[2]>>8);
cs1_hi();
}
/*============================================================================*/
/*init_adc(): Initialise ADC Channels CH0 & CH2 with SMCLK --DCO clock of 1MHz*/
/*============================================================================*/
/*
void init_adc(void)
{
ADC10CTL0 = SREF_1 + ADC10SHT_2 + REFON + ADC10ON + REF2_5V; // + ADC10IE;
ADC10CTL1 |= INCH_0 + ADC10SSEL_3 + CONSEQ_0; //Select adc channel A0,SMCLK
ADC10AE0 |= BIT0| BIT2 ; // P2.0 ADC option select
//------------------------
ADC10CTL1 = INCH_2 + CONSEQ_1; // A2/A1/A0, single sequence
// ADC10CTL0 = ADC10SHT_2 + MSC + ADC10ON + ADC10IE;
ADC10CTL0 = SREF_1 + ADC10SHT_2 + MSC + REFON + ADC10ON + REF2_5V + ADC10IE;
ADC10DTC1 = 0x03; // 3 conversions
ADC10AE0 |= 0x07; // P2.2,1,0 ADC10 option select
P3DIR |= 0x80; // Set P1.0 output
}
*/
/*void readADC(void)
{
for (;;)
{
ADC10CTL0 &= ~ENC;
while (ADC10CTL1 & BUSY); // Wait if ADC10 core is active
ADC10SA = 0x200; // Data buffer start
P3OUT |= 0x80; // P3.7 = 1
ADC10CTL0 |= ENC + ADC10SC; // Sampling and conversion start
P3OUT &= ~0x80; // P1.0 = 0
}
}*/
//General short delays
void delay_ms(uint16_t x)
{
uint8_t y, z;
for ( ; x > 0 ; x--){
for ( y = 0 ; y < 90 ; y++){
for ( z = 0 ; z < 6 ; z++);
}
}
}
void putText(char *t)
{
unsigned char i=0;
while( *t !='#')
{
transmit(*t);
t++;
i++;
}
}
void display_x()
{
float temp;
int act_data;
act_data=(vectors[0] & 0x1FFF)-4095;
transmit('X');
transmit(':');
ANGLE_x = asin(scale_x/10000);
if(scale_x<0)
{
act_data=-act_data;
transmit('-');
scale_x *= -1;
}
else transmit(' ');
temp=(float)act_data*3.9;
conversion(scale_x);
transmit(dis_data[0]);
transmit('.');
transmit(dis_data[1]);
transmit(dis_data[2]);
transmit(dis_data[3]);
transmit(dis_data[4]);
transmit(' ');
act_data=(vectors[1] & 0x1FFF)-4095;
transmit('Y');
transmit(':');
if(scale_y<0)
{
act_data=-act_data;
transmit('-');
scale_y *= -1;
}
else transmit(' ');
temp=(float)act_data*3.9;
conversion(scale_y);
transmit(dis_data[0]);
transmit('.');
transmit(dis_data[1]);
transmit(dis_data[2]);
transmit(dis_data[3]);
transmit(dis_data[4]);
transmit(' ');
act_data=(vectors[2] & 0x1FFF)-4095;
transmit('Z');
transmit(':');
if(scale_z<0)
{
act_data=-act_data;
transmit('-');
scale_z *= -1;
}
else transmit(' ');
temp=(float)act_data*3.9;
conversion(scale_z);
transmit(dis_data[0]);
transmit('.');
transmit(dis_data[1]);
transmit(dis_data[2]);
transmit(dis_data[3]);
transmit(dis_data[4]);
transmit(' ');
transmit('T');
transmit(':');
transmit(0xd);
transmit(0xa);
}
void conversion(unsigned int temp_data)
{
dis_data[0]=temp_data/10000+0x30 ;
temp_data=temp_data%10000;
ANGLE_x = asin ((double)temp_data/10000);
dis_data[1]=temp_data/1000+0x30 ;
temp_data=temp_data%1000;
dis_data[2]=temp_data/100+0x30 ;
temp_data=temp_data%100;
dis_data[3]=temp_data/10+0x30 ;
temp_data=temp_data%10;
dis_data[4]=temp_data+0x30;
}
void BackChannel_Write(char text[])
{
uint16_t textLength;
for (textLength = 0; text[textLength] != '\0'; ++textLength)
;
{
bcUartSend((uint8_t *) text, textLength);
}
}
void bcUartInit(void)
{
//Set pins 4.0 and 4.3 to UARTA1 functionality
// Always use the step-by-step init procedure listed in the USCI chapter of
// the F5xx Family User's Guide
UCA1CTL1 |= UCSWRST; // Put the USCI state machine in reset
UCA1CTL1 |= UCSSEL__SMCLK; // Use SMCLK as the bit clock
// Set the baudrate
UCA1BR0 = UCA1_BR0;
UCA1BR1 = UCA1_BR1;
UCA1MCTL = ((UCA1_BRF&0x0F) << 4) | ((UCA1_BRS&0x7F) << 1) | ((UCA1_OS&0xFF));
P4SEL |= BIT4+BIT5; // Configure these pins as TXD/RXD
UCA1CTL1 &= ~UCSWRST; // Take the USCI out of reset
UCA1IE |= UCRXIE; // Enable the RX interrupt. Now, when bytes are
// rcv'ed, the USCI_A1 vector will be generated.
}
void bcUartSend(uint8_t * buf, uint8_t len)
{
uint8_t i = 0;
// Write each byte in buf to USCI TX buffer, which sends it out
while (i < len)
{
UCA1TXBUF = *(buf+(i++));
// Wait until each bit has been clocked out...
while(!(UCTXIFG==(UCTXIFG & UCA1IFG))&&((UCA1STAT & UCBUSY)==UCBUSY));
UCB1TXBUF = UCA1TXBUF;
}
}
// Copies into 'buf' whatever bytes have been received on the UART since the
// last fetch. Returns the number of bytes copied.
uint16_t bcUartReceiveBytesInBuffer(uint8_t* buf)
{
uint16_t i, count;
// Hold off ints for incoming data during the copy
UCA1IE &= ~UCRXIE;
for(i=0; i<bcUartRcvBufIndex; i++)
{
buf[i] = bcUartRcvBuf[i];
}
count = bcUartRcvBufIndex;
bcUartRcvBufIndex = 0; // Move index back to the beginning of the buffer
bcUartRxThreshReached = 0;
// Restore USCI interrupts, to resume receiving data.
UCA1IE |= UCRXIE;
return count;
}
// The USCI_A1 receive interrupt service routine (ISR). Executes every time a
// byte is received on the back-channel UART.
#pragma vector=USCI_A1_VECTOR
__interrupt void bcUartISR(void)
{
bcUartRcvBuf[bcUartRcvBufIndex++] = UCA1RXBUF; // Fetch the byte, store
// it in the buffer.
// Wake main, to fetch data from the buffer.
if(bcUartRcvBufIndex >= BC_RX_WAKE_THRESH)
{
bcUartRxThreshReached = 1;
__bic_SR_register_on_exit(LPM3_bits); // Exit LPM0-3
}
}
