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