Part Number:MSP432P4111
Tool/software: Code Composer Studio
I'm trying to program a relatively basic thing, a stopwatch. I have a MSP432P4111 launchpad which has a built in LCD.
1. My project needs to be triggered by an switch, to start and stop the clock
2. Show the time on an LCD
3. Display the same time via UART, and hopefully Bluetooth later
4. Be accurate to the millisecond.
I've reviewed example projects like:
lcd_f_animated_text_MSP_EXP432P4111_nortos_ccs uartecho_MSP_EXP432P4111_nortos_ccs gpio_input_interrupt_MSP_EXP432P4111_nortos_ccs msp432p411x_rtc_04_MSP_EXP432P4111_nortos_ccs
It seems like all of the example projects have different included files or build options, like if i try to add " #include <ti/devices/msp432p4xx/driverlib/driverlib.h> " to a project that didn't have it already I always get ""C:/ti/simplelink_msp432p4_sdk_2_40_00_10/source/ti/devices/msp432p4xx/inc/msp.h", line 76: fatal error #35: #error directive: "Failed to match a default include file" "
It's extremely frustrating, if I programmed this with Arduino I would be done in a day, but I have to use code composer studio for "school reasons". I know Arduino isn't as fast or accurate but it's really nice how the same code works on different boards.
Can someone please tell me how to make a project with all the necessary includes and options for my project?
This is the code i have so far, it's based off the animate text example. I tried to mix and match different examples but it's not working right.
please help!
//Combined with gpio interrupt
//* MSP432 LCD_F Animated Text
#include <ti/devices/msp432p4xx/driverlib/driverlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
#include <ti/drivers/GPIO.h>
#include <ti/drivers/UART.h>
#include "ti/devices/msp432p4xx/inc/msp.h"
int t =0;
int i1;
int i2;
int i3;
int i4;
int i5;
int i6;
// RTC interrupt service routine
void RTC_C_IRQHandler(void)
{
// Toggles P1.0 every second
if (RTC_C->PS1CTL & RTC_C_PS1CTL_RT1PSIFG)
{
// P1->OUT ^= BIT0;
t++;
// Clear the pre-scalar timer interrupt flag
RTC_C->PS1CTL &= ~(RTC_C_PS1CTL_RT1PSIFG);
}
}
// Definitions for LCD Driver
#define char1 16 // Digit A1 - L16
#define char2 32 // Digit A2 - L32
#define char3 40 // Digit A3 - L40
#define char4 36 // Digit A4 - L36
#define char5 28 // Digit A5 - L28
#define char6 44 // Digit A6 - L44
// LCD memory map for numeric digits (Byte Access)
const char digit[10][4] =
{
{0xC, 0xF, 0x8, 0x2}, /* "0" LCD segments a+b+c+d+e+f+k+q */
{0x0, 0x6, 0x0, 0x2}, /* "1" */
{0xB, 0xD, 0x0, 0x0}, /* "2" */
{0x3, 0xF, 0x0, 0x0}, /* "3" */
{0x7, 0x6, 0x0, 0x0}, /* "4" */
{0x7, 0xB, 0x0, 0x0}, /* "5" */
{0xF, 0xB, 0x0, 0x0}, /* "6" */
{0x4, 0xE, 0x0, 0x0}, /* "7" */
{0xF, 0xF, 0x0, 0x0}, /* "8" */
{0x7, 0xF, 0x0, 0x0} /* "9" */
};
// LCD memory map for uppercase letters (Byte Access)
const char alphabetBig[26][4] =
{
{0xF, 0xE, 0x0, 0x0}, /* "A" LCD segments a+b+c+e+f+g+m */
{0x1, 0xF, 0x0, 0x5}, /* "B" */
{0xC, 0x9, 0x0, 0x0}, /* "C" */
{0x0, 0xF, 0x0, 0x5}, /* "D" */
{0xF, 0x9, 0x0, 0x0}, /* "E" */
{0xF, 0x8, 0x0, 0x0}, /* "F" */
{0xD, 0xB, 0x0, 0x0}, /* "G" */
{0xF, 0x6, 0x0, 0x0}, /* "H" */
{0x0, 0x9, 0x0, 0x5}, /* "I" */
{0x8, 0x7, 0x0, 0x0}, /* "J" */
{0xE, 0x0, 0x2, 0x2}, /* "K" */
{0xC, 0x1, 0x0, 0x0}, /* "L" */
{0xC, 0x6, 0x0, 0xA}, /* "M" */
{0xC, 0x6, 0x2, 0x8}, /* "N" */
{0xC, 0xF, 0x0, 0x0}, /* "O" */
{0xF, 0xC, 0x0, 0x0}, /* "P" */
{0xC, 0xF, 0x2, 0x0}, /* "Q" */
{0xF, 0xC, 0x2, 0x0}, /* "R" */
{0x7, 0xB, 0x0, 0x0}, /* "S" */
{0x0, 0x8, 0x0, 0x5}, /* "T" */
{0xC, 0x7, 0x0, 0x0}, /* "U" */
{0xC, 0x0, 0x8, 0x2}, /* "V" */
{0xC, 0x6, 0xA, 0x0}, /* "W" */
{0x0, 0x0, 0xA, 0xA}, /* "X" */
{0x0, 0x0, 0x0, 0xB}, /* "Y" */
{0x0, 0x9, 0x8, 0x2} /* "Z" */
};
static void showChar(char c, int position)
{
uint8_t ii;
if (c == ' ')
{
for (ii=0; ii<4; ii++)
{
LCD_F->M[position+ii] |= 0x00;
}
}
else if (c >= '0' && c <= '9')
{
for (ii=0; ii<4; ii++)
{
LCD_F->M[position+ii] |= digit[c-48][ii];
}
}
else if (c >= 'A' && c <= 'Z')
{
for (ii=0; ii<4; ii++)
{
LCD_F->M[position+ii] |= alphabetBig[c-65][ii];
}
} else
{
LCD_F->M[position] = 0xFF;
}
}
// Configuration Structure for LCD
LCD_F_Config lcdConf =
{
.clockSource = LCD_F_CLOCKSOURCE_ACLK,
.clockDivider = LCD_F_CLOCKDIVIDER_32,
.clockPrescaler = LCD_F_CLOCKPRESCALER_1,
.muxRate = LCD_F_4_MUX,
.waveforms = LCD_F_STANDARD_WAVEFORMS,
.segments = LCD_F_SEGMENTS_ENABLED
};
int main(void)
{
// Halting the Watchdog
WDT_A_holdTimer();
// Enabling MASTER interrupts
Interrupt_enableMaster();
int i1 = 0;
int i2 = 0;
int i3 = 0;
int i4 = 0;
int i5 = 0;
int i6 = 0;
/* UART wont word DX
// UART_write(UART_Handle handle, const void *buffer, size_t size);
// mainThread(NULL);
// char input;
char echoPrompt[] = "Test:\r\n";
UART_Handle uart;
UART_Params uartParams;
GPIO_init();
UART_init();
// GPIO_setConfig(Board_GPIO_LED0, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);
// GPIO_write(Board_GPIO_LED0, Board_GPIO_LED_ON);
UART_write(uart, echoPrompt, sizeof(echoPrompt));
*/
//Setting MCLK to REFO at 128Khz for LF mode
CS_setReferenceOscillatorFrequency(CS_REFO_128KHZ);
CS_initClockSignal(CS_MCLK, CS_REFOCLK_SELECT, CS_CLOCK_DIVIDER_1);
PCM_setPowerState(PCM_AM_LF_VCORE0);
// Configuring GPIO
GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN1);
GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN1);
// Configuring P1.0 as output and P1.1 (switch) as input
GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN2);
GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN1);
// Configuring P1.1 as an input and enabling interrupts
GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN1);
GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1);
GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN1);
Interrupt_enableInterrupt(INT_PORT1);
// MAP_GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN1);
// MAP_GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1);
// MAP_GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN1);
// Configuring Timer32 to 128000 (1s) of MCLK in periodic mode
Timer32_initModule(TIMER32_BASE, TIMER32_PRESCALER_1, TIMER32_32BIT, TIMER32_PERIODIC_MODE);
// Enabling interrupts
// MAP_Interrupt_enableInterrupt(INT_PORT1);
Interrupt_enableInterrupt(INT_T32_INT1);
Interrupt_enableMaster();
// Initializing all of the function selection bits in the pins
P3->SEL1 |= 0xF2;
P6->SEL1 |= 0x0C;
P7->SEL1 |= 0xF0;
P8->SEL1 |= 0xFC;
P9->SEL1 |= 0xFF;
P10->SEL1 |= 0x3F;
// Setting ACLK to the reference oscillator
CS_initClockSignal(CS_ACLK, CS_REFOCLK_SELECT, CS_CLOCK_DIVIDER_1);
// Initializing the LCD_F module
LCD_F_initModule(&lcdConf);
// Clearing out all memory
LCD_F_clearAllMemory();
// Initializing all of our pins and setting the relevant COM lines
LCD_F_setPinsAsLCDFunction(LCD_F_SEGMENT_LINE_0, LCD_F_SEGMENT_LINE_3);
LCD_F_setPinAsLCDFunction(LCD_F_SEGMENT_LINE_6);
LCD_F_setPinsAsLCDFunction(LCD_F_SEGMENT_LINE_16, LCD_F_SEGMENT_LINE_19);
LCD_F_setPinsAsLCDFunction(LCD_F_SEGMENT_LINE_26, LCD_F_SEGMENT_LINE_47);
LCD_F_setPinAsCOM(LCD_F_SEGMENT_LINE_26, LCD_F_MEMORY_COM0);
LCD_F_setPinAsCOM(LCD_F_SEGMENT_LINE_27, LCD_F_MEMORY_COM1);
LCD_F_setPinAsCOM(LCD_F_SEGMENT_LINE_6, LCD_F_MEMORY_COM2);
LCD_F_setPinAsCOM(LCD_F_SEGMENT_LINE_3, LCD_F_MEMORY_COM3);
// Turing the LCD_F module on
LCD_F_turnOn();
// number + '0' = char of that number =D cool
showChar(i1 + '0', char1);
showChar(i2 + '0', char2);
showChar(i3 + '0', char3);
showChar(i4 + '0', char4);
showChar(i5 + '0', char5);
showChar(i6 + '0', char6);
PCM_gotoLPM0();
// Enabling SRAM Bank Retention
SysCtl_A_enableSRAMRetention(0x20002000, 0x20002000);
GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN2);
GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN1);
// Configure Port J
PJ->DIR |= (BIT2 | BIT3); PJ->OUT &= ~(BIT2 | BIT3);
PJ->SEL0 |= BIT0 | BIT1; // set LFXT pin as second function
CS->KEY = CS_KEY_VAL ; // Unlock CS module for register access
CS->CTL2 |= CS_CTL2_LFXT_EN; // LFXT on
// Loop until XT1, XT2 & DCO fault flag is cleared
do
{
// Clear XT2,XT1,DCO fault flags
CS->CLRIFG |= CS_CLRIFG_CLR_DCOR_OPNIFG | CS_CLRIFG_CLR_HFXTIFG |
CS_CLRIFG_CLR_LFXTIFG | CS_CLRIFG_CLR_FCNTLFIFG;
SYSCTL_A->NMI_CTLSTAT &= ~ SYSCTL_A_NMI_CTLSTAT_CS_SRC;
} while ((SYSCTL_A->NMI_CTLSTAT | SYSCTL_A_NMI_CTLSTAT_CS_FLG)
&& (CS->IFG & CS_IFG_LFXTIFG)); // Test oscillator fault flag
// Select ACLK as LFXTCLK
CS->CTL1 &= ~(CS_CTL1_SELA_MASK) | CS_CTL1_SELA_0;
CS->KEY = 0; // Lock CS module from unintended accesses
// Configure RTC
// Unlock RTC key protected registers
RTC_C->CTL0 = RTC_C_KEY;
RTC_C->CTL13 = RTC_C_CTL13_HOLD | // Hold the RTC for now
RTC_C_CTL13_MODE | // Set the RTC to calendar mode
RTC_C_CTL13_BCD; // BCD mode
RTC_C->PS1CTL = RTC_C_PS1CTL_RT1IP__2 | // set divider to 128
RTC_C_PS1CTL_RT1PSIE; // Enable pre-scaler interrupt enable
// Start RTC calendar mode
RTC_C->CTL13 = RTC_C->CTL13 & ~(RTC_C_CTL13_HOLD);
// Lock the RTC registers
RTC_C->CTL0 = RTC_C->CTL0 & ~(RTC_C_CTL0_KEY_MASK);
// Enable all SRAM bank retentions prior to going to LPM3
SYSCTL_A->SRAM_BANKEN_CTL0 = SYSCTL_A_SRAM_BANKEN_CTL0_BNK0_EN
| SYSCTL_A_SRAM_BANKEN_CTL0_BNK1_EN
| SYSCTL_A_SRAM_BANKEN_CTL0_BNK2_EN
| SYSCTL_A_SRAM_BANKEN_CTL0_BNK3_EN;
// Enable retention for all blocks within each bank (8blks/bank x 4banks=32 blocks)
SYSCTL_A->SRAM_BLKRET_CTL0 = 0xFFFFFFFF;
// Enable global interrupt
__enable_irq();
// Enable the RTC_C in the NVIC module
NVIC->ISER[0] = 1 << ((RTC_C_IRQn) & 31);
// Sleep on exit from ISR
//SCB->SCR |= SCB_SCR_SLEEPONEXIT_Msk;
// Ensures SLEEPONEXIT takes effect immediately
// __DSB();
while (1)
{
// Initializing all of our pins and setting the relevant COM lines
LCD_F_setPinsAsLCDFunction(LCD_F_SEGMENT_LINE_0, LCD_F_SEGMENT_LINE_3);
LCD_F_setPinAsLCDFunction(LCD_F_SEGMENT_LINE_6);
LCD_F_setPinsAsLCDFunction(LCD_F_SEGMENT_LINE_16, LCD_F_SEGMENT_LINE_19);
LCD_F_setPinsAsLCDFunction(LCD_F_SEGMENT_LINE_26, LCD_F_SEGMENT_LINE_47);
LCD_F_setPinAsCOM(LCD_F_SEGMENT_LINE_26, LCD_F_MEMORY_COM0);
LCD_F_setPinAsCOM(LCD_F_SEGMENT_LINE_27, LCD_F_MEMORY_COM1);
LCD_F_setPinAsCOM(LCD_F_SEGMENT_LINE_6, LCD_F_MEMORY_COM2);
LCD_F_setPinAsCOM(LCD_F_SEGMENT_LINE_3, LCD_F_MEMORY_COM3);
//uint8_t frame1 = showChar(i6 + '0', char6);
// Set battery animation frames
LCD_F->ANM[0] = 0x11; // Frame 1 // Not sure why this is the same as frame 1
LCD_F->ANM[1] = 0x11; // Frame 2 //but displays something else... ?
LCD_F->ANM[2] = 0x31; // Frame 3
// LCD_F->ANM[3] = 0x33; // Frame 4
// LCD_F->ANM[4] = 0x73; // Frame 5
// LCD_F->ANM[5] = 0x77; // Frame 6
// LCD_F->ANM[6] = 0xF7; // Frame 7
// LCD_F->ANM[7] = 0xFF; // Frame 8
// Configuring and enabling animation
LCD_F_setAnimationControl(LCD_F_ANIMATION_FREQ_CLOCK_PRESCALAR_512,
LCD_F_ANIMATION_FREQ_CLOCK_DIVIDER_8,
LCD_F_ANIMATION_FRAMES_T0_TO_T3);
LCD_F_enableAnimation();
// Turing the LCD_F module on
LCD_F_turnOn();
// Going into LPM0
PCM_gotoLPM3(); // ?
PCM_gotoLPM0();
// GPIO_toggleOutputOnPin(GPIO_PORT_P2, GPIO_PIN2);
// Initializing all of the function selection bits in the pins
P3->SEL1 |= 0xF2;
P6->SEL1 |= 0x0C;
P7->SEL1 |= 0xF0;
P8->SEL1 |= 0xFC;
P9->SEL1 |= 0xFF;
P10->SEL1 |= 0x3F;
// Setting ACLK to the reference oscillator
CS_initClockSignal(CS_ACLK, CS_REFOCLK_SELECT, CS_CLOCK_DIVIDER_1);
// Initializing the LCD_F module
LCD_F_initModule(&lcdConf);
// Clearing out all memory
LCD_F_clearAllMemory();
i6++;
if (i6 ==10 )
{
i6=0;
i5 ++;
}
if (i5 ==10 )
{
i5=0;
i4 ++;
}
if (i4 ==10 )
{
i4=0;
i3 ++;
}
if (i3 ==10 )
{
i3=0;
i2 ++;
}
if (i2 ==10 )
{
i2=0;
i1 ++;
}
LCD_F_turnOn();
showChar(i1 + '0', char1);
showChar(i2 + '0', char2);
showChar(i3 + '0', char3);
showChar(i4 + '0', char4);
showChar(i5 + '0', char5);
showChar(i6 + '0', char6);
PCM_gotoLPM0();
// Going to LPM3
PCM_gotoLPM3(); // ?
// Setting the sleep deep bit
// SCB->SCR |= (SCB_SCR_SLEEPDEEP_Msk);
// __sleep();
}
}
// GPIO ISR
void PORT1_IRQHandler(void)
{
uint32_t status;
status = GPIO_getEnabledInterruptStatus(GPIO_PORT_P1);
GPIO_clearInterruptFlag(GPIO_PORT_P1, status);
// Toggling the output on the LED
if(status & GPIO_PIN1)
{
// GPIO_toggleOutputOnPin(GPIO_PORT_P1, GPIO_PIN0);
GPIO_toggleOutputOnPin(GPIO_PORT_P2, GPIO_PIN1);
GPIO_toggleOutputOnPin(GPIO_PORT_P2, GPIO_PIN2);
// showChar(i1 + '0', char1);
// showChar(i2 + '0', char2);
// showChar(i3 + '0', char3);
// showChar(i4 + '0', char4);
// showChar(i5 + '0', char5);
// showChar(i6 + '0', char6);
}
}
// Timer32 ISR
void T32_INT1_IRQHandler(void)
{
MAP_Timer32_clearInterruptFlag(TIMER32_BASE);
MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN1);
MAP_GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN1);
//t1++;
}