int
read_pins(struct header_pin pins[], uint16_t length, uint8_t *buf) {
static char bnone[] = "\"x\"";
uint16_t i = 0;
int l;
for(l=0;l<length;l++) {
if( l > 0)
buf[i++] = ',';
printf("pin %d: %d\n", l, pins[l].config);
if( pins[l].config == CONFIG_NOT_USED) {
memcpy(buf+i, bnone, sizeof(bnone)-1);
i+= sizeof(bnone)-1;
} else if( pins[l].config == CONFIG_OUTPUT ) {
if( MAP_GPIOPinRead(pins[l].base, pins[l].pin) == 0x00 ) {
buf[i++] = '2';
} else {
buf[i++] = '3';
}
} else {
if( MAP_GPIOPinRead(pins[l].base, pins[l].pin) == 0x00 ) {
buf[i++] = '0';
} else {
buf[i++] = '1';
}
}
}
return i;
}
//*****************************************************************************
//! Wait while the safe mode pin is being held high and blink the system led
//! with the specified period
//*****************************************************************************
static bool wait_while_blinking (uint32_t wait_time, uint32_t period, bool force_wait) {
_u32 count;
for (count = 0; (force_wait || MAP_GPIOPinRead(MICROPY_SAFE_BOOT_PORT, MICROPY_SAFE_BOOT_PORT_PIN)) &&
((period * count) < wait_time); count++) {
// toogle the led
MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, ~MAP_GPIOPinRead(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN));
UtilsDelay(UTILS_DELAY_US_TO_COUNT(period * 1000));
}
return MAP_GPIOPinRead(MICROPY_SAFE_BOOT_PORT, MICROPY_SAFE_BOOT_PORT_PIN) ? true : false;
}
//*****************************************************************************
//! Check for the safe mode pin
//*****************************************************************************
static bool safe_mode_boot (void) {
_u32 count = 0;
while (MAP_GPIOPinRead(MICROPY_SAFE_BOOT_PORT, MICROPY_SAFE_BOOT_PORT_PIN) &&
((BOOTMGR_WAIT_SAFE_MODE_TOOGLE_MS * count++) < BOOTMGR_WAIT_SAFE_MODE_MS)) {
// toogle the led
MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, ~MAP_GPIOPinRead(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN));
UtilsDelay(UTILS_DELAY_US_TO_COUNT(BOOTMGR_WAIT_SAFE_MODE_TOOGLE_MS * 1000));
}
mperror_deinit_sfe_pin();
return MAP_GPIOPinRead(MICROPY_SAFE_BOOT_PORT, MICROPY_SAFE_BOOT_PORT_PIN) ? true : false;
}
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;
}
int arch_GpioRead(uint_t nPort, uint_t nPin)
{
if (MAP_GPIOPinRead(arch_GpioPortBase(nPort), BITMASK(nPin)))
return 1;
return 0;
}
/* Measures the length (in microseconds) of a pulse on the pin; state is HIGH
* or LOW, the type of pulse to measure. Works on pulses from 2-3 microseconds
* to 3 minutes in length, but must be called at least a few dozen microseconds
* before the start of the pulse. */
unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout)
{
// cache the port and bit of the pin in order to speed up the
// pulse width measuring loop and achieve finer resolution. calling
// digitalRead() instead yields much coarser resolution.
uint8_t bit = digitalPinToBitMask(pin);
uint8_t port = digitalPinToPort(pin);
uint32_t portBase = (uint32_t) portBASERegister(port);
uint8_t stateMask = (state ? bit : 0);
// convert the timeout from microseconds to a number of times through
// the initial loop; it takes 11 clock cycles per iteration.
unsigned long numloops = 0;
unsigned long maxloops = microsecondsToClockCycles(timeout) / 11;
// wait for any previous pulse to end
while (MAP_GPIOPinRead(portBase, bit) == stateMask)
if (numloops++ == maxloops)
return 0;
// wait for the pulse to start
while (MAP_GPIOPinRead(portBase, bit) != stateMask)
if (numloops++ == maxloops)
return 0;
// wait for the pulse to stop
unsigned long start = micros();
while (MAP_GPIOPinRead(portBase, bit) == stateMask) {
if (numloops++ == maxloops)
return 0;
}
unsigned long end = micros();
unsigned long result = end - start;
return(result);
// convert the reading to microseconds. The loop has been determined
// to be 13 clock cycles long and have about 11 clocks between the edge
// and the start of the loop. There will be some error introduced by
// the interrupt handlers.
//return clockCyclesToMicroseconds(width * 13 + 11);
}
//*****************************************************************************
//
//! MicroPhone Control Routine
//!
//! \param pValue - pointer to a memory structure that is passed
//! to the interrupt handler.
//!
//! \return None
//
//*****************************************************************************
void MicroPhoneControl(void* pValue)
{
int iCount=0;
unsigned long ulPin5Val = 1;
//Check whether GPIO Level is Stable As No Debouncing Circuit in LP
for(iCount=0;iCount<3;iCount++)
{
osi_Sleep(200);
ulPin5Val = MAP_GPIOPinRead(GPIOA1_BASE,GPIO_PIN_5);
if(ulPin5Val)
{
//False Alarm
return;
}
}
if (g_ucMicStartFlag == 0)
{
for(iCount = 0; iCount<3; iCount++)
{
//Blink LED 3 times to Indicate ON
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
osi_Sleep(50);
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
osi_Sleep(50);
}
g_ucMicStartFlag = 1;
}
else
{
//Blink LED 3 times to Indicate OFF
for(iCount = 0; iCount<3; iCount++)
{
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
osi_Sleep(50);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
osi_Sleep(50);
}
g_ucMicStartFlag = 0;
}
//Enable GPIO Interrupt
MAP_GPIOIntClear(GPIOA1_BASE,GPIO_PIN_5);
MAP_IntPendClear(INT_GPIOA1);
MAP_IntEnable(INT_GPIOA1);
MAP_GPIOIntEnable(GPIOA1_BASE,GPIO_PIN_5);
}
static int int_gpio_negedge_get_flag( elua_int_resnum resnum, int clear )
{
unsigned long portbase = pio_base[ PLATFORM_IO_GET_PORT( resnum ) ];
u8 pinmask = 1 << PLATFORM_IO_GET_PIN( resnum );
if( MAP_GPIOPinRead( portbase, pinmask ) != 0 )
return 0;
if( MAP_GPIOPinIntStatus( portbase, true ) & pinmask )
{
if( clear )
MAP_GPIOPinIntClear( portbase, pinmask );
return 1;
}
return 0;
}
/// \method value([value])
/// Get or set the digital logic level of the pin:
///
/// - With no arguments, return 0 or 1 depending on the logic level of the pin.
/// - With `value` given, set the logic level of the pin. `value` can be
/// anything that converts to a boolean. If it converts to `True`, the pin
/// is set high, otherwise it is set low.
STATIC mp_obj_t pin_value(mp_uint_t n_args, const mp_obj_t *args) {
pin_obj_t *self = args[0];
if (n_args == 1) {
// get the pin value
return MP_OBJ_NEW_SMALL_INT(MAP_GPIOPinRead(self->port, self->bit) ? 1 : 0);
} else {
// set the pin value
if (mp_obj_is_true(args[1])) {
MAP_GPIOPinWrite(self->port, self->bit, self->bit);
} else {
MAP_GPIOPinWrite(self->port, self->bit, 0);
}
return mp_const_none;
}
}
//*****************************************************************************
//
// CheckBoardRevision uses PD1 with a weak pull down resistor to detect the
// development board hardware revision. Code for the LM4F board can run on the
// TM4C, but not vice versa. This function checks for the board verion and
// warns the user if they are using the wrong board / software.
//
// The EK-LM4F232 (green) board uses an analog accelorometer. The DK-TM4C123G
//(red) board uses a digitial I2C 9 axis accel, mag, gyro.
//
//*****************************************************************************
void
CheckBoardRevision(void)
{
uint32_t ui32BoardType;
tContext sDisplayContext;
//
// Check if board is TM4C123G (red) or LM4F232 (green). This code
// should not be run on green board.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
MAP_GPIODirModeSet(GPIO_PORTD_BASE, GPIO_PIN_1, GPIO_DIR_MODE_IN);
MAP_GPIOPadConfigSet(GPIO_PORTD_BASE, GPIO_PIN_1,
GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
ui32BoardType=MAP_GPIOPinRead(GPIO_PORTD_BASE, GPIO_PIN_1);
if(ui32BoardType==0)
{
//
// The board is green, print error message and hang.
//
CFAL96x64x16Init();
GrContextInit(&sDisplayContext, &g_sCFAL96x64x16);
GrContextForegroundSet(&sDisplayContext, ClrWhite);
GrContextFontSet(&sDisplayContext, g_psFontFixed6x8);
GrStringDrawCentered(&sDisplayContext, "ERROR:", -1,
GrContextDpyWidthGet(&sDisplayContext) / 2, 4, 0);
GrStringDrawCentered(&sDisplayContext, "Due to different", -1,
GrContextDpyWidthGet(&sDisplayContext) / 2, 20, false);
GrStringDrawCentered(&sDisplayContext, "hardware this", -1,
GrContextDpyWidthGet(&sDisplayContext) / 2, 30, false);
GrStringDrawCentered(&sDisplayContext, "code cannot run", -1,
GrContextDpyWidthGet(&sDisplayContext) / 2, 40, false);
GrStringDrawCentered(&sDisplayContext, "on this board", -1,
GrContextDpyWidthGet(&sDisplayContext) / 2, 50, false);
GrStringDrawCentered(&sDisplayContext, "Try diff code.", -1,
GrContextDpyWidthGet(&sDisplayContext) / 2, 60, false);
while(1)
{
// Hang here.
}
}
else
{
//
// The board is red, exit & continue as normal.
//
return ;
}
}
void cc3200_leds(enum cc3200_led leds, enum cc3200_led_state s) {
long v;
leds &= (RED | GREEN | AMBER);
switch (s) {
case ON:
v = ~0;
break;
case OFF:
v = 0;
break;
case TOGGLE:
v = ~(MAP_GPIOPinRead(GPIOA1_BASE, leds));
break;
default:
return;
}
MAP_GPIOPinWrite(GPIOA1_BASE, leds, (v & leds));
}
static void gpio_common_handler( int port )
{
u32 base = pio_base[ port ];
u8 pin, pinmask;
u32 ibe = HWREG( base + GPIO_O_IBE );
u32 iev = HWREG( base + GPIO_O_IEV );
// Check each pin in turn
for( pin = 0, pinmask = 1; pin < 8; pin ++, pinmask <<= 1 )
if( HWREG( base + GPIO_O_MIS ) & pinmask ) // interrupt on pin
{
if( MAP_GPIOPinRead( base, pinmask ) && ( ( ibe & pinmask ) || ( iev & pinmask ) ) ) // high level and posedge interrupt enabled
cmn_int_handler( INT_GPIO_POSEDGE, PLATFORM_IO_ENCODE( port, pin, 0 ) );
else if( ( ibe & pinmask ) || !( iev & pinmask ) ) // low level and negedge interrupt enabled
cmn_int_handler( INT_GPIO_NEGEDGE, PLATFORM_IO_ENCODE( port, pin, 0 ) );
HWREG( base + GPIO_O_ICR ) = pinmask;
}
}
//****************************************************************************
//
//! Set a value to the specified GPIO pin
//!
//! \param ucPin is the GPIO pin to be set (0:39)
//! \param uiGPIOPort is the GPIO port address
//! \param ucGPIOPin is the GPIO pin of the specified port
//!
//! This function
//! 1. Gets a value of the specified GPIO pin
//!
//! \return value of the GPIO pin
//
//****************************************************************************
unsigned char
GPIO_IF_Get(unsigned char ucPin,
unsigned int uiGPIOPort,
unsigned char ucGPIOPin)
{
unsigned char ucGPIOValue;
long lGPIOStatus;
//
// Invoke the API to Get the value
//
lGPIOStatus = MAP_GPIOPinRead(uiGPIOPort,ucGPIOPin);
//
// Set the corresponding bit in the bitmask
//
ucGPIOValue = lGPIOStatus >> (ucPin % 8);
return ucGPIOValue;
}
//*****************************************************************************
//
//! Initializes the GPIO pins used by the board pushbuttons.
//!
//! This function must be called during application initialization to
//! configure the GPIO pins to which the pushbuttons are attached. It enables
//! the port used by the buttons and configures each button GPIO as an input
//! with a weak pull-up.
//!
//! \return None.
//
//*****************************************************************************
void
ButtonsInit(void)
{
//
// Enable the GPIO port to which the pushbuttons are connected.
//
MAP_SysCtlPeripheralEnable(BUTTONS_GPIO_PERIPH);
//
// Set each of the button GPIO pins as an input with a pull-up.
//
MAP_GPIODirModeSet(BUTTONS_GPIO_BASE, ALL_BUTTONS, GPIO_DIR_MODE_IN);
MAP_GPIOPadConfigSet(BUTTONS_GPIO_BASE, ALL_BUTTONS,
GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
//
// Initialize the debounced button state with the current state read from
// the GPIO bank.
//
g_ui8ButtonStates = MAP_GPIOPinRead(BUTTONS_GPIO_BASE, ALL_BUTTONS);
}
STATIC uint8_t pin_get_value (const pin_obj_t* self) {
uint32_t value;
bool setdir = false;
if (self->mode == PIN_TYPE_OD || self->mode == GPIO_DIR_MODE_ALT_OD) {
setdir = true;
// configure the direction to IN for a moment in order to read the pin value
MAP_GPIODirModeSet(self->port, self->bit, GPIO_DIR_MODE_IN);
}
// now get the value
value = MAP_GPIOPinRead(self->port, self->bit);
if (setdir) {
// set the direction back to output
MAP_GPIODirModeSet(self->port, self->bit, GPIO_DIR_MODE_OUT);
if (self->value) {
MAP_GPIOPinWrite(self->port, self->bit, self->bit);
} else {
MAP_GPIOPinWrite(self->port, self->bit, 0);
}
}
// return it
return value ? 1 : 0;
}
// common interrupt handler
STATIC void EXTI_Handler(uint port) {
uint32_t bits = MAP_GPIOIntStatus(port, true);
MAP_GPIOIntClear(port, bits);
// might be that we have more than one pin interrupt pending
// therefore we must loop through all of the 8 possible bits
for (int i = 0; i < 8; i++) {
uint32_t bit = (1 << i);
if (bit & bits) {
pin_obj_t *self = (pin_obj_t *)pin_find_pin_by_port_bit(&pin_board_pins_locals_dict, port, bit);
if (self->irq_trigger == (PYB_PIN_FALLING_EDGE | PYB_PIN_RISING_EDGE)) {
// read the pin value (hoping that the pin level has remained stable)
self->irq_flags = MAP_GPIOPinRead(self->port, self->bit) ? PYB_PIN_RISING_EDGE : PYB_PIN_FALLING_EDGE;
} else {
// same as the triggers
self->irq_flags = self->irq_trigger;
}
mp_irq_handler(mp_irq_find(self));
// always clear the flags after leaving the user handler
self->irq_flags = 0;
}
}
}
//*****************************************************************************
//
// Called by the NVIC as a SysTick interrupt, which is used to generate the
// sample interval
//
//*****************************************************************************
void
SysTickIntHandler()
{
unsigned char sw_pin_status;
// get pressure data
BMP180DataRead(&g_sBMP180Inst, BMP180AppCallback, &g_sBMP180Inst);
// SW debounce
sw_pin_status = ~((unsigned char)(MAP_GPIOPinRead(SW_BASE, (SW1|SW2))));
if ( (sw_pin_status & SW1) != (sw_state & SW1) ){
sw1_debounce_count++;
if (sw1_debounce_count >= SW_DEBOUNCE_CNT){
sw_state = (sw_state & ~SW1) | (sw_pin_status & SW1);
sw1_debounce_count = 0;
}
}else{
sw1_debounce_count = 0;
}
if ( (sw_pin_status & SW2) != (sw_state & SW2) ){
sw2_debounce_count++;
if (sw2_debounce_count >= SW_DEBOUNCE_CNT){
sw_state = (sw_state & ~SW2) | (sw_pin_status & SW2);
sw2_debounce_count = 0;
}
}else{
sw2_debounce_count = 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);
}
}
void SpeakerControl(void* pValue)
{
int iCount=0;
unsigned long ulPin6Val = 1;
long lRetVal = -1;
//Check whether GPIO Level is Stable As No Debouncing Circuit in LP
for(iCount=0;iCount<3;iCount++)
{
osi_Sleep(200);
ulPin6Val = MAP_GPIOPinRead(GPIOA2_BASE,GPIO_PIN_6);
if(ulPin6Val)
{
//False Alarm
return;
}
}
if (g_ucSpkrStartFlag == 0)
{
#ifndef MULTICAST
//Un Register mDNS Service.
lRetVal = sl_NetAppMDNSUnRegisterService((signed char *)CC3200_MDNS_NAME,\
(unsigned char)strlen((const char *)CC3200_MDNS_NAME));
if(lRetVal < 0)
{
UART_PRINT("Unable to unregister MDNS service\n\r");
}
//Registering for the mDNS service.
lRetVal = sl_NetAppMDNSRegisterService((signed char *)CC3200_MDNS_NAME, \
(unsigned char)strlen((const char *)CC3200_MDNS_NAME),\
(signed char *)"multicast",\
(unsigned char)strlen((const char *)"multicast"),\
AUDIO_PORT,1000,0);
if(lRetVal < 0)
{
UART_PRINT("Unable to register MDNS service\n\r");
LOOP_FOREVER();
}
#endif
//Blink LED 3 times to Indicate ON
for(iCount = 0; iCount<3; iCount++)
{
GPIO_IF_LedOff(MCU_ORANGE_LED_GPIO);
osi_Sleep(50);
GPIO_IF_LedOn(MCU_ORANGE_LED_GPIO);
osi_Sleep(50);
}
g_ucSpkrStartFlag = 1;
}
else
{
//Un Register mDNS Service.
lRetVal = sl_NetAppMDNSUnRegisterService((signed char *)CC3200_MDNS_NAME,\
(unsigned char)strlen((const char *)CC3200_MDNS_NAME));
if(lRetVal < 0)
{
UART_PRINT("Unable to unregister MDNS service\n\r");
}
//Blink LED 3 times to Indicate OFF
for(iCount = 0; iCount<3; iCount++)
{
GPIO_IF_LedOn(MCU_ORANGE_LED_GPIO);
osi_Sleep(50);
GPIO_IF_LedOff(MCU_ORANGE_LED_GPIO);
osi_Sleep(50);
}
g_ucSpkrStartFlag = 0;
}
//Enable GPIO Interrupt
MAP_GPIOIntClear(GPIOA2_BASE,GPIO_PIN_6);
MAP_IntPendClear(INT_GPIOA2);
MAP_IntEnable(INT_GPIOA2);
MAP_GPIOIntEnable(GPIOA2_BASE,GPIO_PIN_6);
}
static bool safe_boot_request_start (uint32_t wait_time) {
if (MAP_GPIOPinRead(MICROPY_SAFE_BOOT_PORT, MICROPY_SAFE_BOOT_PORT_PIN)) {
UtilsDelay(UTILS_DELAY_US_TO_COUNT(wait_time * 1000));
}
return MAP_GPIOPinRead(MICROPY_SAFE_BOOT_PORT, MICROPY_SAFE_BOOT_PORT_PIN) ? true : false;
}
//*****************************************************************************
//
// Required by lwIP library to support any host-related timer functions.
//
//*****************************************************************************
void
lwIPHostTimerHandler(void)
{
uint32_t ui32Idx, ui32NewIPAddress;
//
// Get the current IP address.
//
ui32NewIPAddress = lwIPLocalIPAddrGet();
//
// See if the IP address has changed.
//
if(ui32NewIPAddress != g_ui32IPAddress)
{
//
// See if there is an IP address assigned.
//
if(ui32NewIPAddress == 0xffffffff)
{
//
// Indicate that there is no link.
//
UARTprintf("Waiting for link.\n");
}
else if(ui32NewIPAddress == 0)
{
//
// There is no IP address, so indicate that the DHCP process is
// running.
//
UARTprintf("Waiting for IP address.\n");
}
else
{
//
// Display the new IP address.
//
//UARTprintf("IP Address: ");
//DisplayIPAddress(ui32NewIPAddress);
//UARTprintf("\nOpen a browser and enter the IP address.\n");
}
//
// Save the new IP address.
//
g_ui32IPAddress = ui32NewIPAddress;
//
// Turn GPIO off.
//
MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, ~GPIO_PIN_1);
}
//
// If there is not an IP address.
//
if((ui32NewIPAddress == 0) || (ui32NewIPAddress == 0xffffffff))
{
//
// Loop through the LED animation.
//
for(ui32Idx = 1; ui32Idx < 17; ui32Idx++)
{
//
// Toggle the GPIO
//
MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1,
(MAP_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_1) ^
GPIO_PIN_1));
SysCtlDelay(120000000/(ui32Idx << 1));
}
}
}
long ReadWlanInterruptPin(void)
{
return MAP_GPIOPinRead(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN);
}
int gpio_get(int pin)
{
return MAP_GPIOPinRead(TO_BASE(pin), TO_PIN(pin));
}
int main()
{
//
// 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 from the PLL at 50MHZ, change to SYSCTL_SYSDIV_2_5 for 80MHz if neeeded
//
MAP_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
MAP_IntMasterDisable();
//
// Initialize the SW2 button
//
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;
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01;
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0);
MAP_GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA , GPIO_PIN_TYPE_STD_WPU);
//
// Initialize the communication layer with a default UART setting
//
AbstractComm * comm = NULL;
AbstractComm * uart_comm = new UARTComm();
purpinsComm communication(uart_comm);
//
// Initialize the robot object
//
purpinsRobot purpins;
//
// Initialize the EEPROM
//
purpinsSettings settings;
//
// Initialize the MPU6050-based IMU
//
mpudata_t mpu;
//unsigned long sample_rate = 10 ;
//mpu9150_init(0, sample_rate, 0);
memset(&mpu, 0, sizeof(mpudata_t));
//
// Get the current processor clock frequency.
//
ulClockMS = MAP_SysCtlClockGet() / (3 * 1000);
//unsigned long loop_delay = (1000 / sample_rate) - 2;
//
// Configure SysTick to occur 1000 times per second
//
MAP_SysTickPeriodSet(MAP_SysCtlClockGet() / SYSTICKS_PER_SECOND);
MAP_SysTickIntEnable();
MAP_SysTickEnable();
MAP_IntMasterEnable();
//
// Load the settings from EEPROM
//
// Load the robot's ID
settings.get(PP_SETTING_ID, &id, sizeof(uint32_t));
// Load the motors' PID gains
settings.get(PP_SETTING_LEFT_PID, purpins.leftPIDGains(), sizeof(PIDGains));
settings.get(PP_SETTING_RIGHT_PID, purpins.rightPIDGains(), sizeof(PIDGains));
// Load the communication type
uint32_t comm_type;
settings.get(PP_SETTING_COMM_TYPE, &comm_type, sizeof(uint32_t));
// Holding SW2 at startup forces USB Comm
if(comm_type != PP_COMM_TYPE_USB && MAP_GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_0) == 1)
{
if(comm_type == PP_COMM_TYPE_CC3000)
{
comm = new WiFiComm();
// Load network and server settings
settings.get(PP_SETTING_NETWORK_DATA, (static_cast<WiFiComm*>(comm))->network(), sizeof(Network));
settings.get(PP_SETTING_SERVER_DATA, (static_cast<WiFiComm*>(comm))->server(), sizeof(Server));
// Set WiFiComm as the underlying communication layer
communication.setCommLayer(comm);
}
else if(comm_type == PP_COMM_TYPE_ESP8266)
{
// TODO
}
else if(comm_type == PP_COMM_TYPE_XBEE)
{
// TODO
}
}
//
// Communication variables and stuff
//
uint8_t sensors_pack[SENSORS_PACK_SIZE];
bool send_pack = false;
unsigned long sensor_streaming_millis = 0;
unsigned long last_millis = millis();
uint8_t data[SERIAL_BUFFER_SIZE];
size_t data_size;
uint8_t action;
//
// Main loop, just managing communications
//
while(1)
{
//
// Check for a new action
//
action = communication.getMsg(data, data_size);
// If we got an action...
if(action > 0)
{
// Process it!!!
if(action == PP_ACTION_GET_VERSION)
{
uint8_t version = VERSION;
communication.sendMsg(PP_ACTION_GET_VERSION, (void*)(&version), 1);
}
else if(action == PP_ACTION_DRIVE)
{
RobotSpeed speed;
memcpy(&speed, data, sizeof(speed));
purpins.setSpeed(&speed);
communication.sendAck(PP_ACTION_DRIVE);
}
else if(action == PP_ACTION_DRIVE_MOTORS)
{
MotorSpeeds motor_speeds;
memcpy(&motor_speeds, data, sizeof(motor_speeds));
purpins.setMotorSpeeds(&motor_speeds);
communication.sendAck(PP_ACTION_DRIVE_MOTORS);
}
else if(action == PP_ACTION_DRIVE_PWM)
{
MotorPWMs motor_pwms;
memcpy(&motor_pwms, data, sizeof(motor_pwms));
purpins.setPWM(&motor_pwms);
communication.sendAck(PP_ACTION_DRIVE_PWM);
}
else if(action == PP_ACTION_GET_ODOMETRY)
{
Pose odometry;
purpins.getOdometry(&odometry);
communication.sendMsg(PP_ACTION_GET_ODOMETRY, (void*)(&odometry), sizeof(odometry));
}
else if(action == PP_ACTION_GET_MOTOR_SPEEDS)
{
MotorSpeeds speed;
purpins.getMotorSpeeds(&speed);
communication.sendMsg(PP_ACTION_GET_MOTOR_SPEEDS, (void*)(&speed), sizeof(speed));
}
else if(action == PP_ACTION_GET_ENCODER_PULSES)
{
EncoderPulses encoder_pulses;
purpins.getEncoderTicks(&encoder_pulses);
communication.sendMsg(PP_ACTION_GET_ENCODER_PULSES, (void*)(&encoder_pulses), sizeof(encoder_pulses));
}
else if(action == PP_ACTION_GET_IMU)
{
IMU imu_data;
imu_data.orientation_x = mpu.fusedQuat[0];
imu_data.orientation_y = mpu.fusedQuat[1];
imu_data.orientation_z = mpu.fusedQuat[2];
imu_data.orientation_w = mpu.fusedQuat[4];
imu_data.linear_acceleration_x = mpu.calibratedAccel[0];
imu_data.linear_acceleration_y = mpu.calibratedAccel[1];
imu_data.linear_acceleration_z = mpu.calibratedAccel[2];
imu_data.angular_velocity_x = mpu.calibratedMag[0];
imu_data.angular_velocity_y = mpu.calibratedMag[1];
imu_data.angular_velocity_z = mpu.calibratedMag[2];
communication.sendMsg(PP_ACTION_GET_IMU, (void*)(&imu_data), sizeof(imu_data));
}
else if(action == PP_ACTION_GET_IR_SENSORS)
{
// TODO: Add the IR sensors
}
else if(action == PP_ACTION_GET_GAS_SENSOR)
{
// TODO: Add the gas sensor
}
else if(action == PP_ACTION_SET_SENSORS_PACK)
{
bool ok = true;
memset(sensors_pack, 0, SENSORS_PACK_SIZE);
if(data_size > SENSORS_PACK_SIZE)
{
communication.error(PP_ERROR_BUFFER_SIZE);
ok = false;
break;
}
for(unsigned int i=0 ; i<data_size ; i++)
{
if(data[i] < PP_ACTION_GET_ODOMETRY || data[i] > PP_ACTION_GET_GAS_SENSOR)
{
communication.error(PP_ERROR_SENSOR_UNKNOWN);
ok = false;
break;
}
}
if(ok)
{
memcpy(sensors_pack, data, data_size);
communication.sendAck(PP_ACTION_SET_SENSORS_PACK);
}
}
else if(action == PP_ACTION_GET_SENSORS_PACK)
{
send_pack = true;
}
else if(action == PP_ACTION_SET_SENSOR_STREAMING)
{
float sensor_streaming_frequency;
memcpy(&sensor_streaming_frequency, data, sizeof(sensor_streaming_frequency));
sensor_streaming_millis = 1/sensor_streaming_frequency * 1000;
communication.sendAck(PP_ACTION_SET_SENSOR_STREAMING);
}
else if(action == PP_ACTION_SET_GLOBAL_POSE)
{
Pose pose;
memcpy(&pose, data, sizeof(pose));
purpins.setGlobalPose(&pose);
communication.sendAck(PP_ACTION_SET_GLOBAL_POSE);
}
else if(action == PP_ACTION_SET_NEIGHBORS_POSES)
{
// TODO: Finish this
}
else if(action == PP_ACTION_SET_ID)
{
memcpy(&id, data, sizeof(id));
settings.save(PP_SETTING_ID, data, sizeof(uint32_t));
communication.sendAck(PP_ACTION_SET_ID);
}
else if(action == PP_ACTION_GET_ID)
{
communication.sendMsg(PP_ACTION_GET_ID, (void*)(&id), sizeof(id));
}
else if(action == PP_ACTION_SET_PID_GAINS)
{
memcpy(purpins.leftPIDGains(), data, sizeof(PIDGains));
memcpy(purpins.rightPIDGains(), data+sizeof(PIDGains), sizeof(PIDGains));
settings.save(PP_SETTING_LEFT_PID, data, sizeof(PIDGains));
settings.save(PP_SETTING_RIGHT_PID, data+sizeof(PIDGains), sizeof(PIDGains));
communication.sendAck(PP_ACTION_SET_PID_GAINS);
}
else if(action == PP_ACTION_GET_PID_GAINS)
{
memcpy(data, purpins.leftPIDGains(), sizeof(PIDGains));
memcpy(data+sizeof(PIDGains), purpins.rightPIDGains(), sizeof(PIDGains));
communication.sendMsg(PP_ACTION_GET_ID, (void*)(data), 2*sizeof(PIDGains));
}
else if(action == PP_ACTION_SET_SERVER_DATA)
{
settings.save(PP_SETTING_SERVER_DATA, data, sizeof(Server));
communication.sendAck(PP_ACTION_SET_SERVER_DATA);
}
else if(action == PP_ACTION_GET_SERVER_DATA)
{
settings.get(PP_SETTING_SERVER_DATA, data, sizeof(Server));
communication.sendMsg(PP_ACTION_GET_SERVER_DATA, (void*)(data), sizeof(Server));
}
else if(action == PP_ACTION_SET_NETWORK_DATA)
{
settings.save(PP_SETTING_NETWORK_DATA, data, sizeof(Network));
communication.sendAck(PP_ACTION_SET_NETWORK_DATA);
}
else if(action == PP_ACTION_GET_NETWORK_DATA)
{
settings.get(PP_SETTING_NETWORK_DATA, data, sizeof(Network));
communication.sendMsg(PP_ACTION_GET_NETWORK_DATA, (void*)(data), sizeof(Network));
}
else if(action == PP_ACTION_SET_COMM_TYPE)
{
memcpy(&comm_type, data, sizeof(comm_type));
if(comm_type != communication.type())
{
if(comm_type == PP_COMM_TYPE_USB)
{
communication.setCommLayer(uart_comm);
if(comm != NULL) delete comm;
}
if(comm_type == PP_COMM_TYPE_CC3000)
{
if(comm != NULL) delete comm;
comm = new WiFiComm();
// Load network and server settings
settings.get(PP_SETTING_NETWORK_DATA, (static_cast<WiFiComm*>(comm))->network(), sizeof(Network));
settings.get(PP_SETTING_SERVER_DATA, (static_cast<WiFiComm*>(comm))->server(), sizeof(Server));
// Set WiFiComm as the underlying communication layer
communication.setCommLayer(comm);
}
else if(comm_type == PP_COMM_TYPE_ESP8266)
{
// TODO
}
else if(comm_type == PP_COMM_TYPE_XBEE)
{
// TODO
}
else
{
communication.error(PP_ERROR_COMM_UNKNOWN);
}
communication.sendAck(PP_ACTION_SET_COMM_TYPE);
}
}
} // if(action > 0)
//
// Manage sensor streaming
//
unsigned long current_millis = millis();
if(send_pack || (sensor_streaming_millis > 0 && (current_millis - last_millis) >= sensor_streaming_millis))
{
size_t size = 0;
for(int i=0 ; i<SENSORS_PACK_SIZE ; i++)
{
if(sensors_pack[i] == 0) break;
if(sensors_pack[i] == PP_ACTION_GET_ODOMETRY)
{
Pose odometry;
purpins.getOdometry(&odometry);
memcpy(data+size, &odometry, sizeof(odometry));
size += sizeof(odometry);
}
else if(sensors_pack[i] == PP_ACTION_GET_MOTOR_SPEEDS)
{
MotorSpeeds speed;
purpins.getMotorSpeeds(&speed);
memcpy(data+size, &speed, sizeof(speed));
size += sizeof(speed);
}
else if(sensors_pack[i] == PP_ACTION_GET_ENCODER_PULSES)
{
EncoderPulses encoder_pulses;
purpins.getEncoderTicks(&encoder_pulses);
memcpy(data+size, &encoder_pulses, sizeof(encoder_pulses));
size += sizeof(encoder_pulses);
}
else if(sensors_pack[i] == PP_ACTION_GET_IMU)
{
IMU imu_data;
imu_data.orientation_x = mpu.fusedQuat[0];
imu_data.orientation_y = mpu.fusedQuat[1];
imu_data.orientation_z = mpu.fusedQuat[2];
imu_data.orientation_w = mpu.fusedQuat[4];
imu_data.linear_acceleration_x = mpu.calibratedAccel[0];
imu_data.linear_acceleration_y = mpu.calibratedAccel[1];
imu_data.linear_acceleration_z = mpu.calibratedAccel[2];
imu_data.angular_velocity_x = mpu.calibratedMag[0];
imu_data.angular_velocity_y = mpu.calibratedMag[1];
imu_data.angular_velocity_z = mpu.calibratedMag[2];
memcpy(data+size, &imu_data, sizeof(imu_data));
size += sizeof(imu_data);
}
else if(sensors_pack[i] == PP_ACTION_GET_IR_SENSORS)
{
// TODO: Add the IR sensors
}
else if(sensors_pack[i] == PP_ACTION_GET_GAS_SENSOR)
{
// TODO: Add the gas sensor
}
}
communication.sendMsg(PP_ACTION_GET_SENSORS_PACK, (void*)(data), size);
last_millis = current_millis;
send_pack = false;
} // if(send_pack ...
} // while(1)
return 0;
}
//*****************************************************************************
//
//! Polls the current state of the buttons and determines which have changed.
//!
//! \param pui8Delta points to a character that will be written to indicate
//! which button states changed since the last time this function was called.
//! This value is derived from the debounced state of the buttons.
//! \param pui8RawState points to a location where the raw button state will
//! be stored.
//!
//! This function should be called periodically by the application to poll the
//! pushbuttons. It determines both the current debounced state of the buttons
//! and also which buttons have changed state since the last time the function
//! was called.
//!
//! In order for button debouncing to work properly, this function should be
//! caled at a regular interval, even if the state of the buttons is not needed
//! that often.
//!
//! If button debouncing is not required, the the caller can pass a pointer
//! for the \e pui8RawState parameter in order to get the raw state of the
//! buttons. The value returned in \e pui8RawState will be a bit mask where
//! a 1 indicates the buttons is pressed.
//!
//! \return Returns the current debounced state of the buttons where a 1 in the
//! button ID's position indicates that the button is pressed and a 0
//! indicates that it is released.
//
//*****************************************************************************
uint8_t
ButtonsPoll(uint8_t *pui8Delta, uint8_t *pui8RawState)
{
uint32_t ui32Delta;
uint32_t ui32Data;
static uint8_t ui8SwitchClockA = 0;
static uint8_t ui8SwitchClockB = 0;
//
// Read the raw state of the push buttons. Save the raw state
// (inverting the bit sense) if the caller supplied storage for the
// raw value.
//
ui32Data = (MAP_GPIOPinRead(BUTTONS_GPIO_BASE, ALL_BUTTONS));
if(pui8RawState) {
*pui8RawState = (uint8_t)~ui32Data;
}
//
// Determine the switches that are at a different state than the debounced
// state.
//
ui32Delta = ui32Data ^ g_ui8ButtonStates;
//
// Increment the clocks by one.
//
ui8SwitchClockA ^= ui8SwitchClockB;
ui8SwitchClockB = ~ui8SwitchClockB;
//
// Reset the clocks corresponding to switches that have not changed state.
//
ui8SwitchClockA &= ui32Delta;
ui8SwitchClockB &= ui32Delta;
//
// Get the new debounced switch state.
//
g_ui8ButtonStates &= ui8SwitchClockA | ui8SwitchClockB;
g_ui8ButtonStates |= (~(ui8SwitchClockA | ui8SwitchClockB)) & ui32Data;
//
// Determine the switches that just changed debounced state.
//
ui32Delta ^= (ui8SwitchClockA | ui8SwitchClockB);
//
// Store the bit mask for the buttons that have changed for return to
// caller.
//
if(pui8Delta) {
*pui8Delta = (uint8_t)ui32Delta;
}
//
// Return the debounced buttons states to the caller. Invert the bit
// sense so that a '1' indicates the button is pressed, which is a
// sensible way to interpret the return value.
//
return(~g_ui8ButtonStates);
}