当前位置：文档库 › LaunchPad(MSP430G2553)_官方例程

LaunchPad(MSP430G2553)_官方例程

LaunchPad 官方例程（无修改）

一切皆为2012TI杯电子设计大赛

//************************************************************************* *****

// LaunchPad Lab2 - Software Toggle P1.0,

// MSP430G2xx2

// -----------------

// /|\| XIN|-

// | | |

// --|RST XOUT|-

// | |

// | P1.0|-->LED

//************************************************************************* *****

#include

void main(void)

{

WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer

if (CALBC1_1MHZ == 0xFF || CALDCO_1MHZ == 0xFF)

{

while(1); // If calibration constants erased, trap CPU!!

}

// Configure Basic Clock

BCSCTL1 = CALBC1_1MHZ; // Set range

DCOCTL = CALDCO_1MHZ; // Set DCO step + modulation

BCSCTL3 |= LFXT1S_2; // Set LFXT1

P1DIR = BIT6; // P1.6 output (green LED)

P1OUT = 0; // LED off

IFG1 &= ~OFIFG; // Clear OSCFault flag

BCSCTL2 |=SELM_1 + DIVM_0; // Set MCLK

for(;;)

{

P1OUT = BIT6; // P1.6 on (green LED)

_delay_cycles(100);

P1OUT = 0; // green LED off

_delay_cycles(5000);

}

//************************************************************************* *****

// LaunchPad Lab3 - Software Port Interrupt Service

// MSP430G2xx2

// -----------------

// /|\| XIN|-

// | | |

// --|RST XOUT|-

// /|\ | |

// --o--|P1.3 P1.0|-->LED

// \|/

//************************************************************************* *****

#include

void main(void)

{

WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer

P1DIR |= BIT0; // Set P1.0 to output direction

P1IES |= BIT3; // P1.3 Hi/lo edge

P1IFG &= ~BIT3; // P1.3 IFG cleared

P1IE |= BIT3; // P1.3 interrupt enabled

_BIS_SR(LPM4_bits + GIE); // Enter LPM4 w/interrupt }

// Port 1 interrupt service routine

#pragma vector=PORT1_VECTOR

__interrupt void Port_1(void)

{

if (P1IFG & BIT3)

{

P1OUT ^= BIT0; // P1.0 = toggle

P1IFG &= ~BIT3; // P1.3 IFG cleared }

}

//************************************************************************* *****

// LaunchPad Lab5 - ADC10, Sample A10 Temp and Convert to oC and oF

// MSP430G2452

// -----------------

// /|\| XIN|-

// | | |

// --|RST XOUT|-

// | |

// |A10 |

//************************************************************************* *****

#include "msp430g2553.h"

long temp;

long IntDegF;

long IntDegC;

void main(void)

{

WDTCTL = WDTPW + WDTHOLD; // Stop WDT

//Configure ADC10

ADC10CTL1 = INCH_10 + ADC10DIV_3; // Choose ADC Channel as Temp Sensor

ADC10CTL0 = SREF_1 + ADC10SHT_3 + REFON + ADC10ON + ADC10IE;

//Choose ADC Ref source

__enable_interrupt(); // Enable interrupts.

TACCR0 = 30; // Delay to allow Ref to settle

TACCTL0 |= CCIE; // Compare-mode interrupt.

TACTL = TASSEL_2 | MC_1; // TACLK = SMCLK, Up mode.

LPM0; // Wait for delay.

TACCTL0 &= ~CCIE; // Disable timer Interrupt

__disable_interrupt();

while(1)

{

ADC10CTL0 |= ENC + ADC10SC; // Sampling and conversion start

__bis_SR_register(LPM0_bits + GIE); // LPM0 with interrupts enabled

// oF = ((A10/1024)*1500mV)-923mV)*1/1.97mV = A10*761/1024 - 468

temp = ADC10MEM;

IntDegF = ((temp - 630) * 761) / 1024;

// oC = ((A10/1024)*1500mV)-986mV)*1/3.55mV = A10*423/1024 - 278

temp = ADC10MEM;

IntDegC = ((temp - 673) * 423) / 1024;

__no_operation(); // SET BREAKPOINT HERE

}

// ADC10 interrupt service routine

#pragma vector=ADC10_VECTOR

__interrupt void ADC10_ISR (void)

{

__bic_SR_register_on_exit(LPM0_bits); // Clear CPUOFF bit from 0(SR)

}

#pragma vector=TIMER0_A0_VECTOR

__interrupt void ta0_isr(void)

{

TACTL = 0;

__bic_SR_register_on_exit(LPM0_bits); // Clear CPUOFF bit from 0(SR)

}

//************************************************************************* *****

// MSP430F20xx Demo - Basic Clock, Output Buffered SMCLK, ACLK and MCLK/10 //

// Description: Buffer ACLK on P2.0, default SMCLK(DCO) on P1.4 and MCLK/10 on // P1.5.

// ACLK = LFXT1 = VLO, MCLK = SMCLK = default DCO

// //* External watch crystal installed on XIN XOUT is required for ACLK *//

// MSP430F20xx

// -----------------

// /|\| XIN|-

// | | |

// --|RST XOUT|-

// | |

// | P1.4/SMCLK|-->SMCLK = Default DCO

// | P1.5|-->MCLK/10 = DCO/10

// | P1.0/ACLK|-->ACLK = VLO

// M. Buccini / L. Westlund

// Texas Instruments Inc.

// October 2005

// Built with IAR Embedded Workbench Version: 3.40A

//************************************************************************* *****

#include

unsigned char s;

void main(void)

{

WDTCTL = WDTPW +WDTHOLD; // Stop Watchdog Timer

BCSCTL3 |= LFXT1S_2; // LFXT1 = VLO

//DCOCTL = 0;

//BCSCTL1 = CALBC1_16MHZ;

//DCOCTL = CALBC1_16MHZ;

P1DIR |= 0x31; // P1.0,5 and P1.4 outputs

P1SEL |= 0x11; // P1.0,4 ACLK/VLO, SMCLK/DCO output

//SMCLK Sub-System Main Clk，ACLK和SMCLK可以通过复用引脚输出，MCLK 不能直接输出体现, MCLK可以配置为VLO或者DCO

while(1)

{

P1OUT |= 0x20; // P1.5 = 1, 通过开关P1.5来体现MCLK，这两条指令的周期大概为SMCLK的1/10

P1OUT &= ~0x20;//20;

}

//*************************************************************************

*****

// MSP430xG46x Demo - FLL+, Runs Internal DCO at 8MHz

// Description: This program demonstrates setting the internal DCO to run at

// 8MHz with auto-calibration by the FLL+.

// ACLK = LFXT1 = 32768Hz, MCLK = SMCLK = DCO = (121+1) x 2 x ACLK = 7995392Hz

// //* An external watch crystal between XIN & XOUT is required for ACLK *//

// MSP430xG461x

// -----------------

// /|\| XIN|-

// | | | 32kHz

// --|RST XOUT|-

// | |

// | P1.1|--> MCLK = 8MHz

// | |

// | P1.5|--> ACLK = 32kHz

// | |

// K. Quiring/ M. Mitchell

// Texas Instruments Inc.

// October 2006

// Built with IAR Embedded Workbench Version: 3.41A

//************************************************************************* ****

#include

void main(void)

{

WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer

FLL_CTL0 |= DCOPLUS + XCAP18PF; // DCO+ set, freq = xtal x D x N+1 SCFI0 |= FN_4; // x2 DCO freq, 8MHz nominal DCO

SCFQCTL = 121; // (121+1) x 32768 x 2 = 7.99 MHz

P1DIR = 0x22; // P1.1 & P1.5 to output direction

P1SEL = 0x22; // P1.1 & P1.5 to output MCLK & ACLK

while(1); // Loop in place

}

//************************************************************************* ***

// MSP430xG46x Demo - Flash In-System Programming, Copy SegA to SegB

// Description: This program first erases flash seg A, then it increments all

// values in seg A, then it erases seg B, then copies seg A to seg B.

// Assumed MCLK 550kHz - 900kHz.

// //* Set Breakpoint on NOP in the Mainloop to avoid Stressing Flash *//

// MSP430xG461x

// -----------------

// /|\| XIN|-

// | | |

// --|RST XOUT|-

// | |

// M. Mitchell

// Texas Instruments Inc.

// Feb 2005

// Built with IAR Embedded Workbench Version: 3.21A

//************************************************************************* *****

#include

char value; // 8-bit value to write to segment A

// Function prototypes

void write_SegA (char value);

void copy_A2B (void);

void main(void)

{

WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer

FCTL2 = FWKEY + FSSEL0 + FN0; // MCLK/2 for Flash Timing Generator

value = 0; // Initialize value

while(1) // Repeat forever

{

write_SegA(value++); // Write segment A, increment value

copy_A2B(); // Copy segment A to B

_NOP(); // SET BREAKPOINT HERE

}

void write_SegA (char value)

{

char *Flash_ptr; // Flash pointer

unsigned int i;

Flash_ptr = (char *) 0x1080; // Initialize Flash pointer

FCTL1 = FWKEY + ERASE; // Set Erase bit

FCTL3 = FWKEY; // Clear Lock bit

*Flash_ptr = 0; // Dummy write to erase Flash segment

FCTL1 = FWKEY + WRT; // Set WRT bit for write operation

for (i=0; i<128; i++)

{

*Flash_ptr++ = value; // Write value to flash

}

FCTL1 = FWKEY; // Clear WRT bit

FCTL3 = FWKEY + LOCK; // Set LOCK bit

}

void copy_A2B (void)

{

char *Flash_ptrA; // Segment A pointer

char *Flash_ptrB; // Segment B pointer

unsigned int i;

Flash_ptrA = (char *) 0x1080; // Initialize Flash segment A pointer

Flash_ptrB = (char *) 0x1000; // Initialize Flash segment B pointer

FCTL1 = FWKEY + ERASE; // Set Erase bit

FCTL3 = FWKEY; // Clear Lock bit

*Flash_ptrB = 0; // Dummy write to erase Flash segment B FCTL1 = FWKEY + WRT; // Set WRT bit for write operation

for (i=0; i<128; i++)

{

*Flash_ptrB++ = *Flash_ptrA++; // Copy value segment A to segment B

}

FCTL1 = FWKEY; // Clear WRT bit

FCTL3 = FWKEY + LOCK; // Set LOCK bit

}

//************************************************************************* *****

// MSP430xG46x Demo - Software Port Interrupt on P1.0 from LPM4

// Description: A hi/low transition on P1.0 will trigger P1_ISR which,

// toggles P2.1. Normal mode is LPM4 ~ 0.1uA. LPM4 current can be measured

// with the LED removed, all unused P1.x/P2.x configured as output or inputs

// pulled high or low, and ensure the P2.0 interrupt input does not float.

// ACLK = 32.768kHz, MCLK = SMCLK = default DCO

// MSP430xG461x

// -----------------

// /|\| |

// | | |

// --|RST |

// /|\ | |

// --o--|P1.0 P2.1|-->LED

// \|/

// K. Quiring/ M. Mitchell

// Texas Instruments Inc.

// October 2006

// Built with IAR Embedded Workbench Version: 3.41A

//************************************************************************* *****

#include

void main(void)

{

WDTCTL = WDTPW + WDTHOLD; // Stop WDT

FLL_CTL0 |= XCAP14PF; // Configure load caps

P2DIR = BIT1; // Set P2.1 to output direction

P1IES = BIT0; // H-L transition

P1IE = BIT0; // Enable interrupt

_BIS_SR(LPM4_bits + GIE); // LPM4, enable interrupts

}

// Port 1 interrupt service routine

#pragma vector=PORT1_VECTOR

__interrupt void Port1_ISR (void)

{

unsigned volatile int i;

for (i=10000; i>0; i--); // Debounce delay

P1IFG &= ~BIT0; // Clear P1IFG

if ((P1IN & 0x01) == 0)

P2OUT ^= 0x02; // Toggle P2.1 using exclusive-OR

}

//************************************************************************* *****

// MSP430xG46x Demo - Software Port Interrupt on P1.0 from LPM4

// Description: A hi/low transition on P1.0 will trigger P1_ISR which,

// toggles P2.1. Normal mode is LPM4 ~ 0.1uA. LPM4 current can be measured

// with the LED removed, all unused P1.x/P2.x configured as output or inputs

// pulled high or low, and ensure the P2.0 interrupt input does not float.

// ACLK = 32.768kHz, MCLK = SMCLK = default DCO

// MSP430xG461x

// -----------------

// /|\| |

// | | |

// --|RST |

// /|\ | |

// --o--|P1.0 P2.1|-->LED

// \|/

// K. Quiring/ M. Mitchell

// Texas Instruments Inc.

// October 2006

// Built with IAR Embedded Workbench Version: 3.41A

//************************************************************************* *****

#include

void main(void)

{

WDTCTL = WDTPW + WDTHOLD; // Stop WDT

FLL_CTL0 |= XCAP14PF; // Configure load caps

P2DIR = BIT1; // Set P2.1 to output direction

P1IES = BIT0; // H-L transition

P1IE = BIT0; // Enable interrupt

_BIS_SR(LPM4_bits + GIE); // LPM4, enable interrupts

}

// Port 1 interrupt service routine

#pragma vector=PORT1_VECTOR

__interrupt void Port1_ISR (void)

{

unsigned volatile int i;

for (i=10000; i>0; i--); // Debounce delay

P1IFG &= ~BIT0; // Clear P1IFG

if ((P1IN & 0x01) == 0)

P2OUT ^= 0x02; // Toggle P2.1 using exclusive-OR

}

//************************************************************************* *****

// MSP430xG46x Demo - USCI_A0, 115200 UART Echo ISR, DCO SMCLK

// (modified code example "msp430xG46x_uscia0_uart_01_115k.c")

// Description: Echo a received character, RX ISR used. Normal mode is LPM0.

// USCI_A0 RX interrupt triggers TX Echo.

// Baud rate divider with 1048576hz = 1048576/115200 = ~9.1 (009h|01h)

// ACLK = LFXT1 = 32768Hz, MCLK = SMCLK = default DCO = 32 x ACLK = 1048576Hz

// //* An external watch crystal between XIN & XOUT is required for ACLK *//

// MSP430FG4619

// -----------------

// /|\| XIN|-

// | | | 32kHz

// --|RST XOUT|-

// | |

// | P2.5/UCA0RXD|<------------

// | | 115200 - 8N1

// | P2.4/UCA0TXD|------------>

// Texas Instruments Inc.

// October 2006

// Built with IAR Embedded Workbench Version: 3.41A

//************************************************************************* *****

#include "msp430xG46x.h"

void main(void)

{

volatile unsigned int i;

WDTCTL = WDTPW+WDTHOLD; // Stop WDT

FLL_CTL0 |= XCAP14PF; // Configure load caps

{

IFG1 &= ~OFIFG; // Clear OSCFault flag

for (i = 0x47FF; i > 0; i--); // Time for flag to set

}

while ((IFG1 & OFIFG)); // OSCFault flag still set?

P2SEL |= 0x030; // P2.4,5 = USCI_A0 RXD/TXD

UCA0CTL1 |= UCSSEL_2; // SMCLK

UCA0BR0 = 18;0x09; // 1MHz 115200

UCA0BR1 = 0;0x00; // 1MHz 115200

UCA0MCTL = 0;0x02; // Modulation

UCA0CTL1 &= ~UCSWRST; // **Initialize USCI state machine**

IE2 |= UCA0RXIE; // Enable USCI_A0 RX interrupt

_BIS_SR(LPM0_bits + GIE); // Enter LPM0, interrupts enabled

}

// Echo back RXed character, confirm TX buffer is ready first

#pragma vector=USCIAB0RX_VECTOR

__interrupt void USCIA0RX_ISR (void)

{

while(!(IFG2&UCA0TXIFG));

UCA0TXBUF = UCA0RXBUF; // TX -> RXed character

}

10.

/************************************************************************** ****

* MSP-EXP430G2-LaunchPad User Experience Application

* 1. Device starts up in LPM3 + blinking LED to indicate device is alive

* + Upon first button press, device transitions to application mode

* 2. Application Mode

* + Continuously sample ADC Temp Sensor channel, compare result against

* initial value

* + Set PWM based on measured ADC offset: Red LED for positive offset, Green

* LED for negative offset

* + Transmit temperature value via TimerA UART to PC

* + Button Press --> Calibrate using current temperature

* Send character '? via UART, notifying PC

******************************************************************************/ #include "msp430g2553.h"

#define LED0 BIT0

#define LED1 BIT6

#define LED_DIR P1DIR

#define LED_OUT P1OUT

#define BUTTON BIT3

#define BUTTON_OUT P1OUT

#define BUTTON_DIR P1DIR

#define BUTTON_IN P1IN

#define BUTTON_IE P1IE

#define BUTTON_IES P1IES

#define BUTTON_IFG P1IFG

#define BUTTON_REN P1REN

#define TXD BIT1 // TXD on P1.1 #define RXD BIT2 // RXD on P1.2

#define APP_STANDBY_MODE 0

#define APP_APPLICATION_MODE 1

#define TIMER_PWM_MODE 0

#define TIMER_UART_MODE 1

#define TIMER_PWM_PERIOD 2000

#define TIMER_PWM_OFFSET 20

#define TEMP_SAME 0

#define TEMP_HOT 1

#define TEMP_COLD 2

#define TEMP_THRESHOLD 5

// Conditions for 9600/4=2400 Baud SW UART, SMCLK = 1MHz

#define Bitime_5 0x05*4 // ~ 0.5 bit length + small adjustment

#define Bitime 13*4//0x0D

#define UART_UPDA TE_INTERV AL 1000

unsigned char BitCnt;

unsigned char applicationMode = APP_STANDBY_MODE;

unsigned char timerMode = TIMER_PWM_MODE;

unsigned char tempMode;

unsigned char calibrateUpdate = 0;

unsigned char tempPolarity = TEMP_SAME;

unsigned int TXByte;

/* Using an 8-value moving average filter on sampled ADC values */

long tempMeasured[8];

unsigned char tempMeasuredPosition=0;

long tempAverage;

long tempCalibrated, tempDifference;

void InitializeLeds(void);

void InitializeButton(void);

void PreApplicationMode(void); // Blinks LED, waits for button press

void ConfigureAdcTempSensor(void);

void ConfigureTimerPwm(void);

void ConfigureTimerUart(void);

void Transmit(void);

void InitializeClocks(void);

void main(void)

{

unsigned int uartUpdateTimer = UART_UPDATE_INTERV AL;

unsigned char i;

WDTCTL = WDTPW + WDTHOLD; // Stop WDT

InitializeClocks();

InitializeButton();

InitializeLeds();

PreApplicationMode(); // Blinks LEDs, waits for button press

/* Application Mode begins */

applicationMode = APP_APPLICATION_MODE;

ConfigureAdcTempSensor();

ConfigureTimerPwm();

__enable_interrupt(); // Enable interrupts.

/* Main Application Loop */

while(1)

{

ADC10CTL0 |= ENC + ADC10SC; // Sampling and conversion start

__bis_SR_register(CPUOFF + GIE); // LPM0 with interrupts enabled

/* Moving average filter out of 8 values to somewhat stabilize sampled ADC */

tempMeasured[tempMeasuredPosition++] = ADC10MEM;

if (tempMeasuredPosition == 8)

tempMeasuredPosition = 0;

tempAverage = 0;

for (i = 0; i < 8; i++)

tempAverage += tempMeasured[i];

tempAverage >>= 3; // Divide by 8 to get average

if ((--uartUpdateTimer == 0) || calibrateUpdate )

{

ConfigureTimerUart();

if (calibrateUpdate)

{

TXByte = 248; // A character with high value, outside of temp range

Transmit();

calibrateUpdate = 0;

}

TXByte = (unsigned char)( ((tempAverage - 630) * 761) / 1024 );

Transmit();

uartUpdateTimer = UART_UPDATE_INTERV AL;

ConfigureTimerPwm();

}

tempDifference = tempAverage - tempCalibrated;

if (tempDifference < -TEMP_THRESHOLD)

{

tempDifference = -tempDifference;

tempPolarity = TEMP_COLD;

LED_OUT &= ~ LED1;

}

else

if (tempDifference > TEMP_THRESHOLD)

{

tempPolarity = TEMP_HOT;

LED_OUT &= ~ LED0;

}

else

{

tempPolarity = TEMP_SAME;

TACCTL0 &= ~CCIE;

TACCTL1 &= ~CCIE;

LED_OUT &= ~(LED0 + LED1);

}

if (tempPolarity != TEMP_SAME)

{

tempDifference <<= 3;

tempDifference += TIMER_PWM_OFFSET;

TACCR1 = ( (tempDifference) < (TIMER_PWM_PERIOD-1) ? (tempDifference) : (TIMER_PWM_PERIOD-1) );

TACCTL0 |= CCIE;

TACCTL1 |= CCIE;

}

void PreApplicationMode(void)

{

LED_DIR |= LED0 + LED1;

LED_OUT |= LED0; // To enable the LED toggling effect LED_OUT &= ~LED1;

BCSCTL1 |= DIV A_1; // ACLK/2

BCSCTL3 |= LFXT1S_2; // ACLK = VLO

TACCR0 = 1200; //

TACTL = TASSEL_1 | MC_1; // TACLK = SMCLK, Up mode. TACCTL1 = CCIE + OUTMOD_3; // TACCTL1 Capture Compare TACCR1 = 600;

__bis_SR_register(LPM3_bits + GIE); // LPM0 with interrupts enabled

}

void ConfigureAdcTempSensor(void)

{

unsigned char i;

/* Configure ADC Temp Sensor Channel */

ADC10CTL1 = INCH_10 + ADC10DIV_3; // Temp Sensor ADC10CLK/4 ADC10CTL0 = SREF_1 + ADC10SHT_3 + REFON + ADC10ON + ADC10IE;

__delay_cycles(1000); // Wait for ADC Ref to settle

ADC10CTL0 |= ENC + ADC10SC; // Sampling and conversion start __bis_SR_register(CPUOFF + GIE); // LPM0 with interrupts enabled tempCalibrated = ADC10MEM;

for (i=0; i < 8; i++)

tempMeasured[i] = tempCalibrated;

tempAverage = tempCalibrated;

}