void msp430_spi_a0_init()
{
/**Configure Pins for SPI
* Set P2.7, P3.3 and P3.4 as Secondary Module Function.
* */
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P2,
GPIO_PIN7
);
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P3,
GPIO_PIN3 + GPIO_PIN4
);
//Initialize Master
USCI_A_SPI_initMasterParam param = {0};
param.selectClockSource = USCI_A_SPI_CLOCKSOURCE_SMCLK;
param.clockSourceFrequency = UCS_getSMCLK();
param.desiredSpiClock = 8000000;
param.msbFirst = USCI_A_SPI_MSB_FIRST;
param.clockPhase = USCI_A_SPI_PHASE_DATA_CHANGED_ONFIRST_CAPTURED_ON_NEXT;
param.clockPolarity = USCI_A_SPI_CLOCKPOLARITY_INACTIVITY_LOW;
USCI_A_SPI_initMaster(USCI_A0_BASE, ¶m);
//Enable SPI module
USCI_A_SPI_enable(USCI_A0_BASE);
//Enable Receive interrupt
USCI_A_SPI_clearInterrupt(USCI_A0_BASE,
USCI_A_SPI_RECEIVE_INTERRUPT);
USCI_A_SPI_enableInterrupt(USCI_A0_BASE,
USCI_A_SPI_RECEIVE_INTERRUPT);
}
t_uint8 _Device_Uart_Module_1_Enable(t_uint32 baud_rate){
//setUSCI_X TXD
GPIO_setAsPeripheralModuleFunctionInputPin( USART_Module_1_TX_PORT, USART_Module_1_TX_PIN );
//setUSCI_X RXD
GPIO_setAsPeripheralModuleFunctionInputPin( USART_Module_1_RX_PORT, USART_Module_1_RX_PIN );
if ( STATUS_FAIL == USCI_A_UART_init(UART_Module_1_USCI_A_BASEADDRESS,
USCI_A_UART_CLOCKSOURCE_SMCLK,
UCS_getSMCLK(UCS_BASE),
baud_rate,
USCI_A_UART_NO_PARITY,
USCI_A_UART_LSB_FIRST,
USCI_A_UART_ONE_STOP_BIT,
USCI_A_UART_MODE,
USCI_A_UART_LOW_FREQUENCY_BAUDRATE_GENERATION )){
return Func_Failure;
}
//Enable UART module for operation
USCI_A_UART_enable(UART_Module_1_USCI_A_BASEADDRESS);
//Enable Receive Interrupt
USCI_A_UART_clearInterruptFlag(UART_Module_1_USCI_A_BASEADDRESS, USCI_A_UART_RECEIVE_INTERRUPT);
USCI_A_UART_enableInterrupt(UART_Module_1_USCI_A_BASEADDRESS, USCI_A_UART_RECEIVE_INTERRUPT);
//Enter LPM3, interrupts enabled
//__bis_SR_register(LPM3_bits + GIE);
__no_operation();
Interrupt_UART_ReceiveData_ptr_fuc = Empty_UART_fun;
SendingWhileTimeOutCount = 0;
return Func_Success;
}
/*
* ======== MSP_EXP430F5529LP_initUART ======== */
void MSP_EXP430F5529LP_initUART(void)
{
/* P4.4,5 = USCI_A1 TXD/RXD */
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P4,
GPIO_PIN4 | GPIO_PIN5);
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P3,
GPIO_PIN3 | GPIO_PIN4);
/* Initialize the UART driver */
UART_init();
}
/**********************************************************************//**
* @brief Initializes the System
*
* @param none
*
* @return none
*************************************************************************/
void SystemInit(void)
{
// Set the DCO to 8MHz (it's also the device's power-on setting). Do not change this frequency!
// It impacts the cap touch scan window.
CS_setDCOFreq(__MSP430_BASEADDRESS_CS__, CS_DCORSEL_0, CS_DCOFSEL_6);
// Configure clock source and clock dividers. After this the clock configuration will be as follows:
// ACLK=LFXT1/1=32,768Hz; SMCLK=DCOCLK/1=8MHz; and MCLK=DCOCLK/1=8MHz.
CS_clockSignalInit(__MSP430_BASEADDRESS_CS__, CS_ACLK, CS_LFXTCLK_SELECT, CS_CLOCK_DIVIDER_1);
CS_clockSignalInit(__MSP430_BASEADDRESS_CS__, CS_SMCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_1);
CS_clockSignalInit(__MSP430_BASEADDRESS_CS__, CS_MCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_1);
// Set all GPIO to output low to minimize current draw by eliminating floating pins.
GPIO_setOutputLowOnPin(GPIO_PORT_PA, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 | GPIO_PIN8 | GPIO_PIN9 | GPIO_PIN10 | GPIO_PIN11 | GPIO_PIN12 | GPIO_PIN13 | GPIO_PIN14 | GPIO_PIN15);
GPIO_setOutputLowOnPin(GPIO_PORT_PB, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 | GPIO_PIN8 | GPIO_PIN9 | GPIO_PIN10 | GPIO_PIN11 | GPIO_PIN12 | GPIO_PIN13 | GPIO_PIN14 | GPIO_PIN15);
GPIO_setOutputLowOnPin(GPIO_PORT_PJ, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN6 | GPIO_PIN7 | GPIO_PIN8 | GPIO_PIN9 | GPIO_PIN10 | GPIO_PIN11 | GPIO_PIN12 | GPIO_PIN13 | GPIO_PIN14 | GPIO_PIN15);
GPIO_setAsOutputPin(GPIO_PORT_PA, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 | GPIO_PIN8 | GPIO_PIN9 | GPIO_PIN10 | GPIO_PIN11 | GPIO_PIN12 | GPIO_PIN13 | GPIO_PIN14 | GPIO_PIN15);
GPIO_setAsOutputPin(GPIO_PORT_PB, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 | GPIO_PIN8 | GPIO_PIN9 | GPIO_PIN10 | GPIO_PIN11 | GPIO_PIN12 | GPIO_PIN13 | GPIO_PIN14 | GPIO_PIN15);
GPIO_setAsOutputPin(GPIO_PORT_PJ, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN6 | GPIO_PIN7 | GPIO_PIN8 | GPIO_PIN9 | GPIO_PIN10 | GPIO_PIN11 | GPIO_PIN12 | GPIO_PIN13 | GPIO_PIN14 | GPIO_PIN15);
// Configure the left button (S2) connected to P4.6. For this enable the internal pull-up resistor and
// setup the pin interrupt to trigger on rising edges.
GPIO_setAsInputPinWithPullUpresistor(GPIO_PORT_P4, GPIO_PIN5);
GPIO_interruptEdgeSelect(GPIO_PORT_P4, GPIO_PIN5, GPIO_LOW_TO_HIGH_TRANSITION);
GPIO_clearInterruptFlag(GPIO_PORT_P4, GPIO_PIN5);
GPIO_enableInterrupt(GPIO_PORT_P4, GPIO_PIN5);
// Configure the right button (S3) connected to P1.1. For this enable the internal pull-up resistor and
// setup the pin interrupt to trigger on rising edges.
GPIO_setAsInputPinWithPullUpresistor(GPIO_PORT_P1, GPIO_PIN1);
GPIO_interruptEdgeSelect(GPIO_PORT_P1, GPIO_PIN1, GPIO_LOW_TO_HIGH_TRANSITION);
GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1);
GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN1);
// CapSense Setup. GPIO pins P1.3-1.5 and P3.4-3.6 are used for capacitive touch so let's
// switch them to inputs.
// GPIO_setAsInputPin(GPIO_PORT_P1, GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5);
GPIO_setAsInputPin(GPIO_PORT_P3, GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6);
// Enable LFXT functionality on PJ.4 and PJ.5. For this we only need to configure PJ.4 to
// LFXIN and the port module logic takes care of the rest.
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_PJ, GPIO_PIN4, GPIO_PRIMARY_MODULE_FUNCTION);
// Disable the GPIO power-on default high-impedance mode to activate previously configured port settings
PMM_unlockLPM5(__MSP430_BASEADDRESS_PMM_FRAM__);
// Perform the required LFXT startup procedure now that all of the port pins are configured.
CS_setExternalClockSource(__MSP430_BASEADDRESS_CS__, 32768, 0);
CS_LFXTStart(__MSP430_BASEADDRESS_CS__, CS_LFXT_DRIVE0);
// Initialize LCD driver and the context for the LCD
Sharp96x96_LCDInit();
TA0_enableVCOMToggle();
GrContextInit(&sContext, &g_sharp96x96LCD);
GrContextForegroundSet(&sContext, ClrBlack);
GrContextBackgroundSet(&sContext, ClrWhite);
onLED(); //blink LED1
}
void main (void)
{
//Stop WDT
WDT_hold(__MSP430_BASEADDRESS_WDT_A__);
//P3.4,5 = USCI_A0 TXD/RXD
GPIO_setAsPeripheralModuleFunctionInputPin(__MSP430_BASEADDRESS_PORT3_R__,
GPIO_PORT_P3,
GPIO_PIN4 + GPIO_PIN5
);
//Initialize USCI UART module
if ( STATUS_FAIL == UART_init(__MSP430_BASEADDRESS_USCI_A0__,
UART_CLOCKSOURCE_SMCLK,
UCS_getSMCLK(__MSP430_BASEADDRESS_UCS__),
BAUD_RATE,
UART_NO_PARITY,
UART_LSB_FIRST,
UART_ONE_STOP_BIT,
UART_MODE,
UART_OVERSAMPLING_BAUDRATE_GENERATION
)){
return;
}
//Enable UART module for operation
UART_enable(__MSP430_BASEADDRESS_USCI_A0__);
//Enable Receive Interrupt
UART_enableInterrupt(__MSP430_BASEADDRESS_USCI_A0__, UART_RECEIVE_INTERRUPT);
//Enter LPM3, interrupts enabled
__bis_SR_register(LPM3_bits + GIE);
__no_operation();
}
/*
* ======== MSP_EXP430F5529LP_initWiFi ========
*/
void MSP_EXP430F5529LP_initWiFi(void)
{
/* Configure EN & CS pins to disable CC3100 */
GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN2);
GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN6);
GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN2);
GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN6);
/* Configure SPI */
/* SPI CLK */
GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P3, GPIO_PIN2);
/* MOSI/SIMO */
GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P3, GPIO_PIN0);
/* MISO/SOMI */
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P3, GPIO_PIN1);
/* Configure IRQ pin */
GPIO_setAsInputPinWithPullDownResistor(GPIO_PORT_P2, GPIO_PIN0);
GPIO_selectInterruptEdge(GPIO_PORT_P2, GPIO_PIN0,
GPIO_LOW_TO_HIGH_TRANSITION);
/* Initialize SPI and WiFi drivers */
SPI_init();
WiFi_init();
}
void WheelADC_init()
{
// --------初始化ADC12--------
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P6,
GPIO_PIN4);
ADC12_A_init(ADC12_A_BASE, // 初始化ADC12，
ADC12_A_SAMPLEHOLDSOURCE_SC,
ADC12_A_CLOCKSOURCE_ADC12OSC,
ADC12_A_CLOCKDIVIDER_1);
ADC12_A_enable(ADC12_A_BASE); // 打开ADC12
ADC12_A_setupSamplingTimer(ADC12_A_BASE,// 建立采样定时器控制采样保持时间，16个clock
ADC12_A_CYCLEHOLD_64_CYCLES,
ADC12_A_CYCLEHOLD_4_CYCLES,
ADC12_A_MULTIPLESAMPLESDISABLE);
ADC12_A_memoryConfigure(ADC12_A_BASE,
ADC12_A_MEMORY_0,
ADC12_A_INPUT_A4,
ADC12_A_VREFPOS_AVCC, // VREF+ = AVCC
ADC12_A_VREFNEG_AVSS, // VREF- = AVSS
ADC12_A_ENDOFSEQUENCE);
//Enable memory buffer 0 interrupt
ADC12_A_clearInterrupt(ADC12_A_BASE,
ADC12_A_IFG0);
ADC12_A_enableInterrupt(ADC12_A_BASE,
ADC12IE0);
__delay_cycles(75);
}
static void prvSetupHardware( void )
{
/* Stop Watchdog timer. */
WDT_A_hold( __MSP430_BASEADDRESS_WDT_A__ );
/* Set all GPIO pins to output and low. */
GPIO_setOutputLowOnPin( GPIO_PORT_P1, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 );
GPIO_setOutputLowOnPin( GPIO_PORT_P2, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 );
GPIO_setOutputLowOnPin( GPIO_PORT_P3, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 );
GPIO_setOutputLowOnPin( GPIO_PORT_P4, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 );
GPIO_setOutputLowOnPin( GPIO_PORT_PJ, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 | GPIO_PIN8 | GPIO_PIN9 | GPIO_PIN10 | GPIO_PIN11 | GPIO_PIN12 | GPIO_PIN13 | GPIO_PIN14 | GPIO_PIN15 );
GPIO_setAsOutputPin( GPIO_PORT_P1, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 );
GPIO_setAsOutputPin( GPIO_PORT_P2, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 );
GPIO_setAsOutputPin( GPIO_PORT_P3, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 );
GPIO_setAsOutputPin( GPIO_PORT_P4, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 );
GPIO_setAsOutputPin( GPIO_PORT_PJ, GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7 | GPIO_PIN8 | GPIO_PIN9 | GPIO_PIN10 | GPIO_PIN11 | GPIO_PIN12 | GPIO_PIN13 | GPIO_PIN14 | GPIO_PIN15 );
/* Configure P2.0 - UCA0TXD and P2.1 - UCA0RXD. */
GPIO_setOutputLowOnPin( GPIO_PORT_P2, GPIO_PIN0 );
GPIO_setAsOutputPin( GPIO_PORT_P2, GPIO_PIN0 );
GPIO_setAsPeripheralModuleFunctionInputPin( GPIO_PORT_P2, GPIO_PIN1, GPIO_SECONDARY_MODULE_FUNCTION );
GPIO_setAsPeripheralModuleFunctionOutputPin( GPIO_PORT_P2, GPIO_PIN0, GPIO_SECONDARY_MODULE_FUNCTION );
/* Set PJ.4 and PJ.5 for LFXT. */
GPIO_setAsPeripheralModuleFunctionInputPin( GPIO_PORT_PJ, GPIO_PIN4 + GPIO_PIN5, GPIO_PRIMARY_MODULE_FUNCTION );
/* Set DCO frequency to 8 MHz. */
CS_setDCOFreq( CS_DCORSEL_0, CS_DCOFSEL_6 );
/* Set external clock frequency to 32.768 KHz. */
CS_setExternalClockSource( 32768, 0 );
/* Set ACLK = LFXT. */
CS_initClockSignal( CS_ACLK, CS_LFXTCLK_SELECT, CS_CLOCK_DIVIDER_1 );
/* Set SMCLK = DCO with frequency divider of 1. */
CS_initClockSignal( CS_SMCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_1 );
/* Set MCLK = DCO with frequency divider of 1. */
CS_initClockSignal( CS_MCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_1 );
/* Start XT1 with no time out. */
CS_turnOnLFXT( CS_LFXT_DRIVE_0 );
/* Disable the GPIO power-on default high-impedance mode. */
PMM_unlockLPM5();
}
void initI2CModule(void)
{
unsigned int flags = EUSCI_B_I2C_TRANSMIT_INTERRUPT0 |
EUSCI_B_I2C_RECEIVE_INTERRUPT0 |
EUSCI_B_I2C_TRANSMIT_INTERRUPT1 |
EUSCI_B_I2C_RECEIVE_INTERRUPT1 |
EUSCI_B_I2C_STOP_INTERRUPT |
EUSCI_B_I2C_NAK_INTERRUPT;
#if 0
/* Select Port B1 for I2C - Set Pin 4, 5 to input Primary Module Function,
* (UCB1SIMO/UCB1SDA, UCB1SOMI/UCB1SCL).
*/
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P6,
GPIO_PIN4 + GPIO_PIN5, GPIO_PRIMARY_MODULE_FUNCTION);
/* eUSCI I2C Slave Configuration */
I2C_initSlave(EUSCI_B1_BASE, SLAVE_ADDRESS, EUSCI_B_I2C_OWN_ADDRESS_OFFSET0,
EUSCI_B_I2C_OWN_ADDRESS_ENABLE);
I2C_initSlave(EUSCI_B1_BASE, 0xC, EUSCI_B_I2C_OWN_ADDRESS_OFFSET1,
EUSCI_B_I2C_OWN_ADDRESS_ENABLE);
I2C_setMode(EUSCI_B1_BASE, EUSCI_B_I2C_RECEIVE_MODE);
/* Enable the module and enable interrupts */
I2C_enableModule(EUSCI_B1_BASE);
MAP_I2C_clearInterruptFlag(EUSCI_B1_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
MAP_I2C_enableInterrupt(EUSCI_B1_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
MAP_Interrupt_enableInterrupt(INT_EUSCIB1);
#else
/* eUSCI I2C Slave Configuration */
I2C_initSlave(EUSCI_B0_BASE, SLAVE_ADDRESS, EUSCI_B_I2C_OWN_ADDRESS_OFFSET0,
EUSCI_B_I2C_OWN_ADDRESS_ENABLE);
#if 1
I2C_initSlave(EUSCI_B0_BASE, 0xC, EUSCI_B_I2C_OWN_ADDRESS_OFFSET1,
EUSCI_B_I2C_OWN_ADDRESS_ENABLE);
#endif
/* Select Port B2 for I2C - Set Pin 6, 7 to input Primary Module Function
*/
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
GPIO_PIN6 | GPIO_PIN7, GPIO_PRIMARY_MODULE_FUNCTION);
/* Define the SMbus alert pin */
MAP_GPIO_setOutputHighOnPin(GPIO_PORT_P5, GPIO_PIN0);
MAP_GPIO_setAsOutputPin(GPIO_PORT_P5, GPIO_PIN0);
I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_MODE);
/* Enable the module and enable interrupts */
I2C_enableModule(EUSCI_B0_BASE);
MAP_I2C_clearInterruptFlag(EUSCI_B0_BASE, flags);
MAP_Interrupt_setPriority(INT_EUSCIB0, configMAX_SYSCALL_INTERRUPT_PRIORITY);
MAP_I2C_enableInterrupt(EUSCI_B0_BASE, flags);
MAP_Interrupt_enableInterrupt(INT_EUSCIB0);
#endif
}
void InitUart(uint32_t uartModuleBaseAdress,uint8_t uartPort,uint8_t pin1Uart,uint8_t pin2Uart,uint8_t pin3Uart,
eUSCI_UART_Config uartConfiguration,uint8_t primaryModuleFunction)
{
/* Selecting P1.2 and P1.3 in UART mode */
GPIO_setAsPeripheralModuleFunctionInputPin(uartPort,
pin1Uart | pin2Uart | pin3Uart, primaryModuleFunction);
/* Setting DCO to 12MHz */
CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_12);
/* Configuring UART Module */
UART_initModule(uartModuleBaseAdress, &uartConfiguration);
/* Enable UART module */
UART_enableModule(uartModuleBaseAdress);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int spi_Open(void)
{
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P6,
GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5, GPIO_PRIMARY_MODULE_FUNCTION);
/* Configuring SPI in 3wire master mode */
SPI_initMaster(EUSCI_B1_MODULE, &LIGHTspiConfig);
/* Enable SPI module */
SPI_enableModule(EUSCI_B1_MODULE);
return 0;//NONOS_RET_OK;
}
/*
* ======== MSP_EXP430F5529LP_initI2C ========
*/
void MSP_EXP430F5529LP_initI2C(void)
{
/*
* NOTE: TI-RTOS examples configure USCIB0 as either SPI or I2C. Thus,
* a conflict occurs when the I2C & SPI drivers are used simultaneously in
* an application. Modify the pin mux settings in this file and resolve the
* conflict before running your the application.
*/
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P3,
GPIO_PIN0 | GPIO_PIN1);
I2C_init();
}
void main (void)
{
//Stop WDT
WDT_hold(__MSP430_BASEADDRESS_WDT_A__);
//Assign I2C pins to USCI_B0
GPIO_setAsPeripheralModuleFunctionInputPin(__MSP430_BASEADDRESS_PORT3_R__,
GPIO_PORT_P3,
GPIO_PIN1 + GPIO_PIN2
);
//Initialize Master
I2C_masterInit(__MSP430_BASEADDRESS_USCI_B0__,
I2C_CLOCKSOURCE_SMCLK,
UCS_getSMCLK(__MSP430_BASEADDRESS_UCS__),
I2C_SET_DATA_RATE_400KBPS
);
//Specify slave address
I2C_setSlaveAddress(__MSP430_BASEADDRESS_USCI_B0__,
SLAVE_ADDRESS
);
//Set Master in receive mode
I2C_setMode(__MSP430_BASEADDRESS_USCI_B0__,
I2C_RECEIVE_MODE
);
//Enable I2C Module to start operations
I2C_enable(__MSP430_BASEADDRESS_USCI_B0__);
//Enable master Receive interrupt
I2C_enableInterrupt(__MSP430_BASEADDRESS_USCI_B0__,
I2C_RECEIVE_INTERRUPT
);
while (1)
{
//Initiate command to receive a single character from Slave
I2C_masterSingleReceiveStart(__MSP430_BASEADDRESS_USCI_B0__);
//Enter low power mode 0 with interrupts enabled.
//Wait until character is received.
__bis_SR_register(LPM0_bits + GIE);
__no_operation();
}
}
////------------------------------------------------------------------------------
Fd_t spi_Open(void)
{
/* Selecting P9.5 P9.6 and P9.7 in SPI mode */
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P6,
GPIO_PIN3 | GPIO_PIN4 | GPIO_PIN5, GPIO_PRIMARY_MODULE_FUNCTION);
/* CS setup. */
GPIO_setAsOutputPin(GPIO_PORT_P4, GPIO_PIN6);
GPIO_setOutputLowOnPin(GPIO_PORT_P4, GPIO_PIN6);
/* Configuring SPI in 3wire master mode */
SPI_initMaster(EUSCI_B1_MODULE, &SDspiConfig);
/* Enable SPI module */
SPI_enableModule(EUSCI_B1_MODULE);
return 0;//NONOS_RET_OK;
}
void msp430_i2c_init(void)
{
unsigned long _smclk;
if (i2c.enabled)
return;
/**Configure Pins for I2C
* Set P3.0 and P3.1 as Secondary Module Function Input.
* Select Port 3
* Set Pin 0, 1 to input Secondary Module Function, (UCB0SIMO/UCB0SDA, UCB0SOMI/UCB0SCL).
* */
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P3,
GPIO_PIN0 + GPIO_PIN1
);
_smclk = msp430_get_smclk_freq();
USCI_B_I2C_initMasterParam param = {0};
param.selectClockSource = USCI_B_I2C_CLOCKSOURCE_SMCLK;
param.i2cClk = _smclk;
param.dataRate = USCI_B_I2C_SET_DATA_RATE_400KBPS;
USCI_B_I2C_initMaster(USCI_B0_BASE, ¶m);
//Enable I2C Module to start operations
USCI_B_I2C_enable(USCI_B0_BASE);
USCI_B_I2C_clearInterrupt(USCI_B0_BASE,
USCI_B_I2C_TRANSMIT_INTERRUPT +
USCI_B_I2C_RECEIVE_INTERRUPT +
USCI_B_I2C_NAK_INTERRUPT
);
//Enable master Receive interrupt
USCI_B_I2C_enableInterrupt(USCI_B0_BASE,
USCI_B_I2C_TRANSMIT_INTERRUPT +
USCI_B_I2C_RECEIVE_INTERRUPT +
USCI_B_I2C_NAK_INTERRUPT
);
/* Initialize struct. */
i2c.state = STATE_WAITING;
i2c.slave_reg = 0;
i2c.data = 0;
i2c.length = 0;
i2c.enabled = 1;
}
/*P3.4 P3.5 上位机通信*/
int UartPCInit(void){
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P3,
GPIO_PIN4 + GPIO_PIN5
);
//Initialize UART module in auto baudrate detection multiprocessor mode
//Baudrate = 9600, clock freq = 1.048MHz
//UCBRx = 6, UCBRFx = 13, UCBRSx = 0, UCOS16 = 1
USCI_A_UART_initParam param = {0};
param.selectClockSource = USCI_A_UART_CLOCKSOURCE_SMCLK;
param.clockPrescalar = 6;
param.firstModReg = 13;
param.secondModReg = 0;
param.parity = USCI_A_UART_NO_PARITY;
param.msborLsbFirst = USCI_A_UART_LSB_FIRST;
param.numberofStopBits = USCI_A_UART_ONE_STOP_BIT;
param.uartMode = USCI_A_UART_AUTOMATIC_BAUDRATE_DETECTION_MODE;
param.overSampling = USCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION;
if(STATUS_FAIL == USCI_A_UART_init(USCI_A0_BASE, ¶m))
{
return 0;
}
//Enable UART module for operation
USCI_A_UART_enable(USCI_A0_BASE);
//Put UART to sleep/dormant mode toreceive break/sync first
// USCI_A_UART_setDormant(USCI_A0_BASE);
// Transmit Break
USCI_A_UART_transmitBreak(USCI_A0_BASE);
// Wait till ,odule is ready to transmit again
//Enable Receive Interrupt
//不使能
// USCI_A_UART_clearInterrupt(USCI_A0_BASE,
// USCI_A_UART_RECEIVE_INTERRUPT);
// USCI_A_UART_enableInterrupt(USCI_A0_BASE,
// USCI_A_UART_RECEIVE_INTERRUPT);
return 1;
}
/*
* ======== MSP_EXP430F5529LP_initSPI ========
*/
void MSP_EXP430F5529LP_initSPI(void)
{
/* USCIB1 */
/*
* NOTE: TI-RTOS examples configure USCIB0 as either SPI or I2C. Thus,
* a conflict occurs when the I2C & SPI drivers are used simultaneously in
* an application. Modify the pin mux settings in this file and resolve the
* conflict before running your the application.
*/
GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P4,
GPIO_PIN3 | GPIO_PIN2 | GPIO_PIN1);
/* SOMI/MISO */
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P4, GPIO_PIN2);
/* CLK and SIMO/MOSI */
GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P4,
GPIO_PIN3 | GPIO_PIN1);
SPI_init();
}
void main (void)
{
//Stop watchdog timer
WDT_hold(__MSP430_BASEADDRESS_WDT_A__);
//If clock signal from master stays low, it is not yet in SPI mode
while ( GPIO_INPUT_PIN_LOW ==
GPIO_getInputPinValue(__MSP430_BASEADDRESS_PORT3_R__,
GPIO_PORT_P3,
GPIO_PIN0
)) ;
//P3.5,4,0 option select
GPIO_setAsPeripheralModuleFunctionInputPin(__MSP430_BASEADDRESS_PORT3_R__,
GPIO_PORT_P3,
GPIO_PIN0 + GPIO_PIN4 + GPIO_PIN5
);
//Initialize slave to MSB first, inactive high clock polarity and 3 wire SPI
returnValue = SPI_slaveInit(__MSP430_BASEADDRESS_USCI_A0__,
SPI_MSB_FIRST,
SPI_PHASE_DATA_CAPTURED_ONFIRST_CHANGED_ON_NEXT,
SPI_CLOCKPOLARITY_INACTIVITY_HIGH
);
if (STATUS_FAIL == returnValue){
return;
}
//Enable SPI Module
SPI_enable(__MSP430_BASEADDRESS_USCI_A0__);
//Enable Receive interrupt
SPI_enableInterrupt(__MSP430_BASEADDRESS_USCI_A0__,
SPI_RECEIVE_INTERRUPT
);
//Enter LPM4, enable interrupts
__bis_SR_register(LPM4_bits + GIE);
}
void msp430_uart_init(unsigned long baud)
{
unsigned long divider;
unsigned long _smclk;
_smclk = msp430_get_smclk_freq();
/**Configure UART pins
* Set P4.4 and P4.5 as Secondary Module Function Input.
* Select Port 4
* Set Pin 4, 5 to input Secondary Module Function, (UCA1TXD/UCA1SIMO, UCA1RXD/UCA1SOMI).
**/
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P4,
GPIO_PIN4 + GPIO_PIN5
);
divider=(_smclk<<3)/baud; //fixed-point number: q3
// Configure UART
USCI_A_UART_initParam param = {0};
param.selectClockSource = USCI_A_UART_CLOCKSOURCE_SMCLK;
param.clockPrescalar = divider>>3;
param.firstModReg = 0;
param.secondModReg = (divider & 0x07);
param.parity = USCI_A_UART_NO_PARITY;
param.msborLsbFirst = USCI_A_UART_LSB_FIRST;
param.numberofStopBits = USCI_A_UART_ONE_STOP_BIT;
param.uartMode = USCI_A_UART_MODE;
param.overSampling = USCI_A_UART_LOW_FREQUENCY_BAUDRATE_GENERATION;
USCI_A_UART_init(USCI_A1_BASE, ¶m);
USCI_A_UART_enable(USCI_A1_BASE);
USCI_A_UART_clearInterrupt(USCI_A1_BASE,
USCI_A_UART_RECEIVE_INTERRUPT_FLAG);
// Enable USCI_A1 RX interrupt
USCI_A_UART_enableInterrupt(USCI_A1_BASE,
USCI_A_UART_RECEIVE_INTERRUPT); // Enable interrupt
}
int main(void)
{
/* Halting WDT */
WDT_A_holdTimer();
Interrupt_enableSleepOnIsrExit();
/* Initializing ADC (MCLK/1/1) */
ADC14_enableModule();
ADC14_initModule(ADC_CLOCKSOURCE_MCLK, ADC_PREDIVIDER_1, ADC_DIVIDER_1,
0);
/* Configuring ADC Memory (ADC_MEM0 A0/A1 Differential) in repeat mode
* with use of external references */
ADC14_configureSingleSampleMode(ADC_MEM0, true);
ADC14_configureConversionMemory(ADC_MEM0, ADC_VREFPOS_EXTPOS_VREFNEG_EXTNEG,
ADC_INPUT_A0, true);
/* Setting up GPIO pins as analog inputs (and references) */
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P5,
GPIO_PIN6 | GPIO_PIN5 | GPIO_PIN4, GPIO_TERTIARY_MODULE_FUNCTION);
/* Enabling sample timer in auto iteration mode and interrupts*/
ADC14_enableSampleTimer(ADC_AUTOMATIC_ITERATION);
ADC14_enableInterrupt(ADC_INT0);
/* Enabling Interrupts */
Interrupt_enableInterrupt(INT_ADC14);
Interrupt_enableMaster();
/* Triggering the start of the sample */
ADC14_enableConversion();
ADC14_toggleConversionTrigger();
/* Going to sleep */
while (1)
{
PCM_gotoLPM0();
}
}
void Board_init(void)
{
// Setup XT1 and XT2
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P5,
GPIO_PIN2 + GPIO_PIN3 +
GPIO_PIN4 + GPIO_PIN5
);
GPIO_setOutputLowOnPin(
GPIO_PORT_P1,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2 +
GPIO_PIN3 + GPIO_PIN4 + GPIO_PIN5
);
// Configure LED ports
GPIO_setAsOutputPin(
GPIO_PORT_P1,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2 +
GPIO_PIN3 + GPIO_PIN4 + GPIO_PIN5
);
GPIO_setOutputLowOnPin(
GPIO_PORT_P8,
GPIO_PIN1 + GPIO_PIN2
);
GPIO_setAsOutputPin(
GPIO_PORT_P8,
GPIO_PIN1 + GPIO_PIN2
);
// Configure button ports
// Buttons on P1.7/P2.2 are inputs
GPIO_setAsInputPin(
GPIO_PORT_PA,
GPIO_PIN7 + GPIO_PIN10
);
// Configure CapTouch ports
GPIO_setOutputLowOnPin(
GPIO_PORT_P1,
GPIO_PIN1 + GPIO_PIN2 + GPIO_PIN3 +
GPIO_PIN4 + GPIO_PIN5 + GPIO_PIN6
);
GPIO_setAsOutputPin(
GPIO_PORT_P1,
GPIO_PIN1 + GPIO_PIN2 + GPIO_PIN3 +
GPIO_PIN4 + GPIO_PIN5 + GPIO_PIN6
);
GPIO_setOutputLowOnPin(
GPIO_PORT_P6,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2 + GPIO_PIN3 +
GPIO_PIN4 + GPIO_PIN5 + GPIO_PIN6 + GPIO_PIN7
);
GPIO_setAsInputPin(
GPIO_PORT_P6,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2 + GPIO_PIN3 +
GPIO_PIN4 + GPIO_PIN5 + GPIO_PIN6 + GPIO_PIN7
);
// Configure Cma3000 ports
// ACCEL_INT pin is input
GPIO_setAsInputPin(
GPIO_PORT_P2,
GPIO_PIN5
);
// SCK
GPIO_setOutputLowOnPin(
GPIO_PORT_P2,
GPIO_PIN7
);
GPIO_setAsOutputPin(
GPIO_PORT_P2,
GPIO_PIN7
);
// ACCEL_SIMO, ACCEL_CS, ACCEL_PWR to low
GPIO_setOutputLowOnPin(
GPIO_PORT_P3,
GPIO_PIN3 + GPIO_PIN5 + GPIO_PIN6
);
// ACCEL_SOMI pin is input
GPIO_setAsInputPin(
GPIO_PORT_P3,
GPIO_PIN4
);
// ACCEL_SIMO, ACCEL_CS, ACCEL_PWR as outp
GPIO_setAsOutputPin(
GPIO_PORT_P3,
GPIO_PIN3 + GPIO_PIN5 + GPIO_PIN6
);
// Configure Dogs102x6 ports
// LCD_C/D, LCD_RST
GPIO_setOutputLowOnPin(
GPIO_PORT_P5,
GPIO_PIN6 + GPIO_PIN7
);
GPIO_setAsOutputPin(
GPIO_PORT_P5,
GPIO_PIN6 + GPIO_PIN7
);
// LCD_CS, LCD_BL_EN
GPIO_setOutputLowOnPin(
GPIO_PORT_P7,
GPIO_PIN4 + GPIO_PIN6
);
GPIO_setAsOutputPin(
GPIO_PORT_P7,
GPIO_PIN4 + GPIO_PIN6
);
// SIMO, SCK
GPIO_setOutputLowOnPin(
GPIO_PORT_P4,
GPIO_PIN1 + GPIO_PIN3
);
// SOMI pin is input
GPIO_setAsInputPin(
GPIO_PORT_P4,
GPIO_PIN2
);
GPIO_setAsOutputPin(
GPIO_PORT_P4,
GPIO_PIN1 + GPIO_PIN3
);
// Configure SDCard ports
// SD_CS to high
GPIO_setOutputHighOnPin(
GPIO_PORT_P3,
GPIO_PIN7
);
GPIO_setAsOutputPin(
GPIO_PORT_P3,
GPIO_PIN7
);
// Configure Wheel ports
// A5 ADC input
GPIO_setAsInputPin(
GPIO_PORT_P6,
GPIO_PIN5
);
// POT_PWR
GPIO_setOutputLowOnPin(
GPIO_PORT_P8,
GPIO_PIN0
);
GPIO_setAsOutputPin(
GPIO_PORT_P8,
GPIO_PIN0
);
// Configure unused ports for low power
GPIO_setOutputLowOnPin(
GPIO_PORT_P2,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN3 +
GPIO_PIN4 + GPIO_PIN6
);
GPIO_setAsOutputPin(
GPIO_PORT_P2,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN3 +
GPIO_PIN4 + GPIO_PIN6
);
GPIO_setOutputLowOnPin(
GPIO_PORT_P3,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2
);
GPIO_setAsOutputPin(
GPIO_PORT_P3,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2
);
GPIO_setOutputLowOnPin(
GPIO_PORT_P4,
GPIO_PIN0 + GPIO_PIN6 + GPIO_PIN7
);
GPIO_setAsOutputPin(
GPIO_PORT_P4,
GPIO_PIN0 + GPIO_PIN6 + GPIO_PIN7
);
GPIO_setOutputLowOnPin(
GPIO_PORT_P5,
GPIO_PIN1
);
GPIO_setAsOutputPin(
GPIO_PORT_P5,
GPIO_PIN1
);
GPIO_setOutputLowOnPin(
GPIO_PORT_P6,
GPIO_PIN6 + GPIO_PIN7
);
GPIO_setAsOutputPin(
GPIO_PORT_P6,
GPIO_PIN6 + GPIO_PIN7
);
GPIO_setOutputLowOnPin(
GPIO_PORT_P7,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2 +
GPIO_PIN3 + GPIO_PIN5+ GPIO_PIN7
);
GPIO_setAsOutputPin(
GPIO_PORT_P7,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2 +
GPIO_PIN3 + GPIO_PIN5+ GPIO_PIN7
);
}
void initClocks()
{
// Set core power mode
PMM_setVCore(PMM_CORE_LEVEL_3);
// Configure pins for crystals
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P5,
GPIO_PIN4+GPIO_PIN2
);
GPIO_setAsPeripheralModuleFunctionOutputPin(
GPIO_PORT_P5,
GPIO_PIN5+GPIO_PIN3
);
// Inform the system of the crystal frequencies
UCS_setExternalClockSource(
XT1_FREQ, // Frequency of XT1 in Hz.
XT2_FREQ // Frequency of XT2 in Hz.
);
// Initialize the crystals
UCS_turnOnXT2( // used to be UCS_XT2Start in previous driverlib version
UCS_XT2_DRIVE_4MHZ_8MHZ
);
UCS_turnOnLFXT1( //used to be UCS_LFXT1Start in previous driverlib version
UCS_XT1_DRIVE_0,
UCS_XCAP_3
);
UCS_initClockSignal(
UCS_FLLREF, // The reference for Frequency Locked Loop
UCS_XT2CLK_SELECT, // Select XT2
UCS_CLOCK_DIVIDER_4 // The FLL reference will be 1 MHz (4MHz XT2/4)
);
// Start the FLL and let it settle
// This becomes the MCLCK and SMCLK automatically
UCS_initFLLSettle(
MCLK_FREQ_KHZ,
MCLK_FLLREF_RATIO
);
// Optional: set SMCLK to something else than full speed
UCS_initClockSignal(
UCS_SMCLK,
UCS_DCOCLKDIV_SELECT,
UCS_CLOCK_DIVIDER_1
);
// Set auxiliary clock
UCS_initClockSignal(
UCS_ACLK,
UCS_XT1CLK_SELECT,
UCS_CLOCK_DIVIDER_1
);
}
int main(void)
{
WDT_A_holdTimer();
//Configure Timer
unsigned int dcoFrequency = 3E+6;
MAP_CS_setDCOFrequency(dcoFrequency);
MAP_CS_initClockSignal(CS_SMCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_1); // ( 3Mhz / 64 ) / (Period = 46875) = 1 second
//Set LED's as outputs and turn off
MAP_GPIO_setAsOutputPin(GPIO_PORT_P1,GPIO_PIN0);
MAP_GPIO_setAsOutputPin(GPIO_PORT_P2,GPIO_PIN0);
MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN0);
////////////////////////////////////////////////////////////////////////////////////////////////////
// ADC INITILIZATION P5.5
////////////////////////////////////////////////////////////////////////////////////////////////////
/* Initializing ADC */
MAP_ADC14_enableModule();
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P5, GPIO_PIN5, GPIO_TERTIARY_MODULE_FUNCTION); //writes 0's in PXSEL registers for pins 1.2 and 1.3
MAP_ADC14_setResolution(ADC_10BIT); // initialize to use a 10 Bit ADC
MAP_ADC14_initModule(ADC_CLOCKSOURCE_SMCLK, ADC_PREDIVIDER_1, ADC_DIVIDER_1,0);
/* Configuring ADC Memory */
MAP_ADC14_configureSingleSampleMode(ADC_MEM0, false); //put results in this 16 bit register location to hold results, false means we are manually triggering
MAP_ADC14_configureConversionMemory(ADC_MEM0, ADC_VREFPOS_AVCC_VREFNEG_VSS, ADC_INPUT_A0, false); //pin 5.5 is tied to channel 0 (A0)
/* Configuring Sample Timer */
MAP_ADC14_enableSampleTimer(ADC_MANUAL_ITERATION);
//Timer A setup
MAP_Timer_A_configureUpMode(TIMER_A0_MODULE, &upConfig0);
Interrupt_enableInterrupt(INT_TA0_0);
Timer_A_startCounter(TIMER_A0_MODULE, TIMER_A_UP_MODE);
/* Enabling/Toggling Conversion */
MAP_ADC14_enableConversion();
MAP_ADC14_toggleConversionTrigger();
////////////////////////////////////////////////////////////////////////////////////////////////////
// END ADC
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
// Timer A 2 and PWM on P5.6
////////////////////////////////////////////////////////////////////////////////////////////////////
GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P5, GPIO_PIN6, GPIO_PRIMARY_MODULE_FUNCTION); //writes 0's in PXSEL registers for pins 1.2 and 1.3
// Set Timer A period (PWM signal period)
TA2CCR0 = 10000 ; // i think i wrote this wring, his example he showed in class is is 10000
// Set Duty cycle
TA2CCR1 = DUTY_CYCLE * 10000; //inital DutyCycle of 0%.. Duty_Cycle is macro
// Set output mode to Reset/Set
TA2CCTL1 = OUTMOD_7 ; // Macro which is equal to 0x00e0, defined in msp432p401r.h
// Initialize Timer A
TA2CTL = TASSEL__SMCLK | MC__UP | TACLR ; // this bitwise or’s multiple settings at the same time (this just sets different bits in the register to set these functionalities/settings)
//Does this start the timer?? (is next line necessary?)
Timer_A_startCounter(TIMER_A2_MODULE, TIMER_A_UP_MODE);
////////////////////////////////////////////////////////////////////////////////////////////////////
// END Timer A 2 and PWM on 5.6
////////////////////////////////////////////////////////////////////////////////////////////////////
Interrupt_enableMaster() ;
while(1){
while(MAP_ADC14_isBusy()==0){ // poll the busy flag. we have a conversion going bc we already triggerted it above, so we are waiting for the conversion to be done, when it is, we are going to call the get result function. this just returns the 16 bit value rsults
ADC_result = (uint16_t)MAP_ADC14_getResult(ADC_MEM0); //just goes to memory location takes results and returns the 16 bit value... this just continues to get repopulted.
MAP_ADC14_toggleConversionTrigger(); ////once we got the result we start a new conversion and we go back to top and begin wiaitng until its dones again
}//end nested while
}//end inf while
}//end main
void clock_init(clock_speed_t speed) {
// Turn on XT1 crystal
#ifndef USE_DRIVERLIB
P5SEL |= BIT4;
UCSCTL6 |= XCAP_3; // Internal load cap of 12pF
do { // Wait until XT1 stabilizes
UCSCTL7 &= ~(XT1LFOFFG + DCOFFG); // Clear XT1 fault flag
//
// The DCO fault flag is also cleared,
// since it is supposed to be faulty at startup
// and thus OFIFG will continue to be set unless
// we clear it...
SFRIFG1 &= ~OFIFG; // Clear oscillator fault flag
} while (SFRIFG1 & OFIFG); // Re-test oscillator fault flag
UCSCTL6 &= ~XT1DRIVE_3; // Decrease XT1 drive as it is stabilized
#else
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P5, GPIO_PIN4);
UCS_turnOnLFXT1(XT1DRIVE_0, UCS_XCAP_3);
#endif
// Set the FLL reference select to XT1 (external 32KHz clock),
// and set the FLL reference divider to 1
#ifndef USE_DRIVERLIB
UCSCTL3 = SELREF__XT1CLK | FLLREFDIV_0;
// Set the MCLK source to DCOCLKDIV
UCSCTL4 = (UCSCTL4 & ~SELM_7) | SELM__DCOCLKDIV;
// Set the SMCLK source to DCOCLKDIV
UCSCTL4 = (UCSCTL4 & ~SELS_7) | SELS__DCOCLKDIV;
#else
UCS_initClockSignal(
UCS_FLLREF,
UCS_XT1CLK_SELECT,
UCS_CLOCK_DIVIDER_1);
#endif
// Initialize the FLL
#ifndef USE_DRIVERLIB
__bis_SR_register(SCG0); // Disable the FLL control loop
UCSCTL0 = 0x0000; // Set lowest possible DCOx, MODx
uint16_t ratio;
switch (speed) {
case CLKSPEED_16MHZ:
clock_speed = 16000000;
ratio = clock_speed/XT1_FREQ;
UCSCTL1 = DCORSEL_6;
UCSCTL2 = FLLD_1 | (ratio - 1); // FLLD doesn't really matter, since we feed MCLK and SMCLK off DCOCLKDIV and not DCOCLK
break;
case CLKSPEED_1MHZ:
clock_speed = 1000000;
ratio = clock_speed/XT1_FREQ;
UCSCTL1 = DCORSEL_2;
UCSCTL2 = FLLD_1 | (ratio - 1); // FLLD doesn't really matter, since we feed MCLK and SMCLK off DCOCLKDIV and not DCOCLK
break;
}
__bic_SR_register(SCG0); // Enable the FLL control loop
do { // Wait until DCO stabilizes
UCSCTL7 &= ~(DCOFFG); // Clear DCO fault flag
SFRIFG1 &= ~OFIFG; // Clear oscillator fault flag
} while (SFRIFG1 & OFIFG); // Re-test oscillator fault flag
// Worst-case settling time for the DCO when the DCO range bits have been
// changed is n x 32 x 32 x f_MCLK / f_FLL_reference. See UCS chapter in 5xx
// UG for optimization.
while (ratio--)
__delay_cycles(32*32);
#else
switch (speed) {
case CLKSPEED_16MHZ:
clock_speed = 16000000;
break;
case CLKSPEED_1MHZ:
clock_speed = 1000000;
break;
}
UCS_initFLLSettle(clock_speed/1000, clock_speed/XT1_FREQ);
#endif
}
void InitReservoirLevelPins(){
GPIO_setAsPeripheralModuleFunctionInputPin( SENSOR_LEVEL_PORT, SENSOR_LEVEL_PIN );
}
/*
@@********************* CYC_SYS_UART_Initialize ***************************************
* Function :
* Description :
* Input parameters :
* Output parameters:
* Return :
* Note :
******************************************************************************
*/
uint8_t CYC_SYS_UART0_Initialize()
{
// Set the values
UINT32 __IO lu32ACLKValue = 0;
uint8_t lsReturnValue = SUCCESS;
// Get Auxiliary Clock Source value
lu32ACLKValue = UCS_getACLK(UCS_BASE);
#ifdef TARGET_MSP430F5438A_EXPERIMENTER_BOARD
//P3.4,5 = USCI_A0 TXD/RXD
GPIO_setAsPeripheralModuleFunctionOutputPin(
GPIO_PORT_P3,
GPIO_PIN4
);
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P3,
GPIO_PIN5
);
#endif
#ifdef TARGET_CYCLOPS_GAME
//P3.3 = USCI_A0 TXD
GPIO_setAsPeripheralModuleFunctionOutputPin(
GPIO_PORT_P3,
GPIO_PIN3
);
//P3.4 = USCI_A0 RXD
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P3,
GPIO_PIN4
);
#endif
/*
Call the MSP43Ware function to initialize the UART port with the following configurations
1. PORT 0
2. Use SMCLK as Source
3. Value of SMCLK is 12MHz
4. Prescalar value to generate 57600 is 208
5. First stage modulator value is 5
6. Second stage modulator is ignored and value is set to 0
7. No Parity bits
*/
/*CHANGE THIS SO WE CAN SET ANY BAUD RATE WE WANT, DATA SHEET PG 907*/
USCI_UART_initAdvance ( UART_PORT_0_BASE_ADDRESS,
USCI_UART_CLOCKSOURCE_SMCLK,
BAUDRATE_CLK_PRESCALER,
FIRST_STAGE_MODULATOR_VALUE,
SECOND_STAGE_MODULATOR_VALUE,
USCI_UART_NO_PARITY,
USCI_UART_LSB_FIRST,
USCI_UART_ONE_STOP_BIT,
USCI_UART_MODE,
USCI_UART_OVERSAMPLING_BAUDRATE_GENERATION
);
//Enable UART module for operation
USCI_UART_enable(USCI_A0_BASE);
//Enable Receive Interrupt
USCI_UART_clearInterruptFlag(USCI_A0_BASE,
USCI_UART_RECEIVE_INTERRUPT
);
USCI_UART_enableInterrupt(USCI_A0_BASE,
USCI_UART_RECEIVE_INTERRUPT
);
return lsReturnValue;
}
void main(void)
{
//Stop Watchdog Timer
WDT_A_hold(WDT_A_BASE);
PowerLevel_3();
Clk_MCLK_24M_SMCLK_3M_ACLK_32768Hz();
//Enable A/D channel inputs
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P6,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2 +
GPIO_PIN3 + GPIO_PIN4 + GPIO_PIN5 +
GPIO_PIN6 + GPIO_PIN7
);
//Initialize the ADC12_A Module
/*
* Base address of ADC12_A Module
* Use internal ADC12_A bit as sample/hold signal to start conversion
* USE MODOSC 5MHZ Digital Oscillator as clock source
* Use default clock divider of 1
*/
ADC12_A_init(ADC12_A_BASE,
ADC12_A_SAMPLEHOLDSOURCE_SC,
ADC12_A_CLOCKSOURCE_ADC12OSC,
ADC12_A_CLOCKDIVIDER_1
);
ADC12_A_enable(ADC12_A_BASE);
/*
* Base address of ADC12_A Module
* For memory buffers 0-7 sample/hold for 256 clock cycles
* For memory buffers 8-15 sample/hold for 4 clock cycles (default)
* Enable Multiple Sampling
*/
ADC12_A_setupSamplingTimer(ADC12_A_BASE,
ADC12_A_CYCLEHOLD_256_CYCLES,
ADC12_A_CYCLEHOLD_4_CYCLES,
ADC12_A_MULTIPLESAMPLESENABLE);
//Configure Memory Buffers
/*
* Base address of the ADC12_A Module
* Configure memory buffer 0
* Map input A0 to memory buffer 0
* Vref+ = AVcc
* Vref- = AVss
* Memory buffer 0 is not the end of a sequence
*/
ADC12_A_configureMemoryParam param0 = {0};
param0.memoryBufferControlIndex = ADC12_A_MEMORY_0;
param0.inputSourceSelect = ADC12_A_INPUT_A0;
param0.positiveRefVoltageSourceSelect = ADC12_A_VREFPOS_AVCC;
param0.negativeRefVoltageSourceSelect = ADC12_A_VREFNEG_AVSS;
param0.endOfSequence = ADC12_A_NOTENDOFSEQUENCE;
ADC12_A_configureMemory(ADC12_A_BASE,¶m0);
/*
* Base address of the ADC12_A Module
* Configure memory buffer 1
* Map input A1 to memory buffer 1
* Vref+ = AVcc
* Vref- = AVss
* Memory buffer 1 is not the end of a sequence
*
*/
ADC12_A_configureMemoryParam param1 = {0};
param1.memoryBufferControlIndex = ADC12_A_MEMORY_1;
param1.inputSourceSelect = ADC12_A_INPUT_A1;
param1.positiveRefVoltageSourceSelect = ADC12_A_VREFPOS_AVCC;
param1.negativeRefVoltageSourceSelect = ADC12_A_VREFNEG_AVSS;
param1.endOfSequence = ADC12_A_NOTENDOFSEQUENCE;
ADC12_A_configureMemory(ADC12_A_BASE,¶m1);
/*
* Base address of the ADC12_A Module
* Configure memory buffer 2
* Map input A2 to memory buffer 2
* Vref+ = AVcc
* Vref- = AVss
* Memory buffer 2 is not the end of a sequence
*/
ADC12_A_configureMemoryParam param2 = {0};
param2.memoryBufferControlIndex = ADC12_A_MEMORY_2;
param2.inputSourceSelect = ADC12_A_INPUT_A2;
param2.positiveRefVoltageSourceSelect = ADC12_A_VREFPOS_AVCC;
param2.negativeRefVoltageSourceSelect = ADC12_A_VREFNEG_AVSS;
param2.endOfSequence = ADC12_A_NOTENDOFSEQUENCE;
ADC12_A_configureMemory(ADC12_A_BASE,¶m2);
/*
* Base address of the ADC12_A Module
* Configure memory buffer 3
* Map input A3 to memory buffer 3
* Vr+ = AVcc
* Vr- = AVss
* Memory buffer 3 IS the end of a sequence
*/
ADC12_A_configureMemoryParam param3 = {0};
param3.memoryBufferControlIndex = ADC12_A_MEMORY_3;
param3.inputSourceSelect = ADC12_A_INPUT_A3;
param3.positiveRefVoltageSourceSelect = ADC12_A_VREFPOS_AVCC;
param3.negativeRefVoltageSourceSelect = ADC12_A_VREFNEG_AVSS;
param3.endOfSequence = ADC12_A_ENDOFSEQUENCE;
ADC12_A_configureMemory(ADC12_A_BASE,¶m3);
//Enable memory buffer 3 interrupt
ADC12_A_clearInterrupt(ADC12_A_BASE,
ADC12IFG3);
ADC12_A_enableInterrupt(ADC12_A_BASE,
ADC12IE3);
//Enable/Start first sampling and conversion cycle
/*
* Base address of ADC12_A Module
* Start the conversion into memory buffer 0
* Use the repeated sequence of channels
*/
ADC12_A_startConversion(ADC12_A_BASE,
ADC12_A_MEMORY_0,
ADC12_A_REPEATED_SEQOFCHANNELS);
//Enter LPM0, Enable interrupts
__bis_SR_register(LPM0_bits + GIE);
//For debugger
__no_operation();
}
static inline void _uart0_gpio_init(void){
GPIO_setAsPeripheralModuleFunctionInputPin(
uC_PORTSEL_UART0,
(uC_PINSEL_UART0_TX | uC_PINSEL_UART0_RX)
);
}
void ADCInit(void)
{
GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P6,
GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2 +
GPIO_PIN3
);
//Initialize the ADC12_A Module
/*
* Base address of ADC12_A Module
* Use internal ADC12_A bit as sample/hold signal to start conversion
* USE MODOSC 5MHZ Digital Oscillator as clock source
* Use default clock divider of 1
*/
ADC12_A_init(ADC12_A_BASE,
ADC12_A_SAMPLEHOLDSOURCE_SC,
ADC12_A_CLOCKSOURCE_ADC12OSC,
ADC12_A_CLOCKDIVIDER_1
);
ADC12_A_enable(ADC12_A_BASE);
/*
* Base address of ADC12_A Module
* For memory buffers 0-7 sample/hold for 256 clock cycles
* For memory buffers 8-15 sample/hold for 4 clock cycles (default)
* Enable Multiple Sampling
*/
ADC12_A_setupSamplingTimer(ADC12_A_BASE,
ADC12_A_CYCLEHOLD_256_CYCLES,
ADC12_A_CYCLEHOLD_4_CYCLES,
ADC12_A_MULTIPLESAMPLESENABLE);
//Configure Memory Buffers
/*
* Base address of the ADC12_A Module
* Configure memory buffer 0
* Map input A0 to memory buffer 0
* Vref+ = AVcc
* Vref- = AVss
* Memory buffer 0 is not the end of a sequence
*/
ADC12_A_configureMemoryParam param0 = {0};
param0.memoryBufferControlIndex = ADC12_A_MEMORY_0;
param0.inputSourceSelect = ADC12_A_INPUT_A0;
param0.positiveRefVoltageSourceSelect = ADC12_A_VREFPOS_AVCC;
param0.negativeRefVoltageSourceSelect = ADC12_A_VREFNEG_AVSS;
param0.endOfSequence = ADC12_A_NOTENDOFSEQUENCE;
ADC12_A_configureMemory(ADC12_A_BASE,¶m0);
/*
* Base address of the ADC12_A Module
* Configure memory buffer 1
* Map input A1 to memory buffer 1
* Vref+ = AVcc
* Vref- = AVss
* Memory buffer 1 is not the end of a sequence
*
*/
ADC12_A_configureMemoryParam param1 = {0};
param1.memoryBufferControlIndex = ADC12_A_MEMORY_1;
param1.inputSourceSelect = ADC12_A_INPUT_A1;
param1.positiveRefVoltageSourceSelect = ADC12_A_VREFPOS_AVCC;
param1.negativeRefVoltageSourceSelect = ADC12_A_VREFNEG_AVSS;
param1.endOfSequence = ADC12_A_NOTENDOFSEQUENCE;
ADC12_A_configureMemory(ADC12_A_BASE,¶m1);
/*
* Base address of the ADC12_A Module
* Configure memory buffer 2
* Map input A2 to memory buffer 2
* Vref+ = AVcc
* Vref- = AVss
* Memory buffer 2 is not the end of a sequence
*/
ADC12_A_configureMemoryParam param2 = {0};
param2.memoryBufferControlIndex = ADC12_A_MEMORY_2;
param2.inputSourceSelect = ADC12_A_INPUT_A2;
param2.positiveRefVoltageSourceSelect = ADC12_A_VREFPOS_AVCC;
param2.negativeRefVoltageSourceSelect = ADC12_A_VREFNEG_AVSS;
param2.endOfSequence = ADC12_A_ENDOFSEQUENCE;
ADC12_A_configureMemory(ADC12_A_BASE,¶m2);
ADC12_A_startConversion(ADC12_A_BASE,
ADC12_A_MEMORY_0,
ADC12_A_REPEATED_SEQOFCHANNELS);
}
uint8_t CYC_SYS_UART1_Initialize()
{
// Set the values
UINT32 __IO lu32ACLKValue = 0;
uint8_t lsReturnValue = SUCCESS;
// Get Auxiliary Clock Source value
lu32ACLKValue = UCS_getACLK(UCS_BASE);
#ifdef TARGET_MSP430F5438A_EXPERIMENTER_BOARD
//P3.4,5 = USCI_A0 TXD/RXD
GPIO_setAsPeripheralModuleFunctionOutputPin(
GPIO_PORT_P3,
GPIO_PIN4
);
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P3,
GPIO_PIN5
);
#endif
#ifdef TARGET_CYCLOPS_GAME
//P3.3 = USCI_A0 TXD
GPIO_setAsPeripheralModuleFunctionOutputPin(
GPIO_PORT_P4,
GPIO_PIN4
);
//P3.4 = USCI_A0 RXD
GPIO_setAsPeripheralModuleFunctionInputPin(
GPIO_PORT_P4,
GPIO_PIN5
);
#endif
/*
Call the MSP43Ware function to initialize the UART port with the following configurations
1. PORT 1
2. Use SMCLK as Source
3. Value of SMCLK is 12MHz
4. Prescalar value to generate 57600 is 208
5. First stage modulator value is 5
6. Second stage modulator is ignored and value is set to 0
7. No Parity bits
*/
USCI_UART_initAdvance ( UART_PORT_1_BASE_ADDRESS,
USCI_UART_CLOCKSOURCE_SMCLK,
BAUDRATE_CLK_PRESCALER,
FIRST_STAGE_MODULATOR_VALUE,
SECOND_STAGE_MODULATOR_VALUE,
USCI_UART_NO_PARITY,
USCI_UART_LSB_FIRST,
USCI_UART_ONE_STOP_BIT,
USCI_UART_MODE,
USCI_UART_OVERSAMPLING_BAUDRATE_GENERATION
);
//Enable UART module for operation
USCI_UART_enable(USCI_A1_BASE);
//Enable Receive Interrupt
USCI_UART_clearInterruptFlag(USCI_A1_BASE,
USCI_UART_RECEIVE_INTERRUPT
);
USCI_UART_enableInterrupt(USCI_A1_BASE,
USCI_UART_RECEIVE_INTERRUPT
);
GPIO_setAsOutputPin(GPIO_PORT_P4, GPIO_PIN3); /*CTS line. Should be HIGH when we are processing received data. should be LOW when we are Ready to receive data*/
GPIO_setAsInputPin(GPIO_PORT_P4, GPIO_PIN0); /*RTS line. Should be LOW if it is OK to send data. Will be HIGH when it is not ok to send data*/
GPIO_setOutputLowOnPin(GPIO_PORT_P4,GPIO_PIN3 ); /*make it low because we are ready to receive data*/
return lsReturnValue;
}
