/**
* Read Control Register (RCR)
*/
uint8_t enc_rcr(uint8_t reg) {
MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, 0);
spi_send(reg);
uint8_t b = spi_send(0xFF);
MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, ENC_CS);
return b;
}
//*****************************************************************************
//
//! 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);
}
void arch_GpioSet(uint_t nPort, uint_t nPin, uint_t nHL)
{
if (nHL)
MAP_GPIOPinWrite(arch_GpioPortBase(nPort), BITMASK(nPin), 0xFF);
else
MAP_GPIOPinWrite(arch_GpioPortBase(nPort), BITMASK(nPin), 0);
}
/**
* Sets reset pin to given value
* @param value true to bring reset high, false for low
*/
void xbd_reset(bool value){/*{{{*/
if(value){
MAP_GPIOPinWrite(GPIO_PORTC_BASE, RESET_PIN, RESET_PIN);
}else{
MAP_GPIOPinWrite(GPIO_PORTC_BASE, RESET_PIN, 0);
}
}/*}}}*/
/**
* Bit Field Clear.
* Clear the bits of argument 'mask' in the register 'reg'.
* Not valid for MAC and MII registers.
*/
void enc_bfc(uint8_t reg, uint8_t mask) {
MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, 0);
spi_send(0xA0 | reg);
spi_send(mask);
MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, ENC_CS);
}
//*****************************************************************************
//
// This function turns the USER LED ON/OFF
//
//!
//! \param ledNum is the LED Number
//!
//! \return none
//!
//! \brief Turns a specific LED Off
//
//*****************************************************************************
void turnLedOn(char ledNum)
{
switch (ledNum)
{
//RED
case 1:
//turn other blue and green LED off
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, PIN_LOW);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, PIN_LOW);
//turn RED LED on
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, PIN_HIGH);
break;
//Blue
case 2:
//turn other red and green LED off
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, PIN_LOW);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, PIN_LOW);
//turn BLUE LED on
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, PIN_HIGH);
break;
//Green
case 3:
//turn other red and blue LED off
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, PIN_LOW);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, PIN_LOW);
//turn GREEN LED on
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, PIN_HIGH);
break;
}
}
void WriteWlanPin( unsigned char val )
{
if(val)
{
MAP_GPIOPinWrite(SPI_GPIO_IRQ_BASE, SPI_EN_PIN,PIN_HIGH);
}
else
{
MAP_GPIOPinWrite(SPI_GPIO_IRQ_BASE, SPI_EN_PIN, PIN_LOW);
}
}
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;
}
/**
* Read Buffer Memory.
*/
void enc_rbm(uint8_t *buf, uint16_t count) {
MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, 0);
spi_send(0x20 | 0x1A);
int i;
for (i = 0; i < count; i++) {
*buf = spi_send(0xFF);
buf++;
}
MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, ENC_CS);
}
/**
* Write Buffer Memory.
*/
void enc_wbm(const uint8_t *buf, uint16_t count) {
MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, 0);
spi_send(0x60 | 0x1A);
int i;
for (i = 0; i < count; i++) {
spi_send(*buf);
buf++;
}
MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, ENC_CS);
}
void AntennaSelect(unsigned char ucAntNum)
{
if(ucAntNum == 1)
{
MAP_GPIOPinWrite(GPIOA3_BASE, 0xC, 0x8);
}
else if(ucAntNum == 2)
{
MAP_GPIOPinWrite(GPIOA3_BASE, 0xC, 0x4);
}
return;
}
void antenna_select (antenna_type_t _antenna) {
if (_antenna == ANTENNA_TYPE_INTERNAL) {
MAP_GPIOPinWrite(GPIOA3_BASE, 0x0C, 0x04);
// also configure the pull-up and pull-down accordingly
HWREG(REG_PAD_CONFIG_26) = ((HWREG(REG_PAD_CONFIG_26) & ~PAD_TYPE_MASK)) | PIN_TYPE_STD_PU;
HWREG(REG_PAD_CONFIG_27) = ((HWREG(REG_PAD_CONFIG_27) & ~PAD_TYPE_MASK)) | PIN_TYPE_STD_PD;
} else {
MAP_GPIOPinWrite(GPIOA3_BASE, 0x0C, 0x08);
// also configure the pull-up and pull-down accordingly
HWREG(REG_PAD_CONFIG_26) = ((HWREG(REG_PAD_CONFIG_26) & ~PAD_TYPE_MASK)) | PIN_TYPE_STD_PD;
HWREG(REG_PAD_CONFIG_27) = ((HWREG(REG_PAD_CONFIG_27) & ~PAD_TYPE_MASK)) | PIN_TYPE_STD_PU;
}
antenna_type_selected = _antenna;
}
/// \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;
}
}
//*****************************************************************************
//
// 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);
}
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);
}
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);
}
}
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);
}
STATIC void pin_obj_configure (const pin_obj_t *self) {
uint32_t type;
if (self->mode == PIN_TYPE_ANALOG) {
type = PIN_TYPE_ANALOG;
} else {
type = self->pull;
uint32_t direction = self->mode;
if (direction == PIN_TYPE_OD || direction == GPIO_DIR_MODE_ALT_OD) {
direction = GPIO_DIR_MODE_OUT;
type |= PIN_TYPE_OD;
}
if (self->mode != GPIO_DIR_MODE_ALT && self->mode != GPIO_DIR_MODE_ALT_OD) {
// enable the peripheral clock for the GPIO port of this pin
switch (self->port) {
case PORT_A0:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA0, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
case PORT_A1:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
case PORT_A2:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA2, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
case PORT_A3:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA3, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
default:
break;
}
// set the pin value
if (self->value) {
MAP_GPIOPinWrite(self->port, self->bit, self->bit);
} else {
MAP_GPIOPinWrite(self->port, self->bit, 0);
}
// configure the direction
MAP_GPIODirModeSet(self->port, self->bit, direction);
}
// now set the alternate function
MAP_PinModeSet (self->pin_num, self->af);
}
MAP_PinConfigSet(self->pin_num, self->strength, type);
}
//*****************************************************************************
//
//! Turn LED Off
//!
//! \param ledNum is the LED Number
//!
//! \return none
//!
//! \brief Turns a specific LED Off
//
//*****************************************************************************
void turnLedOff(char ledNum)
{
switch (ledNum)
{
//RED
case 1:
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, PIN_LOW);
//Blue
case 2:
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, PIN_LOW);
//Green
case 3:
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, PIN_LOW);
}
}
//*****************************************************************************
//
//! 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);
}
//*****************************************************************************
//! 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;
}
/*
* @brief Deselects all select/latch pins
* Waits till all transfers are finished
* @return if their is a error return FALSE else ture
*/
boolean SPIDeselectISR(void) {
// wait until the last transfer is finished
volatile uint16 i = 0;
while (MAP_SSIBusy(SSI0_BASE)) {
i++;
if (i > SPI_MAX_XFER_IRQ_DELAY) {
SPIBusError_SPIDeselectISR = TRUE;
return FALSE;
}
}
i = i + 1;
#if (defined(RONE_V12) || defined(RONE_V9))
//set output enable low, which pulls all spi select lines high
MAP_GPIOPinWrite(SPI_ENABLE_PORT, SPI_ENABLE_PIN, 0);
MAP_GPIOPinWrite(SPI_SELECT_PORT, SPI_SELECT_PINS, NULL_SELECT_PINS);
#endif
return TRUE;
}
//*****************************************************************************
//! 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;
}
//*****************************************************************************
//
// Called by the NVIC as a SysTick interrupt, which is used to generate the
// sample interval
//
//*****************************************************************************
void
SysTickIntHandler()
{
//
// Blink the blue LED to indicate data read from BMP180.
//
MAP_GPIOPinWrite(GPIO_PORTQ_BASE, GPIO_PIN_4,
((GPIOPinRead(GPIO_PORTQ_BASE, GPIO_PIN_4)) ^
GPIO_PIN_4));
BMP180DataRead(&g_sBMP180Inst, BMP180AppCallback, &g_sBMP180Inst);
}
//*****************************************************************************
//! Load the proper image based on information from boot info and executes it.
//*****************************************************************************
static void bootmgr_image_loader(sBootInfo_t *psBootInfo) {
_i32 fhandle;
if (safe_mode_boot()) {
_u32 count = 0;
while ((BOOTMGR_SAFE_MODE_ENTER_TOOGLE_MS * count++) < BOOTMGR_SAFE_MODE_ENTER_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_SAFE_MODE_ENTER_TOOGLE_MS * 1000));
}
psBootInfo->ActiveImg = IMG_ACT_FACTORY;
// turn the led off
MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, 0);
// request a safe boot to the application
PRCMRequestSafeBoot();
}
// do we have a new update image that needs to be verified?
else if ((psBootInfo->ActiveImg == IMG_ACT_UPDATE) && (psBootInfo->Status == IMG_STATUS_CHECK)) {
if (!bootmgr_verify()) {
// delete the corrupted file
sl_FsDel((_u8 *)IMG_UPDATE, 0);
// switch to the factory image
psBootInfo->ActiveImg = IMG_ACT_FACTORY;
}
// in any case, set the status as "READY"
psBootInfo->Status = IMG_STATUS_READY;
// write the new boot info
if (!sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_WRITE, NULL, &fhandle)) {
sl_FsWrite(fhandle, 0, (unsigned char *)psBootInfo, sizeof(sBootInfo_t));
// close the file
sl_FsClose(fhandle, 0, 0, 0);
}
}
// now boot the active image
if (IMG_ACT_UPDATE == psBootInfo->ActiveImg) {
bootmgr_load_and_execute((unsigned char *)IMG_UPDATE);
}
else {
bootmgr_load_and_execute((unsigned char *)IMG_FACTORY);
}
}
void TimerBaseIntHandlerB(void)
{
if(HWREG(TIMERA0_BASE + TIMER_O_MIS) & 0x800)
{
// Match interrupt
HWREG(TIMERA0_BASE + TIMER_O_ICR) = 0x800;
if(speedRight > 0)
{
MAP_GPIOPinWrite(port_bin1, pin_bin1, 0);
MAP_GPIOPinWrite(port_bin2, pin_bin2, bitB2);
}
else
{
MAP_GPIOPinWrite(port_bin1, pin_bin1, bitB1);
MAP_GPIOPinWrite(port_bin2, pin_bin2, 0);
}
}
else
{
// Overflow interrupt
HWREG(TIMERA0_BASE + TIMER_O_ICR) = 0x100;
MAP_GPIOPinWrite(port_bin1, pin_bin1, bitB1);
MAP_GPIOPinWrite(port_bin2, pin_bin2, bitB2);
}
}
void TimerBaseIntHandlerA(void)
{
if(HWREG(TIMERA0_BASE + TIMER_O_MIS) & 0x10)
{
// Match interrupt
HWREG(TIMERA0_BASE + TIMER_O_ICR) = 0x10;
if(speedLeft > 0)
{
MAP_GPIOPinWrite(port_ain1, pin_ain1, 0);
MAP_GPIOPinWrite(port_ain2, pin_ain2, bitA2);
}
else
{
MAP_GPIOPinWrite(port_ain1, pin_ain1, bitA1);
MAP_GPIOPinWrite(port_ain2, pin_ain2, 0);
}
}
else
{
// Overflow interrupt
HWREG(TIMERA0_BASE + TIMER_O_ICR) = 0x1;
MAP_GPIOPinWrite(port_ain1, pin_ain1, bitA1);
MAP_GPIOPinWrite(port_ain2, pin_ain2, bitA2);
}
}
//*****************************************************************************
//
// 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);
}
//*****************************************************************************
//
// Deasserts the chip select for the TRF79x0
//
//*****************************************************************************
void
SSITRF79x0ChipSelectDeAssert(void)
{
//
// Deassert the chip select for the TRF79x0.
//
MAP_GPIOPinWrite(TRF79X0_CS_BASE, TRF79X0_CS_PIN, TRF79X0_CS_PIN);
//
// Enable interrupt associated with the TRF79x0.
//
TRF79x0InterruptEnable();
}
//*****************************************************************************
//
// Asserts the chip select for the TRF79x0.
//
//*****************************************************************************
void
SSITRF79x0ChipSelectAssert(void)
{
//
// Disable the interrupt associated with the TRF79x0.
//
TRF79x0InterruptDisable();
//
// Assert the chip select for TRF79x0.
//
MAP_GPIOPinWrite(TRF79X0_CS_BASE, TRF79X0_CS_PIN, 0);
}