int main(void)
{
//
// Device configuration: PLL is used, crystal of 16 MHz, main clock is the source clock
// System clock divider = 4
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// PF2 as output (blue led)
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LED_RED|LED_BLUE|LED_GREEN);
ButtonsInit(); // Init buttons
// Loop
while(1)
{
In = ROM_GPIOPinRead(BUTTONS_GPIO_BASE, RIGHT_BUTTON); // Read PORTF 0
if (In==0){
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_BLUE, LED_BLUE); // Turn on LED BLUE
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED, 0);
}
else {
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED, LED_RED); // Turn on LED RED
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_BLUE, 0);
}
}
}
void readSingleBlock(unsigned char *buf, unsigned int addr) {
ROM_GPIOPinWrite(LED_BASE, BUSY_LED, BUSY_LED);
unsigned char r = sendCommand(CMD17, addr);
if(r != 0x00){
#ifdef __UART_DEBUG
UARTprintf("Recieved error 0x%02x for CMD17(0x%02x)!\n",r,addr);
#endif
errorAndHang();
}
// read in what we've requested
do
r = tradeByte(0xff);
while (r == 0xff);
if(r != 0xfe) {
#ifdef __UART_DEBUG
UARTprintf("Invalid data token read, recieved %02x\n",r);
#endif
errorAndHang();
}
for(int i = 0; i < 512; i++)
buf[i] = tradeByte(0xff);
while(tradeByte(0xff) != 0xff);
ROM_GPIOPinWrite(LED_BASE, BUSY_LED, 0);
}
void writeSingleBlock(unsigned char *buf, unsigned int addr) {
ROM_GPIOPinWrite(LED_BASE, BUSY_LED, BUSY_LED);
unsigned char r = sendCommand(CMD24, addr);
if(r != 0x00){
#ifdef __UART_DEBUG
UARTprintf("Recieved error 0x%02x for CMD24(0x%02x)!\n",r,addr);
#endif
errorAndHang();
}
// block start token
tradeByte(0xfe);
// push out data packet
for(int i = 0; i < 512; i++)
tradeByte(buf[i]);
// CRC dummy bytes
r = tradeByte(0xff);
r = tradeByte(0xff);
// card is now busy, wait for it to stop
while(tradeByte(0xff) != 0xff);
ROM_GPIOPinWrite(LED_BASE, BUSY_LED, 0);
}
void board_toggle_led(led_t led) {
uint32_t port;
switch (led) {
case RED:
port = ROM_GPIOPinRead(LED_RED_PORTBASE, LED_RED);
port ^=LED_RED;
ROM_GPIOPinWrite(LED_RED_PORTBASE, LED_RED, port);
break;
case BLUE:
port = ROM_GPIOPinRead(LED_BLUE_PORTBASE, LED_BLUE);
port ^=LED_BLUE;
ROM_GPIOPinWrite(LED_BLUE_PORTBASE, LED_BLUE, port);
break;
case GREEN:
port = ROM_GPIOPinRead(LED_GREEN_PORTBASE, LED_GREEN);
port ^=LED_GREEN;
ROM_GPIOPinWrite(LED_GREEN_PORTBASE, LED_GREEN, port);
break;
default:
break;
}
}
// Fonction qui initialise le LCD
void init_lcd(void) {
// Enable ports on board
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
// Configure pins
ROM_GPIOPadConfigSet(GPIO_PORTE_BASE, 0xFF, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPD);
// Enable data as output
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTJ_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, 0xFF); // Toutes les pins
// Default values of pins to zero
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_RS | LCD_RW | LCD_E, 0x00);
ROM_GPIOPinWrite(GPIO_PORTE_BASE, 0xFF, 0x00);
// Set LCD to 2line mode
wait();
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_RS | LCD_RW, LCD_RS_Instruction | LCD_RW_Write);
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_E, LCD_E);
ROM_GPIOPinWrite(GPIO_PORTE_BASE, 0xFF, 0x38);
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_E, 0);
// Activate cursor blinking
wait();
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_RS | LCD_RW, LCD_RS_Instruction | LCD_RW_Write);
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_E, LCD_E);
ROM_GPIOPinWrite(GPIO_PORTE_BASE, 0xFF, 0x0F);
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_E, 0);
// Clear LCD
clear();
}
//*****************************************************************************
//
// This is the handler for INT_GPIOA. It simply saves the interrupt sequence
// number.
//
//*****************************************************************************
void
IntGPIOa(void)
{
//
// Set PE1 high to indicate entry to this interrupt handler.
//
ROM_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_1, GPIO_PIN_1);
//
// Put the current interrupt state on the display.
//
DisplayIntStatus();
//
// Wait two seconds.
//
Delay(2);
//
// Save and increment the interrupt sequence number.
//
g_ui32GPIOa = g_ui32Index++;
//
// Set PE1 low to indicate exit from this interrupt handler.
//
ROM_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_1, 0);
}
//Fonction qui écrit le charactère "mychar" en mémoire du LCD
void write_char(char mychar) {
wait();
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_RS | LCD_RW, LCD_RS_Display | LCD_RW_Write);
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_E, LCD_E);
ROM_GPIOPinWrite(GPIO_PORTE_BASE, 0xFF, mychar);
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_E, 0);
}
static void Config_PWM(void)
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_GPIOPinConfigure(GPIO_PB6_T0CCP0);
ROM_GPIOPinConfigure(GPIO_PB2_T3CCP0);
ROM_GPIOPinTypeTimer(GPIO_PORTB_BASE, GPIO_PIN_2 | GPIO_PIN_6);
// Configure timer
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER3);
ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_PWM);
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, DEFAULT);
ROM_TimerMatchSet(TIMER0_BASE, TIMER_A, DEFAULT); // PWM
ROM_TimerEnable(TIMER0_BASE, TIMER_A);
ROM_TimerConfigure(TIMER3_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_PWM);
ROM_TimerLoadSet(TIMER3_BASE, TIMER_A, DEFAULT);
ROM_TimerMatchSet(TIMER3_BASE, TIMER_A, DEFAULT); // PWM
ROM_TimerControlLevel(TIMER3_BASE, TIMER_A, true);
ROM_TimerEnable(TIMER3_BASE, TIMER_A);
ROM_SysCtlPeripheralEnable(DRV_ENABLE_LEFT_CHN_PERIPHERAL);
ROM_SysCtlPeripheralEnable(DRV_ENABLE_RIGHT_CHN_PERIPHERAL);
ROM_GPIOPinTypeGPIOOutput(DRV_ENABLE_LEFT_CHN_PORT, DRV_ENABLE_LEFT_CHN_PIN);
ROM_GPIOPinTypeGPIOOutput(DRV_ENABLE_RIGHT_CHN_PORT, DRV_ENABLE_RIGHT_CHN_PIN);
ROM_GPIOPinWrite(DRV_ENABLE_LEFT_CHN_PORT, DRV_ENABLE_LEFT_CHN_PIN, 0);
ROM_GPIOPinWrite(DRV_ENABLE_RIGHT_CHN_PORT, DRV_ENABLE_RIGHT_CHN_PIN, 0);
}
//*****************************************************************************
//
// Waits until a program/erase operation has completed.
//
//*****************************************************************************
static void
MX66L51235FWait(void)
{
uint8_t ui8Status;
//
// Loop until the requested operation has completed.
//
do {
//
// Assert the chip select to the MX66L51235F.
//
ROM_GPIOPinWrite(GPIO_PORTQ_BASE, GPIO_PIN_1, 0);
//
// Read the status register.
//
ui8Status = ROM_SPIFlashReadStatus(SSI3_BASE);
//
// De-assert the chip select to the MX66L51235F.
//
ROM_GPIOPinWrite(GPIO_PORTQ_BASE, GPIO_PIN_1, GPIO_PIN_1);
} while(ui8Status & 1);
}
// Triggered every SERVO_TIMER_RESOLUTION microseconds
void TimerIntHandlerServos(void) {
// Clear the interrupt
ROM_TimerIntClear(SERVO_TIMER, SERVO_TIMER_TRIGGER);
// SERVO_TIMER_RESOLUTION microseconds have passed, increment each counter by that
// to determine how long to set the pin high for
g_pulseTime += SERVO_TIMER_RESOLUTION;
if(g_pulseTime > SERVO_PERIOD) {
g_pulseTime = 0;
}
// Loop through al servo configs and see if they need to be set low yet
uint8_t i;
for(i=0; i<SERVO_MAX_COUNT; i++) {
servo_t *servo = &g_servos[i];
if(servo->state & SERVO_STATE_ENABLED) {
if(g_pulseTime >= servo->value) {
// End of pulse, set low
ROM_GPIOPinWrite(servo->port, servo->pin, 0);
} else {
// Beginning of pulse, set high
ROM_GPIOPinWrite(servo->port, servo->pin, servo->pin);
}
}
}
}
void motor_enable()
{
ROM_GPIOPinWrite( MOTOR_XENPORT, MOTOR_XEN, 0 );
ROM_GPIOPinWrite( MOTOR_YENPORT, MOTOR_YEN, 0 );
ROM_GPIOPinWrite( MOTOR_ZENPORT, MOTOR_ZEN, 0 );
ROM_GPIOPinWrite( MOTOR_EENPORT, MOTOR_EEN, 0 );
motors_enabled = true;
}
void motor_disable()
{
ROM_GPIOPinWrite( MOTOR_XENPORT, MOTOR_XEN, MOTOR_XEN );
ROM_GPIOPinWrite( MOTOR_YENPORT, MOTOR_YEN, MOTOR_YEN );
ROM_GPIOPinWrite( MOTOR_ZENPORT, MOTOR_ZEN, MOTOR_ZEN );
ROM_GPIOPinWrite( MOTOR_EENPORT, MOTOR_EEN, MOTOR_EEN );
motors_enabled = false;
}
void motor_unstep()
{
ROM_GPIOPinWrite(LED_PORT, LED_R | LED_G | LED_B, 0 );
ROM_GPIOPinWrite( MOTOR_XSTEPPORT, MOTOR_XPIN, 0);
ROM_GPIOPinWrite( MOTOR_YSTEPPORT, MOTOR_YPIN, 0);
ROM_GPIOPinWrite( MOTOR_ZSTEPPORT, MOTOR_ZPIN, 0);
ROM_GPIOPinWrite( MOTOR_ESTEPPORT, MOTOR_EPIN, 0);
}
//*****************************************************************************
//
// Writes the extended address register, allowing the full contents of the
// MX66L51235F to be accessed.
//
//*****************************************************************************
static void
MX66L51235FWriteEAR(uint32_t ui32Addr)
{
//
// See if the extended address register needs to be written.
//
if((ui32Addr & 0xff000000) == (g_ui32MX66L51235FAddr & 0xff000000)) {
//
// The extended address register does not need to be changed, so return
// without doing anything.
//
return;
}
//
// Save the new value of the extended address register.
//
g_ui32MX66L51235FAddr = ui32Addr;
//
// Enable program/erase of the SPI flash.
//
MX66L51235FWriteEnable();
//
// Assert the chip select to the MX66L51235F.
//
ROM_GPIOPinWrite(GPIO_PORTQ_BASE, GPIO_PIN_1, 0);
//
// Set the SSI module into write-only mode.
//
ROM_SSIAdvModeSet(SSI3_BASE, SSI_ADV_MODE_WRITE);
//
// Send the sector erase command.
//
ROM_SSIDataPut(SSI3_BASE, 0xc5);
//
// Send the address of the sector to be erased, marking the last byte of
// the address as the end of the frame.
//
ROM_SSIAdvDataPutFrameEnd(SSI3_BASE, (ui32Addr >> 24) & 0xff);
//
// Wait until the command has been completely transmitted.
//
while(ROM_SSIBusy(SSI3_BASE)) {
}
//
// De-assert the chip select to the MX66L51235F.
//
ROM_GPIOPinWrite(GPIO_PORTQ_BASE, GPIO_PIN_1, GPIO_PIN_1);
}
void lcd_init() {
ROM_SysCtlPeripheralEnable(LCD_PORTENABLE);
ROM_GPIOPinTypeGPIOOutput(LCD_PORT, (LCD_RS | LCD_E | LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7));
// Please refer to the HLCD_D44780 datasheet for how these initializations work!
ROM_SysCtlDelay(ROM_SysCtlClockGet()/3/2);
ROM_GPIOPinWrite(LCD_PORT, LCD_RS, 0x00);
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, 0x30);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3); ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((50e-3)*ROM_SysCtlClockGet()/3);
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, 0x30);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3);ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((50e-3)*ROM_SysCtlClockGet()/3);
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, 0x30);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3); ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((10e-3)*ROM_SysCtlClockGet()/3);
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, 0x20);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3); ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((10e-3)*ROM_SysCtlClockGet()/3);
lcd_command(LCD_CLEARDISPLAY); // Clear the screen.
lcd_command(0x06); // Cursor moves right.
lcd_command(LCD_DISPLAYCONTROL | LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF); // Don't show any cursor, turn on LCD.
}
void system_Enable_BoostCircuit(bool Enable)
{
if (Enable)
{
ROM_GPIOPinWrite(BOOST_ENABLE_PORT, BOOST_ENABLE_PIN, 0xff);
}
else
{
ROM_GPIOPinWrite(BOOST_ENABLE_PORT, BOOST_ENABLE_PIN, 0x00);
}
}
/*turn off selected leds*/
void led_off(u32 led)
{
if (led == LED_2)
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0);
if (led == LED_1)
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0);
if (led == LED_3)
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
}
//Fonction qui effectue un "Clear" sur le LCD et qui met les nom des équipiers sur la ligne du haut.
void clear(void) {
// Clear LCD
wait();
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_RS | LCD_RW, LCD_RS_Instruction | LCD_RW_Write);
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_E, LCD_E);
ROM_GPIOPinWrite(GPIO_PORTE_BASE, 0xFF, 0x01);
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_E, 0);
// Write names
write_position();
// Reset counter
nbrchar = 0;
}
int main()
{
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LED_RED|LED_BLUE|LED_GREEN);
for (;;) {
// set the red LED pin high, others low
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE, LED_RED);
ROM_SysCtlDelay(4000000);
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE, 0);
ROM_SysCtlDelay(5000000);
}
}
/**
* @brief Control Hbridge
*/
void speed_Enable_Hbridge(bool Enable)
{
if (Enable)
{
ROM_GPIOPinWrite(DRV_ENABLE_LEFT_CHN_PORT, DRV_ENABLE_LEFT_CHN_PIN, DRV_ENABLE_LEFT_CHN_PIN);
ROM_GPIOPinWrite(DRV_ENABLE_RIGHT_CHN_PORT, DRV_ENABLE_RIGHT_CHN_PIN, DRV_ENABLE_RIGHT_CHN_PIN);
}
else
{
ROM_GPIOPinWrite(DRV_ENABLE_LEFT_CHN_PORT, DRV_ENABLE_LEFT_CHN_PIN, 0);
ROM_GPIOPinWrite(DRV_ENABLE_RIGHT_CHN_PORT, DRV_ENABLE_RIGHT_CHN_PIN, 0);
}
}
static inline void shift_bit(shiftbrite* sb, uint16_t val) {
if( val )
{
ROM_GPIOPinWrite( sb->data_pin.port, sb->data_pin.pin, sb->data_pin.pin );
}
else
{
ROM_GPIOPinWrite( sb->data_pin.port, sb->data_pin.pin, ~sb->data_pin.pin );
}
ROM_SysCtlDelay(5);
pulse(sb->clock_pin);
}
//*****************************************************************************
//
//! Toggle one or both of the EVALBOT LEDs.
//!
//! \param eLED indicates the LED or LEDs to toggle. Valid values are \e
//! LED_1, \e LED_2 or \e BOTH_LEDS.
//!
//! This function may be used to toggle either one or both of the LEDs on the
//! EVALBOT. If the LED is currently lit, it will be turned off and vice verse.
//! Callers must ensure that they have previously called LEDsInit().
//!
//! \return None.
//
//*****************************************************************************
void
LED_Toggle (tLED eLED)
{
//
// Check for invalid parameter values.
//
ASSERT((eLED == BOTH_LEDS) || (eLED == LED_1) || (eLED == LED_2));
//
// Which LED are we to toggle?
//
switch (eLED)
{
//
// Toggle both LEDs.
//
case BOTH_LEDS:
{
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_4 | GPIO_PIN_5,
~ROM_GPIOPinRead(GPIO_PORTF_BASE,
GPIO_PIN_4 | GPIO_PIN_5));
break;
}
//
// Toggle LED 1.
//
case LED_1:
{
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_4,
~ROM_GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4));
break;
}
//
// Toggle LED 2.
//
case LED_2:
{
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_5,
~ROM_GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_5));
break;
}
//
// An invalid value was passed.
//
default:
break;
}
}
// Fonction qui gère le temps de traitement du LCD
void wait(void) {
// Change pin type
ROM_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, 0xFF); // Toutes les pins
//Read busy flag until it's 0
volatile unsigned long busyflag;
do {
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_RS | LCD_RW, LCD_RS_Instruction | LCD_RW_Read);
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_E, LCD_E);
busyflag = ROM_GPIOPinRead(GPIO_PORTE_BASE, GPIO_PIN_7);
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, LCD_E, 0);
} while(busyflag == 128);
// Restore pin type
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, 0xFF); // Toutes les pins
}
void signalUnhandleError(void)
{
while (1)
{
ROM_GPIOPinWrite(LED_PORT_BASE, LED_ALL, LED_RED);
ROM_SysCtlDelay(2000000);
ROM_GPIOPinWrite(LED_PORT_BASE, LED_ALL, LED_GREEN);
ROM_SysCtlDelay(2000000);
ROM_GPIOPinWrite(LED_PORT_BASE, LED_ALL, LED_BLUE);
ROM_SysCtlDelay(2000000);
}
}
//*****************************************************************************
//
//! Turn one or both of the EVALBOT LEDs on.
//!
//! \param eLED indicates the LED or LEDs to turn on. Valid values are \e
//! LED_1, \e LED_2 or \e BOTH_LEDS.
//!
//! This function may be used to light either one or both of the LEDs on the
//! EVALBOT. Callers must ensure that they have previously called LEDsInit().
//!
//! \return None.
//
//*****************************************************************************
void
LED_On(tLED eLED)
{
//
// Check for invalid parameter values.
//
ASSERT((eLED == BOTH_LEDS) || (eLED == LED_1) || (eLED == LED_2));
//
// Which LED are we to turn on?
//
switch (eLED)
{
//
// Turn both LEDs on.
//
case BOTH_LEDS:
{
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_4 | GPIO_PIN_5,
GPIO_PIN_4 | GPIO_PIN_5);
break;
}
//
// Turn LED 1 on.
//
case LED_1:
{
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_PIN_4);
break;
}
//
// Turn LED 2 on.
//
case LED_2:
{
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_5, GPIO_PIN_5);
break;
}
//
// An invalid LED value was passed.
//
default:
break;
}
}
// Main ----------------------------------------------------------------------------------------------
int main(void){
// Enable lazy stacking
ROM_FPULazyStackingEnable();
// Set the system clock to run at 40Mhz off PLL with external crystal as reference.
ROM_SysCtlClockSet(SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);
// Initialize the UART and write status.
ConfigureUART();
UARTprintf("ISL29023 Example\n");
// Enable LEDs
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LED_RED|LED_BLUE|LED_GREEN);
// Enable I2C3
ConfigureI2C3();
// Create struct
tISL29023 islSensHub;
// Create print variables
uint32_t printValue[2];
ISL29023ChangeSettings(ISL29023_COMMANDII_RANGE64k, ISL29023_COMMANDII_RES16, &islSensHub);
while(1){
// Get ALS
ISL29023GetALS(&islSensHub);
FloatToPrint(islSensHub.alsVal, printValue);
UARTprintf("ALS: %d.%03d |.| ",printValue[0],printValue[1]);
// Get IR
ISL29023GetIR(&islSensHub);
FloatToPrint(islSensHub.irVal, printValue);
UARTprintf("IR: %d.%03d\n",printValue[0],printValue[1]);
// Blink LED
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE, LED_GREEN);
ROM_SysCtlDelay(ROM_SysCtlClockGet()/3/10); // Delay for 100ms (1/10s) :: ClockGet()/3 = 1second
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE, 0);
// Delay for second
ROM_SysCtlDelay(ROM_SysCtlClockGet()/3);
}
}
//*****************************************************************************
//
// Initialize the IO used in this demo
//
//*****************************************************************************
void
io_init(void)
{
//
// Configure Port F0 for as an output for the status LED.
//
ROM_GPIOPinTypeGPIOOutput(LED_PORT_BASE, LED_PIN);
//
// Initialize LED to OFF (0)
//
ROM_GPIOPinWrite(LED_PORT_BASE, LED_PIN, 0);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER2);
//
// Configure the timer used to pace the animation.
//
ROM_TimerConfigure(TIMER2_BASE, TIMER_CFG_PERIODIC);
//
// Setup the interrupts for the timer timeouts.
//
ROM_IntEnable(INT_TIMER2A);
ROM_TimerIntEnable(TIMER2_BASE, TIMER_TIMA_TIMEOUT);
//
// Set the timer for the current animation speed. This enables the
// timer as a side effect.
//
io_set_timer(g_ulAnimSpeed);
}
//*****************************************************************************
//
// The interrupt handler for the watchdog. This feeds the dog (so that the
// processor does not get reset) and winks the LED connected to GPIO B3.
//
//*****************************************************************************
void
WatchdogIntHandler(void)
{
//
// If we have been told to stop feeding the watchdog, return immediately
// without clearing the interrupt. This will cause the system to reset
// next time the watchdog interrupt fires.
//
if(!g_bFeedWatchdog)
{
return;
}
//
// Clear the watchdog interrupt.
//
ROM_WatchdogIntClear(WATCHDOG0_BASE);
//
// Invert the GPIO PN0 value.
//
ROM_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0,
(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_0) ^
GPIO_PIN_0));
}
int8_t CMD_set_test(uint8_t argc, uint8_t **argv) {
if(argc == 1){
// Turn red LED on.
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_3|GPIO_PIN_2, GPIO_PIN_2);
}
return 0;
}
void Init_LED()
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_4); //配置PF4为数值输出
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_PIN_4); //PF4,输出高电平
}
