/*
* ======== MSP_EXP432P401R_initUART ========
*/
void MSP_EXP432P401R_initUART(void)
{
/* Set P1.2 & P1.3 in UART mode */
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);
/* Set P3.2 & P3.3 in UART mode */
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P3,
GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);
/* Initialize the UART driver */
UART_init();
}
void DWire::_initSlave( void )
{
// Init the pins
MAP_GPIO_setAsPeripheralModuleFunctionInputPin( modulePort, modulePins,
GPIO_PRIMARY_MODULE_FUNCTION );
// initialise driverlib
MAP_I2C_initSlave( module, slaveAddress, EUSCI_B_I2C_OWN_ADDRESS_OFFSET0,
EUSCI_B_I2C_OWN_ADDRESS_ENABLE );
// Enable the module and enable interrupts
MAP_I2C_enableModule( module );
MAP_I2C_clearInterruptFlag( module,
EUSCI_B_I2C_RECEIVE_INTERRUPT0 | EUSCI_B_I2C_STOP_INTERRUPT
| EUSCI_B_I2C_TRANSMIT_INTERRUPT0 | EUSCI_B_I2C_CLOCK_LOW_TIMEOUT_INTERRUPT );
MAP_I2C_enableInterrupt( module,
EUSCI_B_I2C_RECEIVE_INTERRUPT0 | EUSCI_B_I2C_STOP_INTERRUPT
| EUSCI_B_I2C_TRANSMIT_INTERRUPT0 | EUSCI_B_I2C_CLOCK_LOW_TIMEOUT_INTERRUPT );
/* Enable the clock low timeout */
EUSCI_B_CMSIS( module )->CTLW1 = (EUSCI_B_CMSIS( module )->CTLW1
& ~EUSCI_B_CTLW1_CLTO_MASK) | 0xC0;
MAP_Interrupt_enableInterrupt( intModule );
MAP_Interrupt_enableMaster( );
}
void A110x2500SpiWrite(unsigned char address,
const unsigned char *buffer,
unsigned char count)
{
digitalWrite(RF_SPI_CSN,LOW);
// Look for CHIP_RDYn from radio.
pinMode(RF_SPI_MISO, INPUT);
while (digitalRead(RF_SPI_MISO));
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1, GPIO_PIN7, GPIO_PRIMARY_MODULE_FUNCTION);
SPI_enableModule(EUSCI_B0_BASE);
// Write the address/command byte.
SPI.transfer(address);
// Write dummy byte(s) and read response(s).
for (unsigned char i = 0; i < count; i++)
{
SPI.transfer(buffer[i]);
}
// Note: It is assumed that the Energia SPI driver waits until the USCIB0
// peripheral is done being busy before returning to the caller.
digitalWrite(RF_SPI_CSN,HIGH);
SPI_disableModule(EUSCI_B0_BASE);
}
void setup_adc(){
/* Setting reference voltage to 2.5 and enabling reference */
REF_A_setReferenceVoltage(REF_A_VREF2_5V);
MAP_REF_A_enableReferenceVoltage();
MAP_ADC14_enableModule();
//~47 KHz
MAP_ADC14_initModule(ADC_CLOCKSOURCE_MCLK, ADC_PREDIVIDER_32, ADC_DIVIDER_2, 0);
/* Configuring GPIOs for Analog In */
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P5,
GPIO_PIN5 | GPIO_PIN4 | GPIO_PIN3 | GPIO_PIN2, GPIO_TERTIARY_MODULE_FUNCTION);
/* Configuring ADC Memory (ADC_MEM0 - ADC_MEM7 (A0 - A1) with no repeat)
* with internal 2.5v reference */
MAP_ADC14_configureMultiSequenceMode(ADC_MEM0, ADC_MEM3, true);
MAP_ADC14_configureConversionMemory(ADC_MEM0, ADC_VREFPOS_INTBUF_VREFNEG_VSS, ADC_INPUT_A0, false);
MAP_ADC14_configureConversionMemory(ADC_MEM1, ADC_VREFPOS_INTBUF_VREFNEG_VSS, ADC_INPUT_A1, false);
MAP_ADC14_configureConversionMemory(ADC_MEM2, ADC_VREFPOS_INTBUF_VREFNEG_VSS, ADC_INPUT_A2, false);
MAP_ADC14_configureConversionMemory(ADC_MEM3, ADC_VREFPOS_INTBUF_VREFNEG_VSS, ADC_INPUT_A3, false);
/* Setting up the sample timer to automatically step through the sequence convert.*/
MAP_ADC14_enableSampleTimer(ADC_AUTOMATIC_ITERATION);
/* Triggering the start of the sample */
MAP_ADC14_enableConversion();
MAP_ADC14_toggleConversionTrigger();
}
static void prvSetupHardware( void )
{
extern void FPU_enableModule( void );
/* The clocks are not configured here, but inside main_full() and
main_blinky() as the full demo uses a fast clock and the blinky demo uses
a slow clock. */
/* Stop the watchdog timer. */
MAP_WDT_A_holdTimer();
/* Ensure the FPU is enabled. */
FPU_enableModule();
/* Selecting P1.2 and P1.3 in UART mode and P1.0 as output (LED) */
MAP_GPIO_setAsPeripheralModuleFunctionInputPin( GPIO_PORT_P1, GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION );
MAP_GPIO_setOutputLowOnPin( GPIO_PORT_P1, GPIO_PIN0 );
MAP_GPIO_setAsOutputPin( GPIO_PORT_P1, GPIO_PIN0 );
/* Enable S2 and LED2 */
MAP_GPIO_setOutputLowOnPin( GPIO_PORT_P2, GPIO_PIN0 );
MAP_GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN0);
MAP_GPIO_setOutputLowOnPin( GPIO_PORT_P2, GPIO_PIN1 );
MAP_GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN1);
MAP_GPIO_setOutputLowOnPin( GPIO_PORT_P2, GPIO_PIN2 );
MAP_GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN2);
MAP_GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN4);
MAP_GPIO_interruptEdgeSelect(GPIO_PORT_P1, GPIO_PIN4, GPIO_HIGH_TO_LOW_TRANSITION);
MAP_GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN4);
MAP_GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN4);
MAP_Interrupt_enableInterrupt(INT_PORT1);
}
int main(void)
{
/* Halting WDT */
MAP_WDT_A_holdTimer();
/* Selecting P1.2 and P1.3 in UART mode */
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);
/* Setting DCO to 12MHz */
CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_12);
/* Configuring UART Module */
MAP_UART_initModule(EUSCI_A0_MODULE, &uartConfig);
/* Enable UART module */
MAP_UART_enableModule(EUSCI_A0_MODULE);
/* Enabling interrupts */
MAP_UART_enableInterrupt(EUSCI_A0_MODULE, EUSCI_A_UART_RECEIVE_INTERRUPT);
MAP_Interrupt_enableInterrupt(INT_EUSCIA0);
MAP_Interrupt_enableSleepOnIsrExit();
MAP_Interrupt_enableMaster();
while(1)
{
MAP_PCM_gotoLPM0();
}
}
int main(void)
{
/* Halting WDT */
MAP_WDT_A_holdTimer();
/* Selecting P1.2 and P1.3 in UART mode and P1.0 as output (LED) */
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);
MAP_GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
/* Setting DCO to 48MHz (upping Vcore) */
MAP_PCM_setCoreVoltageLevel(PCM_VCORE1);
CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_48);
/* Configuring UART Module */
MAP_UART_initModule(EUSCI_A0_MODULE, &uartConfig);
/* Enable UART module */
MAP_UART_enableModule(EUSCI_A0_MODULE);
/* Enabling interrupts */
MAP_UART_enableInterrupt(EUSCI_A0_MODULE, EUSCI_A_UART_RECEIVE_INTERRUPT);
MAP_Interrupt_enableInterrupt(INT_EUSCIA0);
MAP_Interrupt_enableSleepOnIsrExit();
while(1)
{
MAP_UART_transmitData(EUSCI_A0_MODULE, TXData);
MAP_Interrupt_enableSleepOnIsrExit();
MAP_PCM_gotoLPM0InterruptSafe();
}
}
/**
* Called to set the eUSCI module in 'master' mode
*/
void DWire::_initMaster(const eUSCI_I2C_MasterConfig * i2cConfig) {
// Initialise the pins
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(modulePort, modulePins,
GPIO_PRIMARY_MODULE_FUNCTION);
// Initializing I2C Master to SMCLK at 400kbs with no autostop
MAP_I2C_initMaster(module, i2cConfig);
// Specify slave address
MAP_I2C_setSlaveAddress(module, slaveAddress);
// Set Master in transmit mode
MAP_I2C_setMode(module, EUSCI_B_I2C_TRANSMIT_MODE);
// Enable I2C Module to start operations
MAP_I2C_enableModule(module);
// Enable and clear the interrupt flag
MAP_I2C_clearInterruptFlag(module,
EUSCI_B_I2C_TRANSMIT_INTERRUPT0 + EUSCI_B_I2C_NAK_INTERRUPT
+ EUSCI_B_I2C_RECEIVE_INTERRUPT0);
// Enable master interrupts
MAP_I2C_enableInterrupt(module,
EUSCI_B_I2C_TRANSMIT_INTERRUPT0 + EUSCI_B_I2C_NAK_INTERRUPT
+ EUSCI_B_I2C_RECEIVE_INTERRUPT0);
// Register the interrupts on the correct module
MAP_Interrupt_enableInterrupt(intModule);
MAP_Interrupt_enableMaster();
}
void DWire::_resetBus( void )
{
/* Reset buffers */
*pTxBufferIndex = 0;
*pTxBufferSize = 0;
*pRxBufferIndex = 0;
*pRxBufferSize = 0;
/* Reset the module */
MAP_I2C_disableModule( module );
/* Perform bus clear according to I2C-bus Specification and User Manual
* (UM10204) section 3.1.16
*/
if (this->isMaster( ))
{
MAP_GPIO_setOutputLowOnPin( modulePort, moduleSCL );
for (uint_fast8_t i = 0; i < 9; i++)
{
MAP_GPIO_setAsOutputPin( modulePort, moduleSCL );
this->_I2CDelay( );
MAP_GPIO_setAsInputPin( modulePort, moduleSCL );
this->_I2CDelay( );
}
MAP_GPIO_setAsPeripheralModuleFunctionInputPin( modulePort,
moduleSCL, GPIO_PRIMARY_MODULE_FUNCTION );
}
/* Re-enable the module */
MAP_I2C_enableModule( module );
}
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
}
int main(int argc, char **argv)
{
/*
* Configure pins as uart.
*/
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);
testStart();
return 0;
}
int main(void)
{
/* Halting WDT */
MAP_WDT_A_holdTimer();
MAP_Interrupt_enableSleepOnIsrExit();
resPos = 0;
/* Setting up clocks
* MCLK = MCLK = 3MHz
* ACLK = REFO/4 = 32Khz */
MAP_CS_initClockSignal(CS_ACLK, CS_REFOCLK_SELECT, CS_CLOCK_DIVIDER_1);
/* Initializing ADC (MCLK/1/1) */
MAP_ADC14_enableModule();
MAP_ADC14_initModule(ADC_CLOCKSOURCE_MCLK, ADC_PREDIVIDER_1, ADC_DIVIDER_1,
0);
/* Configuring GPIOs (5.5 A0) */
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P5, GPIO_PIN5,
GPIO_TERTIARY_MODULE_FUNCTION);
/* Configuring ADC Memory */
MAP_ADC14_configureSingleSampleMode(ADC_MEM0, true);
MAP_ADC14_configureConversionMemory(ADC_MEM0, ADC_VREFPOS_AVCC_VREFNEG_VSS,
ADC_INPUT_A0, false);
/* Configuring Timer_A in continuous mode and sourced from ACLK */
MAP_Timer_A_configureContinuousMode(TIMER_A0_MODULE, &continuousModeConfig);
/* Configuring Timer_A0 in CCR1 to trigger at 16000 (0.5s) */
MAP_Timer_A_initCompare(TIMER_A0_MODULE, &compareConfig);
/* Configuring the sample trigger to be sourced from Timer_A0 and setting it
* to automatic iteration after it is triggered*/
MAP_ADC14_setSampleHoldTrigger(ADC_TRIGGER_SOURCE1, false);
/* Enabling the interrupt when a conversion on channel 1 is complete and
* enabling conversions */
MAP_ADC14_enableInterrupt(ADC_INT0);
MAP_ADC14_enableConversion();
/* Enabling Interrupts */
MAP_Interrupt_enableInterrupt(INT_ADC14);
MAP_Interrupt_enableMaster();
/* Starting the Timer */
MAP_Timer_A_startCounter(TIMER_A0_MODULE, TIMER_A_CONTINUOUS_MODE);
/* Going to sleep */
while (1)
{
MAP_PCM_gotoLPM0();
}
}
int main(void)
{
volatile uint32_t ii;
/* Stop WDT */
MAP_WDT_A_holdTimer();
/*
* Select Port 7
* Set Pin 1 to output Primary Module Function, (COUT).
*/
MAP_GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P7, GPIO_PIN1,
GPIO_PRIMARY_MODULE_FUNCTION);
/* Set P7.7 to be comparator in (C0.2) */
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P7, GPIO_PIN7,
GPIO_TERTIARY_MODULE_FUNCTION);
/* Initialize the Comparator E module
* Comparator Instance 0,
* Pin CE2 to Positive(+) Terminal,
* Reference Voltage to Negative(-) Terminal,
* Normal Power Mode,
* Output Filter On with max delay,
* Non-Inverted Output Polarity
*/
MAP_COMP_E_initModule(COMP_E0_MODULE, &compConfig);
/*Set the reference voltage that is being supplied to the (-) terminal
* Comparator Instance 0,
* Reference Voltage of 2.0 V,
* Lower Limit of 2.0*(32/32) = 2.0V,
* Upper Limit of 2.0*(32/32) = 2.0V
*/
MAP_COMP_E_setReferenceVoltage(COMP_E0_MODULE, COMP_E_VREFBASE2_0V, 32, 32);
/* Disable Input Buffer on P1.2/CE2
* Base Address of Comparator E,
* Input Buffer port
* Selecting the CEx input pin to the comparator
* multiplexer with the CEx bits automatically
* disables output driver and input buffer for
* that pin, regardless of the state of the
* associated CEPD.x bit
*/
MAP_COMP_E_disableInputBuffer(COMP_E0_MODULE, COMP_E_INPUT2);
/* Allow power to Comparator module */
MAP_COMP_E_enableModule(COMP_E0_MODULE);
MAP_PCM_gotoLPM0();
__no_operation();
}
/*
* ======== MSP_EXP432P401R_initSPI ========
*/
void MSP_EXP432P401R_initSPI(void)
{
/*
* NOTE: TI-RTOS examples configure EUSCIB0 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.
*/
/* Configure CLK, MOSI & MISO for SPI0 (EUSCI_B0) */
MAP_GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P1,
GPIO_PIN5 | GPIO_PIN6, GPIO_PRIMARY_MODULE_FUNCTION);
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1, GPIO_PIN7,
GPIO_PRIMARY_MODULE_FUNCTION);
/* Configure CLK, MOSI & MISO for SPI1 (EUSCI_B2) */
MAP_GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P3,
GPIO_PIN5 | GPIO_PIN6, GPIO_PRIMARY_MODULE_FUNCTION);
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P3, GPIO_PIN7,
GPIO_PRIMARY_MODULE_FUNCTION);
MSP_EXP432P401R_initDMA();
SPI_init();
}
/*
* ======== MSP_EXP432P401R_initI2C ========
*/
void MSP_EXP432P401R_initI2C(void)
{
/*
* NOTE: TI-RTOS examples configure EUSCIB0 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.
*/
/* Configure Pins 1.6 & 1.7 as SDA & SCL, respectively. */
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
GPIO_PIN6 | GPIO_PIN7, GPIO_PRIMARY_MODULE_FUNCTION);
/* Initialize the I2C driver */
I2C_init();
}
int main(void)
{
uint32_t ii;
/* Disabling the Watchdog */
MAP_WDT_A_holdTimer();
xferIndex = 0;
/* Select Port 1 for I2C - Set Pin 6, 7 to input Primary Module Function,
* (UCB0SIMO/UCB0SDA, UCB0SOMI/UCB0SCL).
*/
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
GPIO_PIN6 + GPIO_PIN7, GPIO_PRIMARY_MODULE_FUNCTION);
/* Configuring GPIO P1.0 to be an input. As the GPIO is pulled up by the
* master, when the port is set to an input the pull-up defaults and the
* pin is high. When the interrupt is asserted, we set the GPIO to an
* output low and cause the interrupt to occur.
*/
MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN1);
MAP_GPIO_setAsInputPin(GPIO_PORT_P1, GPIO_PIN0);
/* eUSCI I2C Slave Configuration */
MAP_I2C_initSlave(EUSCI_B0_MODULE, SLAVE_ADDRESS_1, EUSCI_B_I2C_OWN_ADDRESS_OFFSET0,
EUSCI_B_I2C_OWN_ADDRESS_ENABLE);
/* Enable the module and enable interrupts */
MAP_I2C_enableModule(EUSCI_B0_MODULE);
MAP_Interrupt_enableInterrupt(INT_EUSCIB0);
/* Sleeping while not in use */
while (1)
{
/* Delaying between transactions */
for(ii=0;ii<4000;ii++);
/* Initiating the read from the master by asserting our GPIO */
MAP_I2C_enableInterrupt(EUSCI_B0_MODULE, EUSCI_B_I2C_TRANSMIT_INTERRUPT0);
MAP_GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
MAP_Interrupt_enableSleepOnIsrExit();
MAP_PCM_gotoLPM0InterruptSafe();
}
}
int main(void)
{
/* Disabling the Watchdog */
MAP_WDT_A_holdTimer();
xferIndex_0 = 0;
xferIndex_1 = 0;
/* Select Port 1 for I2C - Set Pin 6, 7 to input Primary Module Function,
* (UCB0SIMO/UCB0SDA, UCB0SOMI/UCB0SCL).
*/
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
GPIO_PIN6 + GPIO_PIN7, GPIO_PRIMARY_MODULE_FUNCTION);
/* eUSCI I2C Slave Configuration */
/* Slave Address 1 (0x48) */
MAP_I2C_initSlave(EUSCI_B0_MODULE, SLAVE_ADDRESS_1,
EUSCI_B_I2C_OWN_ADDRESS_OFFSET0,
EUSCI_B_I2C_OWN_ADDRESS_ENABLE);
/* Slave Address 1 (0x49) */
MAP_I2C_initSlave(EUSCI_B0_MODULE, SLAVE_ADDRESS_2,
EUSCI_B_I2C_OWN_ADDRESS_OFFSET1,
EUSCI_B_I2C_OWN_ADDRESS_ENABLE);
/* Set in receive mode */
MAP_I2C_setMode(EUSCI_B0_MODULE, EUSCI_B_I2C_RECEIVE_MODE);
/* Enable the module and enable interrupts */
MAP_I2C_enableModule(EUSCI_B0_MODULE);
MAP_I2C_clearInterruptFlag(EUSCI_B0_MODULE,
EUSCI_B_I2C_RECEIVE_INTERRUPT0 | EUSCI_B_I2C_RECEIVE_INTERRUPT1);
MAP_I2C_enableInterrupt(EUSCI_B0_MODULE,
EUSCI_B_I2C_RECEIVE_INTERRUPT0 | EUSCI_B_I2C_RECEIVE_INTERRUPT1);
MAP_Interrupt_enableSleepOnIsrExit();
MAP_Interrupt_enableInterrupt(INT_EUSCIB0);
MAP_Interrupt_enableMaster();
/* Sleeping while not in use */
while (1)
{
MAP_PCM_gotoLPM0();
}
}
static void prvSetupHardware( void )
{
extern void FPU_enableModule( void );
/* The clocks are not configured here, but inside main_full() and
main_blinky() as the full demo uses a fast clock and the blinky demo uses
a slow clock. */
/* Stop the watchdog timer. */
MAP_WDT_A_holdTimer();
/* Ensure the FPU is enabled. */
FPU_enableModule();
/* Selecting P1.2 and P1.3 in UART mode and P1.0 as output (LED) */
MAP_GPIO_setAsPeripheralModuleFunctionInputPin( GPIO_PORT_P1, GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION );
MAP_GPIO_setOutputLowOnPin( GPIO_PORT_P1, GPIO_PIN0 );
MAP_GPIO_setAsOutputPin( GPIO_PORT_P1, GPIO_PIN0 );
}
int main(void)
{
/* Halting WDT */
MAP_WDT_A_holdTimer();
/* Selecting P1.2 and P1.3 in UART mode */
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);
/* Setting DCO to 12MHz */
CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_12);
/* Configuring UART Module */
MAP_UART_initModule(EUSCI_A0_MODULE, &uartConfig);
/* Enable UART module */
MAP_UART_enableModule(EUSCI_A0_MODULE);
MAP_Interrupt_enableMaster();
/* Initialize values to display */
char *s = "printf test";
char c = '!';
int i = -12345;
unsigned u = 4321;
long int l = -123456780;
long unsigned n = 1098765432;
unsigned x = 0xABCD;
while(1)
{
printf(EUSCI_A0_MODULE, "String %s\r\n", s);
printf(EUSCI_A0_MODULE, "Char %c\r\n", c);
printf(EUSCI_A0_MODULE, "Integer %i\r\n", i);
printf(EUSCI_A0_MODULE, "Unsigned %u\r\n", u);
printf(EUSCI_A0_MODULE, "Long %l\r\n", l);
printf(EUSCI_A0_MODULE, "uNsigned loNg %n\r\n", n);
printf(EUSCI_A0_MODULE, "heX %x\r\n", x);
}
}
/*
* ======== MSP_EXP432P401R_initWiFi ========
*/
void MSP_EXP432P401R_initWiFi(void)
{
/* Configure EN & CS pins to disable CC3100 */
MAP_GPIO_setAsOutputPin(GPIO_PORT_P3, GPIO_PIN0);
MAP_GPIO_setAsOutputPin(GPIO_PORT_P4, GPIO_PIN1);
MAP_GPIO_setOutputHighOnPin(GPIO_PORT_P3, GPIO_PIN0);
MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P4, GPIO_PIN1);
/* Configure CLK, MOSI & MISO for SPI0 (EUSCI_B0) */
MAP_GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P1,
GPIO_PIN5 | GPIO_PIN6, GPIO_PRIMARY_MODULE_FUNCTION);
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1, GPIO_PIN7,
GPIO_PRIMARY_MODULE_FUNCTION);
/* Configure IRQ pin */
MAP_GPIO_setAsInputPinWithPullDownResistor(GPIO_PORT_P2, GPIO_PIN5);
MAP_GPIO_interruptEdgeSelect(GPIO_PORT_P2, GPIO_PIN5,
GPIO_LOW_TO_HIGH_TRANSITION);
/* Initialize SPI and WiFi drivers */
MSP_EXP432P401R_initDMA();
SPI_init();
WiFi_init();
}
void DWire::_initSlave(void) {
// Init the pins
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(modulePort, modulePins,
GPIO_PRIMARY_MODULE_FUNCTION);
// initialise driverlib
MAP_I2C_initSlave(module, slaveAddress, EUSCI_B_I2C_OWN_ADDRESS_OFFSET0,
EUSCI_B_I2C_OWN_ADDRESS_ENABLE);
// Enable the module
MAP_I2C_enableModule(module);
// Enable the module and enable interrupts
MAP_I2C_enableModule(module);
MAP_I2C_clearInterruptFlag(module,
EUSCI_B_I2C_RECEIVE_INTERRUPT0 | EUSCI_B_I2C_STOP_INTERRUPT
| EUSCI_B_I2C_TRANSMIT_INTERRUPT0);
MAP_I2C_enableInterrupt(module,
EUSCI_B_I2C_RECEIVE_INTERRUPT0 | EUSCI_B_I2C_STOP_INTERRUPT
| EUSCI_B_I2C_TRANSMIT_INTERRUPT0);
//MAP_Interrupt_enableSleepOnIsrExit();
MAP_Interrupt_enableInterrupt(intModule);
MAP_Interrupt_enableMaster();
}
int main(void)
{
volatile uint32_t ii;
/* Disabling the Watchdog */
MAP_WDT_A_holdTimer();
/* Select Port 1 for I2C - Set Pin 6, 7 to input Primary Module Function,
* (UCB0SIMO/UCB0SDA, UCB0SOMI/UCB0SCL).
*/
MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
GPIO_PIN6 + GPIO_PIN7, GPIO_PRIMARY_MODULE_FUNCTION);
sendStopCondition = false;
sendToSlaveAddress2 = false;
/* Initializing I2C Master to SMCLK at 400kbs with no autostop */
MAP_I2C_initMaster(EUSCI_B0_MODULE, &i2cConfig);
/* Specify slave address. For start we will do our first slave address */
MAP_I2C_setSlaveAddress(EUSCI_B0_MODULE, SLAVE_ADDRESS_1);
/* Set Master in receive mode */
MAP_I2C_setMode(EUSCI_B0_MODULE, EUSCI_B_I2C_TRANSMIT_MODE);
/* Enable I2C Module to start operations */
MAP_I2C_enableModule(EUSCI_B0_MODULE);
/* Enable and clear the interrupt flag */
MAP_I2C_clearInterruptFlag(EUSCI_B0_MODULE,
EUSCI_B_I2C_TRANSMIT_INTERRUPT0 + EUSCI_B_I2C_NAK_INTERRUPT);
//Enable master Receive interrupt
MAP_I2C_enableInterrupt(EUSCI_B0_MODULE,
EUSCI_B_I2C_TRANSMIT_INTERRUPT0 + EUSCI_B_I2C_NAK_INTERRUPT);
MAP_Interrupt_enableInterrupt(INT_EUSCIB0);
while (1)
{
/* Load Byte Counter */
TXByteCtr = 4;
/* Making sure the last transaction has been completely sent out */
while (MAP_I2C_masterIsStopSent(EUSCI_B0_MODULE) == EUSCI_B_I2C_SENDING_STOP);
/* Sending the initial start condition for appropriate
* slave addresses */
if(sendToSlaveAddress2)
{
MAP_I2C_setSlaveAddress(EUSCI_B0_MODULE, SLAVE_ADDRESS_2);
}
else
{
MAP_I2C_setSlaveAddress(EUSCI_B0_MODULE, SLAVE_ADDRESS_1);
}
MAP_I2C_masterSendMultiByteStart(EUSCI_B0_MODULE, TXData++);
while(sendStopCondition == false)
{
/* Go to sleep while data is being transmitted */
MAP_Interrupt_enableSleepOnIsrExit();
MAP_PCM_gotoLPM0InterruptSafe();
}
sendStopCondition = false;
}
}
