/* * ======== 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; } }