//*****************************************************************************
//
//! Initialize LEDs
//!
//! \param none
//!
//! \return none
//!
//! \brief Initializes LED Ports and Pins
//
//*****************************************************************************
void initLEDs()
{
// Enable use of PORTF to toggle LED and disable interrupt on this port
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Unlock PF0 so we can change it to a GPIO input
// Once we have enabled (unlocked) the commit register then re-lock it
// to prevent further changes. PF0 is muxed with NMI thus a special case.
//
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD;
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01;
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0;
MAP_GPIOPinIntDisable(GPIO_PORTF_BASE, 0xFF);
// Configure Red LED
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, PIN_LOW);
// Configure Blue LED
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, PIN_LOW);
// Configure Green LED
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, PIN_LOW);
// Button inputs
ROM_GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_DIR_MODE_IN);
ROM_GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
}
/*
* @brief Initializes SPI unit.
*
* Enables peripherals
* Configures GPIO
* Sets radio, accelerometer, and LED as output
* Sets word size as 0
* @returns void
*/
void SPIInit(void) {
volatile unsigned long ulLoop;
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
// configure SSI pins for peripheral control
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, (SPI_MOSI_PIN | SPI_MISO_PIN | SPI_CLK_PIN));
MAP_GPIOPinConfigure(GPIO_PA2_SSI0CLK);
MAP_GPIOPinConfigure(GPIO_PA4_SSI0RX);
MAP_GPIOPinConfigure(GPIO_PA5_SSI0TX);
// Also, it may be better to just get rid of the pullups/downs entirely. -Jeremy
MAP_GPIOPadConfigSet(GPIO_PORTA_BASE, (SPI_MOSI_PIN | SPI_MISO_PIN | SPI_CLK_PIN), GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD);
#if (defined(RONE_V12) || defined(RONE_V9))
// enable output enable peripheral for SPI
MAP_SysCtlPeripheralEnable(SPI_ENABLE_PERIPH);
// enable peripheral for three SPI pins
MAP_SysCtlPeripheralEnable(SPI_SELECT_PERIPH);
// drive select pins to correct values while they are still in input mode
SPIDeselectISR();
// enable output enable pin for output
MAP_GPIOPinTypeGPIOOutput(SPI_ENABLE_PORT, SPI_ENABLE_PIN);
// enable A,B,C SPI pins for output
MAP_GPIOPinTypeGPIOOutput(SPI_SELECT_PORT, SPI_SELECT_PINS);
#endif
// force the port to be enabled by the first call to SPIConfigure()
SPIWordSize = 0;
}
void configure_pin(struct header_pin *pin) {
if(pin->config == CONFIG_INPUT) {
MAP_GPIOPinTypeGPIOInput(pin->base, pin->pin);
} else if( pin->config == CONFIG_OUTPUT) {
MAP_GPIOPinTypeGPIOOutput(pin->base, pin->pin);
}
}
static void
enc28j60_comm_init(void) {
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, ENC_CS | ENC_RESET);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, SRAM_CS);
// MAP_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, ENC_CS | ENC_RESET | SRAM_CS);
MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, ENC_INT);
MAP_GPIOPinWrite(GPIO_PORTB_BASE, ENC_RESET, 0);
MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, ENC_CS);
MAP_GPIOPinWrite(GPIO_PORTA_BASE, SRAM_CS, SRAM_CS);
SysCtlDelay(((SysCtlClockGet() / 3) / 10)); //100ms delay
MAP_GPIOPinWrite(GPIO_PORTB_BASE, ENC_RESET, ENC_RESET);
}
//*****************************************************************************
//
// Initializes the SSI port and determines if the TRF79x0 is available.
//
// This function must be called prior to any other function offered by the
// TRF79x0. It configures the SSI port to run in Motorola/Freescale
// mode.
//
// \return None.
//
//*****************************************************************************
void
SSITRF79x0Init(void)
{
//
// Enable the peripherals used to drive the TRF79x0 on SSI.
//
MAP_SysCtlPeripheralEnable(TRF79X0_SSI_PERIPH);
//
// Enable the GPIO peripherals associated with the SSI.
//
MAP_SysCtlPeripheralEnable(TRF79X0_CLK_PERIPH);
MAP_SysCtlPeripheralEnable(TRF79X0_RX_PERIPH);
MAP_SysCtlPeripheralEnable(TRF79X0_TX_PERIPH);
MAP_SysCtlPeripheralEnable(TRF79X0_CS_PERIPH);
//
// Configure the appropriate pins to be SSI instead of GPIO. The CS
// is configured as GPIO to support TRF79x0 SPI requirements for R/W
// access.
//
MAP_GPIOPinConfigure(TRF79X0_CLK_CONFIG);
MAP_GPIOPinConfigure(TRF79X0_RX_CONFIG);
MAP_GPIOPinConfigure(TRF79X0_TX_CONFIG);
MAP_GPIOPinTypeSSI(TRF79X0_CLK_BASE, TRF79X0_CLK_PIN);
MAP_GPIOPinTypeSSI(TRF79X0_RX_BASE, TRF79X0_RX_PIN);
MAP_GPIOPinTypeSSI(TRF79X0_TX_BASE, TRF79X0_TX_PIN);
MAP_GPIOPinTypeGPIOOutput(TRF79X0_CS_BASE, TRF79X0_CS_PIN);
MAP_GPIOPadConfigSet(TRF79X0_CLK_BASE, TRF79X0_CLK_PIN,
GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU);
MAP_GPIOPadConfigSet(TRF79X0_RX_BASE, TRF79X0_RX_PIN,
GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU);
MAP_GPIOPadConfigSet(TRF79X0_TX_BASE, TRF79X0_TX_PIN,
GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU);
//
// Deassert the SSI chip selects TRF79x0.
//
MAP_GPIOPinWrite(TRF79X0_CS_BASE, TRF79X0_CS_PIN, TRF79X0_CS_PIN);
//
// Configure the SSI port for 2MHz operation.
//
MAP_SSIConfigSetExpClk(TRF79X0_SSI_BASE, g_ui32SysClk,
SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, SSI_CLK_RATE,
8);
if(RF_DAUGHTER_TRF7970) {
//
// Switch from SPH=0 to SPH=1. Required for TRF7970.
//
HWREG(TRF79X0_SSI_BASE + SSI_O_CR0) |= SSI_CR0_SPH;
}
//
// Enable the SSI controller.
//
MAP_SSIEnable(TRF79X0_SSI_BASE);
}
/**
* Hardware setup
* Initializes pins, clocks, etc
*/
void HAL_setup(void){/*{{{*/
//Configure clock to run at 120MHz
//configCPU_CLOCK_HZ = 120MHz
//Needs to be set for FreeRTOS
g_syshz = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480),
120000000L);
MAP_SysCtlMOSCConfigSet(SYSCTL_MOSC_HIGHFREQ);
//Enable all GPIOs
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOM);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOP);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOQ);
init_ethernet();
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//Configure reset pin for XBD
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTC_BASE, RESET_PIN);
//Reset XBD
xbd_reset(true);
//Configure UART
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
MAP_UARTConfigSetExpClk(UART0_BASE, g_syshz, 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
// //Configure measurement stuff
measure_setup();
//Configure xbd i2c comm
i2c_comm_setup();
//Setup watchdog
watchdog_setup();
//Unreset XBD
xbd_reset(false);
}/*}}}*/
static void enc28j60_comm_init(void) {
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, ENC_CS);
MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, ENC_INT);
MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, ENC_CS);
}
//*****************************************************************************
//
//! Initialize LEDs
//!
//! \param none
//!
//! \return none
//!
//! \brief Initializes LED Ports and Pins
//
//*****************************************************************************
void initLEDs()
{
// Enable use of PORTF to toggle LED and disable interrupt on this port
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
MAP_GPIOPinIntDisable(GPIO_PORTF_BASE, 0xFF);
// Configure Red LED
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, PIN_LOW);
// Configure Blue LED
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, PIN_LOW);
// Configure Green LED
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, PIN_LOW);
}
// Pin config
virtual void PinSetMode(MicroFlo::PinId pin, IO::PinMode mode) {
MAP_SysCtlPeripheralEnable(peripheral(pin));
if (mode == IO::InputPin) {
MAP_GPIOPinTypeGPIOInput(portBase(pin), pinMask(pin));
} else if (mode == IO::OutputPin) {
MAP_GPIOPinTypeGPIOOutput(portBase(pin), pinMask(pin));
} else {
MICROFLO_DEBUG(debug, DebugLevelError, DebugIoOperationNotImplemented);
}
}
uint8_t setPWMGenFreq(uint8_t generator, unsigned int freq)
{
config_done[generator - 1] = 0;
if(generator <= MAX_PWM_GENERATORS && generator > 0)
{
if(freq > 0 && freq <= max_pwm_freq)
{
freq_pwm[generator - 1] = freq;
max_count[generator -1] = max_pwm_freq * min_pwm_res / freq_pwm[generator - 1];
config_done[generator - 1] = 1;
#ifdef UART_DEBUG
UARTprintf(" max count %u", max_count[generator - 1] );
UARTprintf("Freq = %u, min_res = %u\n", max_pwm_freq, min_pwm_res);
UARTprintf("port = %x, pin = %x\n", port_table[generator - 1], (1 << pin_table[(generator - 1) * 2]) | (1 << pin_table[(generator - 1) * 2 + 1]));
#endif
MAP_SysCtlPeripheralEnable(periph_table[generator - 1]);
MAP_SysCtlGPIOAHBEnable(periph_table[generator - 1]);
MAP_GPIOPinTypeGPIOOutput(port_table[generator - 1], (pin_table[(generator - 1) * 2]) | (pin_table[(generator - 1) * 2 + 1]));
lookUp_pwm[(generator - 1) * 2] = (uint8_t *)malloc(max_count[generator - 1]);
lookUp_pwm[(generator - 1) * 2 + 1] = (uint8_t *)malloc(max_count[generator - 1]);
memset(lookUp_pwm[(generator - 1) * 2], 0, max_count[generator - 1]);
memset(lookUp_pwm[(generator - 1) * 2 + 1], 0, max_count[generator - 1]);
lastDutyCycle[(generator - 1) * 2] = 0;
lastDutyCycle[(generator - 1) * 2 + 1] = 0;
#ifdef UART_DEBUG
UARTprintf("printing tab...");
for(i = 0; i < max_count[generator - 1]; i++)
{
UARTprintf("%d ", lookUp_pwm[(generator - 1) * 2 ][i]);
}
UARTprintf("pr \n");
for(i = 0; i < max_count[generator - 1]; i++)
{
UARTprintf("%d ", lookUp_pwm[(generator - 1) * 2 +1][i]);
}
UARTprintf("done\n");
#endif
return 0;
}
else
{
return 1;
}
}
else
{
return 2;
}
}
pio_type platform_pio_op( unsigned port, pio_type pinmask, int op )
{
pio_type retval = 1, base = pio_base[ port ];
switch( op )
{
case PLATFORM_IO_PORT_SET_VALUE:
MAP_GPIOPinWrite( base, 0xFF, pinmask );
break;
case PLATFORM_IO_PIN_SET:
MAP_GPIOPinWrite( base, pinmask, pinmask );
break;
case PLATFORM_IO_PIN_CLEAR:
MAP_GPIOPinWrite( base, pinmask, 0 );
break;
case PLATFORM_IO_PORT_DIR_INPUT:
pinmask = 0xFF;
case PLATFORM_IO_PIN_DIR_INPUT:
MAP_GPIOPinTypeGPIOInput( base, pinmask );
break;
case PLATFORM_IO_PORT_DIR_OUTPUT:
pinmask = 0xFF;
case PLATFORM_IO_PIN_DIR_OUTPUT:
MAP_GPIOPinTypeGPIOOutput( base, pinmask );
break;
case PLATFORM_IO_PORT_GET_VALUE:
retval = MAP_GPIOPinRead( base, 0xFF );
break;
case PLATFORM_IO_PIN_GET:
retval = MAP_GPIOPinRead( base, pinmask ) ? 1 : 0;
break;
case PLATFORM_IO_PIN_PULLUP:
case PLATFORM_IO_PIN_PULLDOWN:
MAP_GPIOPadConfigSet( base, pinmask, GPIO_STRENGTH_8MA, op == PLATFORM_IO_PIN_PULLUP ? GPIO_PIN_TYPE_STD_WPU : GPIO_PIN_TYPE_STD_WPD );
break;
case PLATFORM_IO_PIN_NOPULL:
MAP_GPIOPadConfigSet( base, pinmask, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD );
break;
default:
retval = 0;
break;
}
return retval;
}
//*****************************************************************************
//
// Initialization function for the LXD display. This turns on the backlight
// and sets the correct RGB mode.
//
//*****************************************************************************
void
InitLXDAndFormike(uint32_t ui32SysClk)
{
//
// Convert PT2 & 3 back to a GPIO output (they were LCDDATA18/19)
//
HWREG(GPIO_PORTT_BASE + GPIO_O_PCTL) &= 0xFFFF00FF;
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTT_BASE, GPIO_PIN_2 | GPIO_PIN_3);
//
// Convert PS0 and 1 back to GPIO outputs (they were LCDDATA20/21)
//
HWREG(GPIO_PORTS_BASE + GPIO_O_PCTL) &= 0xFFFFFF00;
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTS_BASE, GPIO_PIN_1 | GPIO_PIN_0);
//
// Drive PS0/1 to set the display TL to BR scanning direction.
//
MAP_GPIOPinWrite(GPIO_PORTS_BASE, GPIO_PIN_1 | GPIO_PIN_0, GPIO_PIN_0);
//
// Write PT2 high to turn on the backlight.
//
MAP_GPIOPinWrite(GPIO_PORTT_BASE, GPIO_PIN_2, GPIO_PIN_2);
//
// Turn OE/DE off
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_6);
//
// Write PT3 low to set the display into RGB mode.
//
MAP_GPIOPinWrite(GPIO_PORTT_BASE, GPIO_PIN_3, 0);
//
// Write PT3 low to set the display into RGB mode.
//
MAP_GPIOPinWrite(GPIO_PORTT_BASE, GPIO_PIN_3, 0);
}
void spi_init(unsigned long bitrate,unsigned long datawidth){
//SSI
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
MAP_SysCtlGPIOAHBEnable(SYSCTL_PERIPH_GPIOA);
MAP_SysCtlGPIOAHBEnable(SYSCTL_PERIPH_GPIOC);
//CS Pin
MAP_GPIOPinTypeGPIOOutput(CS_PIN_BASE,CS_PIN);
//CE Pin
MAP_GPIOPinTypeGPIOOutput(CE_PIN_BASE,CE_PIN);
/* Configure the SSI0 port */
MAP_SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_0,SSI_MODE_MASTER, bitrate, datawidth);
/* Configure the appropriate pins to be SSI instead of GPIO */
MAP_GPIOPinTypeSSI(GPIO_PORTA_AHB_BASE, GPIO_PIN_2 |GPIO_PIN_4 | GPIO_PIN_5);
MAP_SSIEnable(SSI0_BASE);
ulClockMS = MAP_SysCtlClockGet() / (3 * 1000);
}
//*****************************************************************************
//
// Initialization function for the Formike 800x480 display. This turns on the
// backlight.
//
//*****************************************************************************
void
EnableBacklightOnPT2(uint32_t ui32SysClk)
{
//
// Convert PT2 back to a GPIO output (it was LCDDATA18)
//
HWREG(GPIO_PORTT_BASE + GPIO_O_PCTL) &= 0xFFFFF0FF;
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTT_BASE, GPIO_PIN_2);
//
// Write the pin high to turn on the backlight.
//
MAP_GPIOPinWrite(GPIO_PORTT_BASE, GPIO_PIN_2, GPIO_PIN_2);
}
void gpio_init(int pin, enum gpio_mode mode, int value)
{
uint32_t base = TO_BASE(pin);
pin = 1 << (pin & 0x0F);
switch (mode) {
case GPIO_OUTPUT:
MAP_GPIOPinTypeGPIOOutput(base, pin);
gpio_set(pin, value);
break;
case GPIO_OUTPUT_SLOW:
MAP_GPIOPinTypeGPIOOutput(base, pin);
MAP_GPIOPadConfigSet(base, pin, GPIO_STRENGTH_8MA_SC,
GPIO_PIN_TYPE_STD);
gpio_set(pin, value);
break;
case GPIO_INPUT:
MAP_GPIOPinTypeGPIOInput(base, pin);
break;
case GPIO_INPUT_PD:
MAP_GPIOPinTypeGPIOInput(base, pin);
MAP_GPIOPadConfigSet(base, pin, GPIO_STRENGTH_8MA,
GPIO_PIN_TYPE_STD_WPD);
break;
case GPIO_INPUT_PU:
MAP_GPIOPinTypeGPIOInput(base, pin);
MAP_GPIOPadConfigSet(base, pin, GPIO_STRENGTH_8MA,
GPIO_PIN_TYPE_STD_WPU);
break;
case GPIO_ANALOG:
MAP_GPIOPinTypeGPIOInput(base, pin);
MAP_GPIOPadConfigSet(base, pin, GPIO_STRENGTH_8MA,
GPIO_PIN_TYPE_ANALOG);
break;
}
}
int main(){
// System clock set to run at 50 MHz from PLL with crystal ref.
// With EK-TM4C123GXL Launchpad, no need to change SYSCTL_XTAL_16MHZ to anything else
MAP_SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LED_RED|LED_BLUE|LED_GREEN);
while(1){
MAP_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE, LED_GREEN|LED_RED|LED_BLUE);
// SysCtlDelay and ROM_SysCtlDelay behave differently, see http://e2e.ti.com/support/microcontrollers/tiva_arm/f/908/t/256106.aspx
MAP_SysCtlDelay(2333333); // Number of loop iterations to perform @ 3 cycles/loop using ROM. Not Accurate. Input = (DesiredTime*ClockFrequency)/3
MAP_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE, 0);
MAP_SysCtlDelay(16333333);
}
}
void platform_init(void) {
/* Enable lazy stacking for interrupt handlers. This allows floating-point instructions to be used within interrupt
* handlers, but at the expense of extra stack usage. */
MAP_FPULazyStackingEnable();
/* Set clock to PLL at 50MHz */
MAP_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
/* Enable the GPIO pins for the LED (PF2 & PF3). */
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3|GPIO_PIN_2);
/* Enable the system tick. FIXME do we need this? */
MAP_SysTickPeriodSet(MAP_SysCtlClockGet() / SYSTICKS_PER_SECOND);
MAP_SysTickIntEnable();
MAP_SysTickEnable();
}
//PWM = PF1/M1PWM5 & PC4/M0PWM6
void configurePWM(void)
{
//Configure PWM Clock to match system
MAP_SysCtlPWMClockSet(SYSCTL_PWMDIV_2);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
//PD6 & PD7 for direction
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE,GPIO_INT_PIN_6 |GPIO_INT_PIN_7);
MAP_GPIOPinWrite(GPIO_PORTD_BASE,GPIO_INT_PIN_6 |GPIO_INT_PIN_7,0);
ulPeriod = MAP_SysCtlClockGet() / 2 / PWM_FREQUENCY; //PWM frequency
MAP_GPIOPinConfigure(GPIO_PF1_M1PWM5);
MAP_GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1);
MAP_PWMGenConfigure(PWM1_BASE, PWM_GEN_2, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
//Set the Period (expressed in clock ticks)
MAP_PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, ulPeriod);
//Set PWM duty-0%
MAP_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5 , 0);
// Enable the PWM generator
MAP_PWMGenEnable(PWM1_BASE, PWM_GEN_2);
// Turn on the Output pins
MAP_PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT, true);
}
/*
* Sets up the PWM pins for the IR beacon PWM control.
*/
void pwmInitializeBeacon(void) {
MAP_SysCtlPeripheralEnable(IR_BEACON_PERIPH);
//MAP_GPIOPinWrite(IR_BEACON_BASE, IR_BEACON_GPIO_BIT, 0);
MAP_GPIOPinTypeGPIOOutput(IR_BEACON_BASE, IR_BEACON_GPIO_BIT);
MAP_GPIOPinWrite(IR_BEACON_BASE, IR_BEACON_GPIO_BIT, IR_BEACON_GPIO_BIT);
}
/*
* ======== EK_TM4C123GXL_initGPIO ========
*/
void EK_TM4C123GXL_initGPIO(void)
{
// /* Setup the LED GPIO pins used */
// GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1); /* EK_TM4C123GXL_LED_RED */
// GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); /* EK_TM4C123GXL_LED_GREEN */
// GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3); /* EK_TM4C123GXL_LED_BLUE */
//
// /* Setup the button GPIO pins used */
// GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4); /* EK_TM4C123GXL_GPIO_SW1 */
// GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU);
//
// /* PF0 requires unlocking before configuration */
// HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
// HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= GPIO_PIN_0;
// GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0); /* EK_TM4C123GXL_GPIO_SW2 */
// GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU);
// HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_M;
//Init debug gpio pin/pins
//
MAP_GPIOPinTypeGPIOOutput(DEBUG_GPIO_PORT_1, DEBUG_GPIO_PIN_1); //debug pin
//Init radio power enable pin
//
MAP_GPIOPinTypeGPIOOutput(INEEDMD_GPIO_EN_PORT, INEEDMD_RADIO_ENABLE_PIN); //radio power enable pin
//Init radio command mode pin
//
MAP_GPIOPinTypeGPIOOutput(INEEDMD_GPIO_CMND_PORT, INEEDMD_RADIO_CMND_PIN); //radio command mode pin
//Init radio reset pin
//
MAP_GPIOPinTypeGPIOOutput(INEEDMD_GPIO_RST_PORT, INEEDMD_RADIO_RESET_PIN); //radio reset pin
//Init external clock enable pin
//
MAP_GPIOPinTypeGPIOOutput(INEEDMD_XTAL_PORT, INEEDMD_XTAL_ENABLE_PIN); //external clock enable pin
//Init ADC power on pin
//
MAP_GPIOPinTypeGPIOOutput(INEEDMD_ADC_GPIO_PORT, INEEDMD_ADC_PWR_PIN);
//Init ADC reset pin
//
MAP_GPIOPinTypeGPIOOutput(INEEDMD_ADC_GPIO_PORT, INEEDMD_ADC_RESET_PIN);
// Init ADC interrupt pin
//
MAP_GPIOPinTypeGPIOInput(INEEDMD_ADC_GPIO_PORT, INEEDMD_ADC_INTERUPT_PIN);
// Init ADC start pin
//
MAP_GPIOPinTypeGPIOOutput(INEEDMD_ADC_GPIO_PORT, INEEDMD_ADC_START_PIN);
//Init ADC nCS pin
//
MAP_GPIOPinTypeGPIOOutput(INEEDMD_ADC_GPIO_PORT, INEEDMD_ADC_nCS_PIN);
//Init USB unplug detect pin
//
HWREG(GPIO_PORTB_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTB_BASE + GPIO_O_CR) |= GPIO_PIN_4;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_4);
MAP_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_4, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPD);
HWREG(GPIO_PORTB_BASE + GPIO_O_LOCK) = GPIO_LOCK_M;
/* Once GPIO_init is called, GPIO_config cannot be changed */
GPIO_init();
}
//*****************************************************************************
//
//! Configures the device pins for the customer specific usage.
//!
//! \return None.
//
//*****************************************************************************
void
PinoutSet(void)
{
//
// Enable Peripheral Clocks
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Configure the GPIO Pin Mux for PB6
// for GPIO_PB6
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_6);
//
// Configure the GPIO Pin Mux for PB7
// for GPIO_PB7
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_7);
//
// Configure the GPIO Pin Mux for PB0
// for GPIO_PB0
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_0);
//
// Configure the GPIO Pin Mux for PB1
// for GPIO_PB1
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_1);
//
// Configure the GPIO Pin Mux for PB2
// for GPIO_PB2
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_2);
//
// Configure the GPIO Pin Mux for PB3
// for GPIO_PB3
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_3);
//
// Configure the GPIO Pin Mux for PB4
// for GPIO_PB4
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_4);
//
// Configure the GPIO Pin Mux for PB5
// for GPIO_PB5
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_5);
//
// Configure the GPIO Pin Mux for PF4
// for GPIO_PF4
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4);
//
// Unlock the Port Pin and Set the Commit Bit
//
HWREG(GPIO_PORTF_BASE+GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTF_BASE+GPIO_O_CR) |= GPIO_PIN_0;
HWREG(GPIO_PORTF_BASE+GPIO_O_LOCK) = 0x0;
//
// Configure the GPIO Pin Mux for PF0
// for GPIO_PF0
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0);
//
// Configure the GPIO Pin Mux for PD2
// for SSI3RX
//
MAP_GPIOPinConfigure(GPIO_PD2_SSI3RX);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_2);
//
// Configure the GPIO Pin Mux for PD1
// for SSI3FSS
//
MAP_GPIOPinConfigure(GPIO_PD1_SSI3FSS);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_1);
//
// Configure the GPIO Pin Mux for PD3
// for SSI3TX
//
MAP_GPIOPinConfigure(GPIO_PD3_SSI3TX);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_3);
//
// Configure the GPIO Pin Mux for PD0
// for SSI3CLK
//
MAP_GPIOPinConfigure(GPIO_PD0_SSI3CLK);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_0);
//
// Configure the GPIO Pin Mux for PA4
// for SSI0RX
//
MAP_GPIOPinConfigure(GPIO_PA4_SSI0RX);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_4);
//
// Configure the GPIO Pin Mux for PA3
// for SSI0FSS
//
MAP_GPIOPinConfigure(GPIO_PA3_SSI0FSS);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_3);
//
// Configure the GPIO Pin Mux for PA5
// for SSI0TX
//
MAP_GPIOPinConfigure(GPIO_PA5_SSI0TX);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5);
//
// Configure the GPIO Pin Mux for PA2
// for SSI0CLK
//
MAP_GPIOPinConfigure(GPIO_PA2_SSI0CLK);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_2);
}
/*******************
* Board Functions *
*******************/
void GTBEA_initErrLED(void) {
MAP_SysCtlPeripheralEnable(GTBEA_ERR_LED_GPIO_PERIPH);
MAP_GPIOPinTypeGPIOOutput(GTBEA_ERR_LED_GPIO_BASE, GTBEA_ERR_LED_PIN);
MAP_GPIOPinWrite(GTBEA_ERR_LED_GPIO_BASE, GTBEA_ERR_LED_PIN, 0); // turn off err LED
}
//*****************************************************************************
//
// This function initializes the ADC hardware in preparation for data
// acquisition.
//
//*****************************************************************************
void
AcquireInit(void)
{
uint32_t ui32Chan, ui32Base, ui32Seq, ui32ChCtl;
//
// Enable the ADC peripherals and the associated GPIO port
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC1);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOP);
//
// Enabled LED GPIO
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTG_BASE, GPIO_PIN_2);
//
// Configure the pins to be used as analog inputs.
//
MAP_GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 |
GPIO_PIN_7 | GPIO_PIN_3);
MAP_GPIOPinTypeADC(GPIO_PORTP_BASE, GPIO_PIN_0);
//
// Select the external reference for greatest accuracy.
//
MAP_ADCReferenceSet(ADC0_BASE, ADC_REF_EXT_3V);
MAP_ADCReferenceSet(ADC1_BASE, ADC_REF_EXT_3V);
//
// Apply workaround for erratum 6.1, in order to use the
// external reference.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
HWREG(GPIO_PORTB_BASE + GPIO_O_AMSEL) |= GPIO_PIN_6;
//
// Initialize both ADC peripherals using sequencer 0 and processor trigger.
//
MAP_ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
MAP_ADCSequenceConfigure(ADC1_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
//
// Enter loop to configure all of the ADC sequencer steps needed to
// acquire the data for the data logger. Multiple ADC and sequencers
// will be used in order to acquire all the channels.
//
for(ui32Chan = 0; ui32Chan < NUM_ADC_CHANNELS; ui32Chan++)
{
//
// If this is the first ADC then set the base for ADC0
//
if(ui32Chan < 8)
{
ui32Base = ADC0_BASE;
ui32Seq = 0;
}
else if(ui32Chan < 16)
{
//
// Second ADC, set the base for ADC1
//
ui32Base = ADC1_BASE;
ui32Seq = 0;
}
//
// Get the channel control for each channel. Test to see if it is the
// last channel for the sequencer, and if so then also set the
// interrupt and "end" flags.
//
ui32ChCtl = g_pui32ADCSeq[ui32Chan];
if((ui32Chan == 7) || (ui32Chan == 15) ||
(ui32Chan == (NUM_ADC_CHANNELS - 1)))
{
ui32ChCtl |= ADC_CTL_IE | ADC_CTL_END;
}
//
// Configure the sequence step
//
MAP_ADCSequenceStepConfigure(ui32Base, ui32Seq, ui32Chan % 8,
ui32ChCtl);
}
//
// Erase the configuration in case there was a prior configuration.
//
g_psConfigState = 0;
}
/*
* initialize tm4c
*/
void init_satellite()
{
FPUEnable();
FPULazyStackingEnable();
/*
* init clock
*/
MAP_SysCtlClockSet(SYSCTL_SYSDIV_3 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); //66.6..MHz
MAP_IntMasterEnable();
/*
* Enable peripherals
*/
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //for LED indication
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); //for UART
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); //for IRQ and SW_EN
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); //for SPI
/*
* configure
*/
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, SIGNAL_LOW); //off
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioConfig(UART_PORT, UART_BAUDRATE, SysCtlClockGet());
MAP_GPIOIntDisable(GPIO_PORTB_BASE, SIGNAL_HIGH); //interrupt disable
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_2); //IRQ as input
MAP_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_2, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
MAP_GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_2, GPIO_FALLING_EDGE); //enable interrupt
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_5); //sw enable
MAP_GPIODirModeSet(GPIO_PORTB_BASE, GPIO_PIN_5, GPIO_DIR_MODE_OUT);
MAP_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_5, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
MAP_GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_5, SIGNAL_LOW);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_0);
MAP_GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_0, SIGNAL_HIGH); //chip select
MAP_GPIOIntEnable(GPIO_PORTB_BASE, GPIO_PIN_2); //enable interrupt for WLAN_IRQ pin
SpiCleanGPIOISR(); //clear interrupt status
MAP_IntEnable(INT_GPIOB); //spi
init_worker();
setState(READY);
}
//*****************************************************************************
void
PortFunctionInit(void)
{
//
// Enable Peripheral Clocks
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Enable port PE5 for CAN0 CAN0TX
//
MAP_GPIOPinConfigure(GPIO_PE5_CAN0TX);
MAP_GPIOPinTypeCAN(GPIO_PORTE_BASE, GPIO_PIN_5);
//
// Enable port PE4 for CAN0 CAN0RX
//
MAP_GPIOPinConfigure(GPIO_PE4_CAN0RX);
MAP_GPIOPinTypeCAN(GPIO_PORTE_BASE, GPIO_PIN_4);
//
// Enable port PB0 for GPIOOutput
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_0);
//
// Enable port PB6 for GPIOInput
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_6);
//
// Enable port PF4 for GPIOInput
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4);
//
// Enable port PF0 for GPIOInput
//
//
//First open the lock and select the bits we want to modify in the GPIO commit register.
//
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD;
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) = 0x1;
//
//Now modify the configuration of the pins that we unlocked.
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0);
//
// Enable port PF3 for GPIOOutput
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3);
//
// Enable port PF2 for GPIOOutput
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
//
// Enable port PF1 for GPIOOutput
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
//
// Enable port PA3 for SSI0 SSI0FSS
//
MAP_GPIOPinConfigure(GPIO_PA3_SSI0FSS);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_3);
//
// Enable port PA2 for SSI0 SSI0CLK
//
MAP_GPIOPinConfigure(GPIO_PA2_SSI0CLK);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_2);
//
// Enable port PA4 for SSI0 SSI0RX
//
MAP_GPIOPinConfigure(GPIO_PA4_SSI0RX);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_4);
//
// Enable port PA5 for SSI0 SSI0TX
//
MAP_GPIOPinConfigure(GPIO_PA5_SSI0TX);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5);
}
//*****************************************************************************
//
// Main 'C' Language entry point.
//
//*****************************************************************************
int
main(void)
{
float fTemperature, fPressure, fAltitude;
int32_t i32IntegerPart;
int32_t i32FractionPart;
tContext sContext;
uint32_t ui32SysClock;
char pcBuf[15];
//
// Setup the system clock to run at 40 Mhz from PLL with crystal reference
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 40000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&sContext, "bmp180");
//
// Flush any cached drawing operations.
//
GrFlush(&sContext);
//
// Enable UART0
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Initialize the UART for console I/O.
//
UARTStdioConfig(0, 115200, ui32SysClock);
//
// Print the welcome message to the terminal.
//
UARTprintf("\033[2JBMP180 Example\n");
//
// The I2C3 peripheral must be enabled before use.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
//
// Configure the pin muxing for I2C3 functions on port G4 and G5.
// This step is not necessary if your part does not support pin muxing.
//
MAP_GPIOPinConfigure(GPIO_PG4_I2C3SCL);
MAP_GPIOPinConfigure(GPIO_PG5_I2C3SDA);
//
// Select the I2C function for these pins. This function will also
// configure the GPIO pins pins for I2C operation, setting them to
// open-drain operation with weak pull-ups. Consult the data sheet
// to see which functions are allocated per pin.
//
MAP_GPIOPinTypeI2CSCL(GPIO_PORTG_BASE, GPIO_PIN_4);
MAP_GPIOPinTypeI2C(GPIO_PORTG_BASE, GPIO_PIN_5);
//
// Enable interrupts to the processor.
//
MAP_IntMasterEnable();
//
// Initialize I2C3 peripheral.
//
I2CMInit(&g_sI2CInst, I2C3_BASE, INT_I2C3, 0xff, 0xff,
ui32SysClock);
//
// Initialize the BMP180
//
BMP180Init(&g_sBMP180Inst, &g_sI2CInst, BMP180_I2C_ADDRESS,
BMP180AppCallback, &g_sBMP180Inst);
//
// Wait for initialization callback to indicate reset request is complete.
//
while(g_vui8DataFlag == 0)
{
//
// Wait for I2C Transactions to complete.
//
}
//
// Reset the data ready flag
//
g_vui8DataFlag = 0;
//
// Enable the system ticks at 10 hz.
//
MAP_SysTickPeriodSet(ui32SysClock / (10 * 3));
MAP_SysTickIntEnable();
MAP_SysTickEnable();
//
// Configure PQ4 to control the blue LED.
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTQ_BASE, GPIO_PIN_4);
//
// Print temperature, pressure and altitude labels once on the LCD.
//
GrStringDraw(&sContext, "Temperature", 11,
((GrContextDpyWidthGet(&sContext) / 2) - 96),
((GrContextDpyHeightGet(&sContext) - 32) / 2) - 24, 1);
GrStringDraw(&sContext, "Pressure", 8,
((GrContextDpyWidthGet(&sContext) / 2) - 63),
(GrContextDpyHeightGet(&sContext) - 32) / 2, 1);
GrStringDraw(&sContext, "Altitude", 8,
((GrContextDpyWidthGet(&sContext) / 2) - 59),
((GrContextDpyHeightGet(&sContext) - 32) / 2) + 24, 1);
//
// Begin the data collection and printing. Loop Forever.
//
while(1)
{
//
// Read the data from the BMP180 over I2C. This command starts a
// temperature measurement. Then polls until temperature is ready.
// Then automatically starts a pressure measurement and polls for that
// to complete. When both measurement are complete and in the local
// buffer then the application callback is called from the I2C
// interrupt context. Polling is done on I2C interrupts allowing
// processor to continue doing other tasks as needed.
//
BMP180DataRead(&g_sBMP180Inst, BMP180AppCallback, &g_sBMP180Inst);
while(g_vui8DataFlag == 0)
{
//
// Wait for the new data set to be available.
//
}
//
// Reset the data ready flag.
//
g_vui8DataFlag = 0;
//
// Get a local copy of the latest temperature data in float format.
//
BMP180DataTemperatureGetFloat(&g_sBMP180Inst, &fTemperature);
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fTemperature;
i32FractionPart =(int32_t) (fTemperature * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print temperature with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%03d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, 8,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
((GrContextDpyHeightGet(&sContext) - 32) / 2) - 24, 1);
UARTprintf("Temperature %3d.%03d\t\t", i32IntegerPart,
i32FractionPart);
//
// Get a local copy of the latest air pressure data in float format.
//
BMP180DataPressureGetFloat(&g_sBMP180Inst, &fPressure);
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fPressure;
i32FractionPart =(int32_t) (fPressure * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print Pressure with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%3d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, -1,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
(GrContextDpyHeightGet(&sContext) - 32) / 2, 1);
UARTprintf("Pressure %3d.%03d\t\t", i32IntegerPart, i32FractionPart);
//
// Calculate the altitude.
//
fAltitude = 44330.0f * (1.0f - powf(fPressure / 101325.0f,
1.0f / 5.255f));
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fAltitude;
i32FractionPart =(int32_t) (fAltitude * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print altitude with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%3d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, 8,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
((GrContextDpyHeightGet(&sContext) - 32) / 2) + 24, 1);
UARTprintf("Altitude %3d.%03d", i32IntegerPart, i32FractionPart);
//
// Print new line.
//
UARTprintf("\n");
//
// Delay to keep printing speed reasonable. About 100 milliseconds.
//
MAP_SysCtlDelay(ui32SysClock / (10 * 3));
}
}
void pio_init()
{
// Board Initialization start
//
//
// The FPU should be enabled because some compilers will use floating-
// point registers, even for non-floating-point code. If the FPU is not
// enabled this will cause a fault. This also ensures that floating-
// point operations could be added to this application and would work
// correctly and use the hardware floating-point unit. Finally, lazy
// stacking is enabled for interrupt handlers. This allows floating-
// point instructions to be used within interrupt handlers, but at the
// expense of extra stack usage.
//
FPUEnable();
FPULazyStackingEnable();
//Init the device with 16 MHz clock.
initClk();
/* Configure the system peripheral bus that IRQ & EN pin are map to */
MAP_SysCtlPeripheralEnable( SYSCTL_PERIPH_IRQ_PORT);
//
// Disable all the interrupts before configuring the lines
//
MAP_GPIOPinIntDisable(SPI_GPIO_IRQ_BASE, 0xFF);
//
// Cofigure WLAN_IRQ pin as input
//
MAP_GPIOPinTypeGPIOInput(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN);
GPIOPadConfigSet(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
//
// Setup the GPIO interrupt for this pin
//
MAP_GPIOIntTypeSet(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN, GPIO_FALLING_EDGE);
//
// Configure WLAN chip
//
MAP_GPIOPinTypeGPIOOutput(SPI_GPIO_IRQ_BASE, SPI_EN_PIN);
MAP_GPIODirModeSet( SPI_GPIO_IRQ_BASE, SPI_EN_PIN, GPIO_DIR_MODE_OUT );
MAP_GPIOPadConfigSet( SPI_GPIO_IRQ_BASE, SPI_EN_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD );
MAP_GPIOPinWrite(SPI_GPIO_IRQ_BASE, SPI_EN_PIN, PIN_LOW);
SysCtlDelay(600000);
SysCtlDelay(600000);
SysCtlDelay(600000);
//
// Disable WLAN CS with pull up Resistor
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SPI_PORT);
MAP_GPIOPinTypeGPIOOutput(SPI_CS_PORT, SPI_CS_PIN);
GPIOPadConfigSet(SPI_CS_PORT, SPI_CS_PIN, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
MAP_GPIOPinWrite(SPI_CS_PORT, SPI_CS_PIN, PIN_HIGH);
//
// Enable interrupt for WLAN_IRQ pin
//
MAP_GPIOPinIntEnable(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN);
//
// Clear interrupt status
//
SpiCleanGPIOISR();
MAP_IntEnable(INT_GPIO_SPI);
//init LED
initLEDs();
}
//*****************************************************************************
//
// Initialization function for the InnoLux display. This turns on the backlight
// after the required 200mS delay.
//
// VLED control - PD6
// LED_EN - PE5
// LED_PWM - PR2 or PE4
//
//*****************************************************************************
void
InitInnoLux(uint32_t ui32SysClk)
{
//
// Turn on GPIO Ports D, E and R.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
#ifdef USE_PR2_FOR_PWM
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOR);
#endif
//
// Configure PD6 (VLED) as an output.
//
HWREG(GPIO_PORTD_BASE + GPIO_O_PCTL) &= 0xF0FFFFFF;
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_6);
//
// Configure PE5 and PR2 as outputs.
//
HWREG(GPIO_PORTE_BASE + GPIO_O_PCTL) &= 0xFF0FFFFF;
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_5);
#ifdef USE_PR2_FOR_PWM
HWREG(GPIO_PORTR_BASE + GPIO_O_PCTL) &= 0xFFFFF0FF;
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTR_BASE, GPIO_PIN_2);
GPIOPadConfigSet(GPIO_PORTR_BASE, GPIO_PIN_2, GPIO_STRENGTH_12MA, GPIO_PIN_TYPE_STD);
#else
HWREG(GPIO_PORTE_BASE + GPIO_O_PCTL) &= 0xFFF0FFFF;
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_4);
#endif
//
// Drive the enables low for now.
//
MAP_GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_6, 0);
#ifdef USE_PR2_FOR_PWM
MAP_GPIOPinWrite(GPIO_PORTR_BASE, GPIO_PIN_2, 0);
MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_5, 0);
#else
MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_5 | GPIO_PIN_4, 0);
#endif
//
// Wait 200mS. This delay is specified in the display datasheet.
//
MAP_SysCtlDelay((ui32SysClk / 5) / 3);
//
// Drive PD6 high to enable VLED to the display.
//
MAP_GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_6, GPIO_PIN_6);
//
// Wait another 10mS before we turn on the PWM to set the display
// backlight brightness.
//
MAP_SysCtlDelay((ui32SysClk / 100) / 3);
//
// Start the LED backlight signaling by asserting LED-PWM (PR2).
//
#ifdef USE_PR2_FOR_PWM
MAP_GPIOPinWrite(GPIO_PORTR_BASE, GPIO_PIN_2, GPIO_PIN_2);
#else
MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4, GPIO_PIN_4);
#endif
//
// Wait another 10mS before returning to ensure that the raster is not
// enabled too soon.
//
MAP_SysCtlDelay((ui32SysClk / 100) / 3);
//
// Enable the LED backlight by asserting LED-EN (PE5).
//
MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_5, GPIO_PIN_5);
}
int main()
{
//
// Make sure the main oscillator is enabled because this is required by
// the PHY. The system must have a 25MHz crystal attached to the OSC
// pins. The SYSCTL_MOSC_HIGHFREQ parameter is used when the crystal
// frequency is 10MHz or higher.
//
SysCtlMOSCConfigSet(SYSCTL_MOSC_HIGHFREQ);
//
// Run from the PLL at 120 MHz.
//
g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
// Configure the device pins.
//
PinoutSet(true, false);
//
// Configure UART.
//
//UARTStdioConfig(0, 115200, g_ui32SysClock);
//
// Clear the terminal and print banner.
//
//UARTprintf("\033[2J\033[H");
//UARTprintf("Ethernet lwIP example\n\n");
//
// Configure Port N1 for as an output for the animation LED.
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
//
// Initialize LED to OFF (0)
//
MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, ~GPIO_PIN_1);
MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, ~GPIO_PIN_0);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, ~GPIO_PIN_1);
//
// Configure SysTick for a periodic interrupt.
//
MAP_SysTickPeriodSet(g_ui32SysClock / SYSTICKHZ);
MAP_SysTickEnable();
MAP_SysTickIntEnable();
// Init Onion Client
client = new OnionClient("o8Ik6DuC","NfyGRECh3WSZw9xn");
client->registerFunction("/on",ledOn,0,0);
client->registerFunction("/off",ledOff,0,0);
char *params[1] = {"data"};
client->registerFunction("/pubTest",pubTest,params,1);
client->init(g_ui32SysClock);
//
// Setup Onion Client
//
//httpd_init();
//client->begin();
//
// Set the interrupt priorities. We set the SysTick interrupt to a higher
// priority than the Ethernet interrupt to ensure that the file system
// tick is processed if SysTick occurs while the Ethernet handler is being
// processed. This is very likely since all the TCP/IP and HTTP work is
// done in the context of the Ethernet interrupt.
//
MAP_IntPrioritySet(INT_EMAC0, ETHERNET_INT_PRIORITY);
MAP_IntPrioritySet(FAULT_SYSTICK, SYSTICK_INT_PRIORITY);
//
// Loop forever. All the work is done in interrupt handlers.
//
uint32_t last_time = g_millis;
bool led = false;
while(1)
{
if ((g_millis - last_time) > 500) {
if (led) {
MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, ~GPIO_PIN_0);
led = false;
} else {
MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, GPIO_PIN_0);
led = true;
}
last_time = g_millis;
}
client->loop();
}
return 0;
}
//*****************************************************************************
//
// This example demonstrates how to send a string of data to the UART.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32_Period, ui32_PWM=0, ui32_PWM_step = 40, ui32_PWM_min=2000, ui32_PWM_max=4000;
uint32_t ui32_sw1;
uint32_t ui32_sw2;
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
//MAP_FPUEnable();
//MAP_FPULazyStackingEnable();
//
// Set the clocking to run directly from the crystal.
//
MAP_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Enable the GPIO port that is used for the on-board LED.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Enable the GPIO pins for the LED (PF2).
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
// Configure UART
InitConsole();
// -----------------------------------------------------------------
// Configure PWM for servo control
// -----------------------------------------------------------------
// follow page 1240 of the datasheet:
ui32_Period = (MAP_SysCtlClockGet()/8) / 50; //PWM frequency 50HZ, T=20ms
// GOTO middle of servo in the beginning
ui32_PWM = ui32_PWM_min + (ui32_PWM_max - ui32_PWM_min) / 2;
ui32_PWM_max = ui32_Period*.1;
ui32_PWM_min = ui32_Period*.05;
//Configure PWM Clock to match system
MAP_SysCtlPWMClockSet(SYSCTL_PWMDIV_8);
// Enable system clock for PWM0 module
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
// Enable the GPIO port that is used for the PWM outputs
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
//Configure PB5,PB5 Pins as PWM
MAP_GPIOPinConfigure(GPIO_PB4_M0PWM2);
MAP_GPIOPinConfigure(GPIO_PB5_M0PWM3);
MAP_GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_4);
MAP_GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_5);
//Configure PWM Options
MAP_PWMGenConfigure(PWM0_BASE, PWM_GEN_1 , PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
//
// Set the PWM period to 50Hz. To calculate the appropriate parameter
// use the following equation: N = (1 / f) * SysClk. Where N is the
// function parameter, f is the desired frequency, and SysClk is the
// system clock frequency.
// In this case you get: (1 / 50Hz) * 16MHz/8div = 40000 cycles. Note that
// the maximum period you can set is 2^16 - 1.
// TODO: modify this calculation to use the clock frequency that you are
// using.
//
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_1, ui32_Period);
//Set PWM duty - 25% and 75%
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_2, ui32_PWM);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_3, ui32_PWM);
// Enable the PWM generator
MAP_PWMGenEnable(PWM0_BASE, PWM_GEN_1);
// Turn on the Output pins
MAP_PWMOutputState(PWM0_BASE, PWM_OUT_2_BIT | PWM_OUT_3_BIT, true);
// -----------------------------------------------------------------
// Enable PORTF and Configure SW1 and SW2 as input
// -----------------------------------------------------------------
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIO_PORTF_LOCK_R = 0x4C4F434B; // unlock GPIO Port F
GPIO_PORTF_CR_R = 0x1F; // allow changes to PF4-0
MAP_GPIOPadConfigSet(GPIO_PORTF_BASE, (GPIO_PIN_4 | GPIO_PIN_0), GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
MAP_GPIODirModeSet(GPIO_PORTF_BASE, (GPIO_PIN_4 | GPIO_PIN_0), GPIO_DIR_MODE_IN);
//
// Loop forever echoing data through the UART.
//
while(1)
{
// Get buttons:
ui32_sw1 = MAP_GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4);
ui32_sw2 = MAP_GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_0);
// if pressing SW1 on LaunchPad TM4C123G
if( ui32_sw1 == 0 )
{
if(ui32_PWM >= ui32_PWM_min+ui32_PWM_step) {
ui32_PWM -= ui32_PWM_step;
}
}
if( ui32_sw2 == 0 )
{
if(ui32_PWM <= ui32_PWM_max-ui32_PWM_step) {
ui32_PWM += ui32_PWM_step;
}
}
UARTprintf("Period: %d, PWM: %d\n", ui32_Period, ui32_PWM);
MAP_SysCtlDelay(2000000);
MAP_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_2 , ui32_Period - ui32_PWM);
MAP_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_3 , ui32_PWM);
}
}
