void __malloc_unlock(struct _reent *reent) { --lock; if (lock == 0) { IntMasterEnable(); } }
// ******************************************************* // Resets the systick counter to a desired time. // Becareful of the systick rate! void mRTCSet(unsigned long long ullTime) { IntMasterDisable(); g_ullRTCTicks = ullTime; IntMasterEnable(); }
//***************************************************************************** // // Configure the I2C0 master and slave and connect them using loopback mode. // //***************************************************************************** int main(void) { uint32_t ui32DataTx; // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // The I2C0 peripheral must be enabled before use. // SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C0); // // For this example I2C0 is used with PortB[3:2]. The actual port and // pins used may be different on your part, consult the data sheet for // more information. GPIO port B needs to be enabled so these pins can // be used. // TODO: change this to whichever GPIO port you are using. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // // Configure the pin muxing for I2C0 functions on port B2 and B3. // This step is not necessary if your part does not support pin muxing. // TODO: change this to select the port/pin you are using. // GPIOPinConfigure(GPIO_PB2_I2C0SCL); GPIOPinConfigure(GPIO_PB3_I2C0SDA); // // Select the I2C function for these pins. This function will also // configure the GPIO pins pins for I2C operation, setting them to // open-drain operation with weak pull-ups. Consult the data sheet // to see which functions are allocated per pin. // TODO: change this to select the port/pin you are using. // GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_2 | GPIO_PIN_3); // // Enable loopback mode. Loopback mode is a built in feature that helps // for debug the I2Cx module. It internally connects the I2C master and // slave terminals, which effectively lets you send data as a master and // receive data as a slave. NOTE: For external I2C operation you will need // to use external pull-ups that are faster than the internal pull-ups. // Refer to the datasheet for more information. // HWREG(I2C0_BASE + I2C_O_MCR) |= 0x01; // // Enable the I2C0 interrupt on the processor (NVIC). // IntEnable(INT_I2C0); // // Configure and turn on the I2C0 slave interrupt. The I2CSlaveIntEnableEx() // gives you the ability to only enable specific interrupts. For this case // we are only interrupting when the slave device receives data. // I2CSlaveIntEnableEx(I2C0_BASE, I2C_SLAVE_INT_DATA); // // Enable and initialize the I2C0 master module. Use the system clock for // the I2C0 module. The last parameter sets the I2C data transfer rate. // If false the data rate is set to 100kbps and if true the data rate will // be set to 400kbps. For this example we will use a data rate of 100kbps. // I2CMasterInitExpClk(I2C0_BASE, SysCtlClockGet(), false); // // Enable the I2C0 slave module. // I2CSlaveEnable(I2C0_BASE); // // Set the slave address to SLAVE_ADDRESS. In loopback mode, it's an // arbitrary 7-bit number (set in a macro above) that is sent to the // I2CMasterSlaveAddrSet function. // I2CSlaveInit(I2C0_BASE, SLAVE_ADDRESS); // // Tell the master module what address it will place on the bus when // communicating with the slave. Set the address to SLAVE_ADDRESS // (as set in the slave module). The receive parameter is set to false // which indicates the I2C Master is initiating a writes to the slave. If // true, that would indicate that the I2C Master is initiating reads from // the slave. // I2CMasterSlaveAddrSet(I2C0_BASE, SLAVE_ADDRESS, false); // // Set up the serial console to use for displaying messages. This is just // for this example program and is not needed for proper I2C operation. // InitConsole(); // // Enable interrupts to the processor. // IntMasterEnable(); // // Display the example setup on the console. // UARTprintf("I2C Slave Interrupt Example ->"); UARTprintf("\n Module = I2C0"); UARTprintf("\n Mode = Receive interrupt on the Slave module"); UARTprintf("\n Rate = 100kbps\n\n"); // // Initialize the data to send. // ui32DataTx = 'I'; // // Indicate the direction of the data. // UARTprintf("Transferring from: Master -> Slave\n"); // // Display the data that I2C0 is transferring. // UARTprintf(" Sending: '%c'", ui32DataTx); // // Place the data to be sent in the data register. // I2CMasterDataPut(I2C0_BASE, ui32DataTx); // // Initiate send of single piece of data from the master. Since the // loopback mode is enabled, the Master and Slave units are connected // allowing us to receive the same data that we sent out. // I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_SINGLE_SEND); // // Wait for interrupt to occur. // while(!g_bIntFlag) { } // // Display that interrupt was received. // UARTprintf("\n Slave Interrupt Received!\n"); // // Display the data that the slave has received. // UARTprintf(" Received: '%c'\n\n", g_ui32DataRx); // // Loop forever. // while(1) { } }
void prvSetupHardware( void ){ tBoolean found; long lEEPROMRetStatus; unsigned short data,data2; unsigned long uart_speed; /* If running on Rev A2 silicon, turn the LDO voltage up to 2.75V. This is a workaround to allow the PLL to operate reliably. */ if( DEVICE_IS_REVA2 ) { SysCtlLDOSet( SYSCTL_LDO_2_75V ); } /* Set the clocking to run from the PLL at 50 MHz */ SysCtlClockSet( SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ ); /* Enable Port F for Ethernet LEDs LED0 Bit 3 Output LED1 Bit 2 Output */ SysCtlPeripheralEnable( SYSCTL_PERIPH_GPIOF ); GPIODirModeSet( GPIO_PORTF_BASE, (GPIO_PIN_2 | GPIO_PIN_3), GPIO_DIR_MODE_HW ); GPIOPadConfigSet( GPIO_PORTF_BASE, (GPIO_PIN_2 | GPIO_PIN_3 ), GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD ); // // Enable the GPIO pin for the LED (PF0). Set the direction as output, and // enable the GPIO pin for digital function. // GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_0); // // Enable processor interrupts. // IntMasterEnable(); if(SoftEEPROMInit(0x1F000, 0x20000, 0x800) != 0) { LWIPDebug("SoftEEPROM initialisation failed."); } lEEPROMRetStatus = SoftEEPROMRead(UART0_SPEED_HIGH_ID, &data, &found); if(lEEPROMRetStatus == 0 && found) { SoftEEPROMRead(UART0_SPEED_LOW_ID, &data2, &found); uart_speed = (data << 16 & 0xFFFF0000) | (data2 & 0x0000FFFF); SoftEEPROMRead(UART0_CONFIG_ID, &data, &found); } else { uart_speed=115200; data = (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE); } uart_init(0, uart_speed, data); SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0); IntPriorityGroupingSet(4); IntPrioritySet(INT_WATCHDOG,SET_SYSCALL_INTERRUPT_PRIORITY(5)); IntEnable(INT_WATCHDOG); // Enable the watchdog interrupt. WatchdogReloadSet(WATCHDOG0_BASE, SysCtlClockGet()); WatchdogResetEnable(WATCHDOG0_BASE); WatchdogEnable(WATCHDOG0_BASE); rtc_init(); modules_init(); }
//***************************************************************************** // //! Add bytes to the ring buffer by advancing the write index. //! //! \param ptRingBuf points to the ring buffer to which bytes have been added. //! \param ulNumBytes is the number of bytes added to the buffer. //! //! This function should be used by clients who wish to add data to the buffer //! directly rather than via calls to RingBufWrite() or RingBufWriteOne(). It //! advances the write index by a given number of bytes. If the \e ulNumBytes //! parameter is larger than the amount of free space in the buffer, the //! read pointer will be advanced to cater for the addition. Note that this //! will result in some of the oldest data in the buffer being discarded. //! //! \return None. // //***************************************************************************** void RingBufAdvanceWrite(tRingBufObject *ptRingBuf, unsigned long ulNumBytes) { unsigned long ulCount; tBoolean bIntsOff; // // Check the arguments. // ASSERT(ptRingBuf != NULL); // // Make sure we were not asked to add a silly number of bytes. // ASSERT(ulNumBytes <= ptRingBuf->ulSize); // // Determine how much free space we currently think the buffer has. // ulCount = RingBufFree(ptRingBuf); // // Advance the buffer write index by the required number of bytes and // check that we have not run past the read index. Note that we must do // this within a critical section (interrupts disabled) to prevent // race conditions that could corrupt one or other of the indices. // bIntsOff = IntMasterDisable(); // // Update the write pointer. // ptRingBuf->ulWriteIndex += ulNumBytes; // // Check and correct for wrap. // if(ptRingBuf->ulWriteIndex >= ptRingBuf->ulSize) { ptRingBuf->ulWriteIndex -= ptRingBuf->ulSize; } // // Did the client add more bytes than the buffer had free space for? // if(ulCount < ulNumBytes) { // // Yes - we need to advance the read pointer to ahead of the write // pointer to discard some of the oldest data. // ptRingBuf->ulReadIndex = ptRingBuf->ulWriteIndex + 1; // // Correct for buffer wrap if necessary. // if(ptRingBuf->ulReadIndex >= ptRingBuf->ulSize) { ptRingBuf->ulReadIndex -= ptRingBuf->ulSize; } } // // Restore interrupts if we turned them off earlier. // if(!bIntsOff) { IntMasterEnable(); } }
int main(void) { // setup the system clock to run at 80 MHz from the external crystal: ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // enable peripherals to operate when CPU is in sleep: ROM_SysCtlPeripheralClockGating(true); // enable all of the GPIOs: ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOB); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOE); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOF); // setup pins connected to RGB LED: ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3); //setup the UART console InitConsole(); // Test either the interrupts on a simple pushbutton to turn-on a led: // 1- interrupt with static allocation on the vector table // 2- interrupt with dynamic allocation on the vector table // 2- interrupt with dynamic allocation on the vector table // setup pin connected to SW1 and SW2 // 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_AFSEL) |= 0x000; HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0; //Configures pin(s) for use as GPIO inputs ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE,GPIO_PIN_4 | GPIO_PIN_0); //Sets the pad configuration for the specified pin(s). ROM_GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_4 | GPIO_PIN_0,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); // Make PORT F pin 0,4 high level triggered interrupts. ROM_GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_4 | GPIO_PIN_0,GPIO_BOTH_EDGES); //dynamic allocation on the vector table of GPIO_PORTF_isr interrupt handler GPIOIntRegister(GPIO_PORTF_BASE, GPIO_PORTF_isr); //Enables the specified GPIO interrupt IntEnable(INT_GPIOF); GPIOIntEnable(GPIO_PORTF_BASE,GPIO_INT_PIN_4 | GPIO_INT_PIN_0); IntMasterEnable(); uint8_t PORTF_status; //uint32_t ui32Loop = 0; // // Loop forever // while(1) { uint8_t PORTF_status=GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0 | GPIO_PIN_4); /* if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)) { ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 ,0); } else { ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 , GPIO_PIN_1); } */ /* // // Turn on the red LED . // ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 , GPIO_PIN_1); ROM_GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_7, GPIO_PIN_7); // // Delay for a bit. // for(ui32Loop = 0; ui32Loop < 2000000; ui32Loop++) { } // // Turn on the green LED. // ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 , GPIO_PIN_2); ROM_GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_7, 0); // // Delay for a bit. // for(ui32Loop = 0; ui32Loop < 2000000; ui32Loop++) { } // // Turn on the blue LED. // ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 , GPIO_PIN_3); // // Delay for a bit. // for(ui32Loop = 0; ui32Loop < 2000000; ui32Loop++) { } */ } }
//***************************************************************************** // // This is the main loop for the application. // //***************************************************************************** int main(void) { // // If running on Rev A2 silicon, turn the LDO voltage up to 2.75V. This is // a workaround to allow the PLL to operate reliably. // if(REVISION_IS_A2) { SysCtlLDOSet(SYSCTL_LDO_2_75V); } // // Set the clocking to run directly from the PLL at 50MHz. // SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Configure CAN 0 Pins. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); GPIOPinTypeCAN(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Configure LED pin. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // // Configure GPIO Pin used for the LED. // GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); // // Turn off the LED. // GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0); // // Enable the CAN controller. // SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0); // // Reset the state of all the message object and the state of the CAN // module to a known state. // CANInit(CAN0_BASE); // // Configure the bit rate for the CAN device, the clock rate to the CAN // controller is fixed at 8MHz for this class of device and the bit rate is // set to CAN_BITRATE. // CANBitRateSet(CAN0_BASE, 8000000, CAN_BITRATE); // // Take the CAN0 device out of INIT state. // CANEnable(CAN0_BASE); // // Enable interrupts from CAN controller. // CANIntEnable(CAN0_BASE, CAN_INT_MASTER | CAN_INT_ERROR); // // Enable interrupts for the CAN in the NVIC. // IntEnable(INT_CAN0); // // Enable processor interrupts. // IntMasterEnable(); // // Set the initial state to wait for data. // g_sCAN.eState = CAN_WAIT_RX; // // Reset the buffer pointer. // g_sCAN.MsgObjectRx.pucMsgData = g_sCAN.pucBuffer; // // Set the total number of bytes expected. // g_sCAN.ulBytesRemaining = CAN_FIFO_SIZE; // // Configure the receive message FIFO. // CANReceiveFIFO(g_sCAN.pucBuffer, CAN_FIFO_SIZE); // // Initialized the LED toggle count. // g_ulLEDCount = 0; // // Loop forever. // while(1) { switch(g_sCAN.eState) { case CAN_IDLE: { // // Switch to sending state. // g_sCAN.eState = CAN_SENDING; // // Initialize the transmit count to zero. // g_sCAN.ulBytesTransmitted = 0; // // Schedule all of the CAN transmissions. // CANTransmitFIFO(g_sCAN.pucBuffer, CAN_FIFO_SIZE); break; } case CAN_SENDING: { // // Wait for all bytes to go out. // if(g_sCAN.ulBytesTransmitted == CAN_FIFO_SIZE) { // // Switch to wait for RX state. // g_sCAN.eState = CAN_WAIT_RX; } break; } case CAN_WAIT_RX: { // // Wait for all new data to be received. // if(g_sCAN.ulBytesRemaining == 0) { // // Switch to wait for Process data state. // g_sCAN.eState = CAN_PROCESS; // // Reset the buffer pointer. // g_sCAN.MsgObjectRx.pucMsgData = g_sCAN.pucBuffer; // // Reset the number of bytes expected. // g_sCAN.ulBytesRemaining = CAN_FIFO_SIZE; } break; } case CAN_PROCESS: { // // Handle the LED toggle. // ToggleLED(); // // Return to the idle state. // g_sCAN.eState = CAN_IDLE; break; } default: { break; } } } }
int main(void) { volatile uint32_t ui32Load; volatile uint32_t ui32PWMClock; volatile uint8_t ui8AdjustRed, ui8AdjustGreen, ui8AdjustBlue; ui8AdjustRed = 254; ui8AdjustGreen = 2; ui8AdjustBlue = 2; // Set the system clock to 40 MHz SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ); // Set the PWM Clock to 1/64 of the system clock i.e. 625 kHz SysCtlPWMClockSet(SYSCTL_PWMDIV_64); // Timer related intializations, time period is 10 ms. SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); uint32_t ui32Period; ui32Period = (SysCtlClockGet()/100)/ 2; TimerLoadSet(TIMER0_BASE, TIMER_A, ui32Period -1); IntEnable(INT_TIMER0A); TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); IntMasterEnable(); TimerEnable(TIMER0_BASE, TIMER_A); // Enable the PWM module 1 SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1); // Enable the GPIO Port F SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // PWM related initializations GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); GPIOPinConfigure(GPIO_PF1_M1PWM5); GPIOPinConfigure(GPIO_PF2_M1PWM6); GPIOPinConfigure(GPIO_PF3_M1PWM7); 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; GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0, GPIO_DIR_MODE_IN); GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); ui32PWMClock = SysCtlClockGet() / 64; ui32Load = (ui32PWMClock / PWM_FREQUENCY) - 1; PWMGenConfigure(PWM1_BASE, PWM_GEN_2, PWM_GEN_MODE_DOWN); PWMGenConfigure(PWM1_BASE, PWM_GEN_3, PWM_GEN_MODE_DOWN); PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, ui32Load); PWMGenPeriodSet(PWM1_BASE, PWM_GEN_3, ui32Load); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8AdjustRed * ui32Load / 1000); PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT, true); PWMGenEnable(PWM1_BASE, PWM_GEN_2); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8AdjustBlue * ui32Load / 1000); PWMOutputState(PWM1_BASE, PWM_OUT_6_BIT, true); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8AdjustGreen * ui32Load / 1000); PWMOutputState(PWM1_BASE, PWM_OUT_7_BIT, true); PWMGenEnable(PWM1_BASE, PWM_GEN_3); // Detecting the phase while in the auto mode, RG, GB or BR. int autoLedState = 0; while(1) { if(mode==0) { if(autoLedState==0) { ui8AdjustRed--; ui8AdjustGreen++; if(ui8AdjustRed==2 && ui8AdjustGreen==254) autoLedState = 1; } else if(autoLedState==1) { ui8AdjustGreen--; ui8AdjustBlue++; if(ui8AdjustGreen==2 && ui8AdjustBlue==254) autoLedState = 2; } else if(autoLedState==2) { ui8AdjustBlue--; ui8AdjustRed++; if(ui8AdjustBlue==2 && ui8AdjustRed==254) autoLedState = 0; } PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8AdjustRed * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8AdjustBlue * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8AdjustGreen * ui32Load / 1000); SysCtlDelay(delay); } else { if(mode==1) { ui8AdjustBlue = 2; ui8AdjustGreen = 2; if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00) { ui8AdjustRed--; if (ui8AdjustRed < 20) ui8AdjustRed = 20; } if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00) { ui8AdjustRed++; if (ui8AdjustRed > 254) ui8AdjustRed = 254; } } else if(mode==2) { ui8AdjustRed = 2; ui8AdjustGreen = 2; if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00) { ui8AdjustBlue--; if (ui8AdjustBlue < 20) ui8AdjustBlue = 20; } if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00) { ui8AdjustBlue++; if (ui8AdjustBlue > 254) ui8AdjustBlue = 254; } } else if(mode==3) { ui8AdjustBlue = 2; ui8AdjustRed = 2; if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00) { ui8AdjustGreen--; if (ui8AdjustGreen < 20) ui8AdjustGreen = 20; } if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00) { ui8AdjustGreen++; if (ui8AdjustGreen > 254) ui8AdjustGreen = 254; } } PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8AdjustRed * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8AdjustBlue * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8AdjustGreen * ui32Load / 1000); SysCtlDelay(100000); } } }
main() { uint8 option=0; uint8 key; SysCtlClockSet(SYSCTL_SYSDIV_4| SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_6MHZ); Uart0Init(19200); Uart1Init(9600); Uart2Init(19200); IntMasterEnable(); SysLinearTimer =0; IoPortInit(); //IO口初始化 I2C1Init() ;//Fm31256 TimerInit(); xs6963_init(); PIN_TDA7367stand_Write(ETDA7367work_no); FlashUsecSet(49); //T1Init_LM331(); DPRINTF(("Bat=%d ,cha=%d ,Temp=%d \n",1,2,3)); Usb_Host_Init(); mainHandleinit(); signPWM_init(50.0); PWM_sign_stop(); /*LCD初始化*/ start_mune(); /* fm31256 eeprom 8 */ readbyte_much(setsto_addr,settype_nub,set.byte ); /*修正系数*/ modify_read(); /**/ Oiltempset.oilTwork=EOiltemp_Workon; /*lm331初始化 温度测量使用*/ T1Init_LM331(); /*系统节拍*/ SysLinearTimer=0; while(SysLinearTimer<3*TIMER_FREQ)//后台参数设置 { key=Keyset.keyEfficiency; if(key==key_modify) { while(Keyset.keyEfficiency==key_modify); option++; if(option>=4) { modify_read();//读取修正参数 TgC_read(); modify();//修正 } } } modifyK_js(); SysLinearTimer=0; rx_flag=0; option=0; mainset_go: key=Keyset.keyEfficiency; mainset_mune(); Reversepic(mainset_lin+option*mainset_high, mainset_column, mainset_high, 2*4); while(1) { while(key==Keyset.keyEfficiency) { if(SysLinearTimer>(3*TIMER_FREQ/4)) { // Temp_account(); if(TRUE_z==Gandispose())//地线检测 { mainset_mune(); Reversepic(mainset_lin+option*mainset_high, mainset_column, mainset_high, 2*4); } read_time(); { uint8 byte[12]; Clock_viewxs(byte) ; } SysLinearTimer=0; } } key=Keyset.keyEfficiency; /*按键处理*/ switch(key) { case key_no: case key_back: continue; case key_down: case key_up: Reversepic(mainset_lin+option*mainset_high, mainset_column, mainset_high, 2*4); option=keyoption_js(option, key,4,Emune_key);// Reversepic(mainset_lin+option*mainset_high, mainset_column, mainset_high, 2*4); /* if(key==key_up) { PWM_sign_acc(0.0, 0.0); delay(0x80000); PIN_DCAC_pwm(EDC_power); PWM_sign_acc(0.0, 0.7); } else { PWM_sign_acc(0.0, 0.0); delay(0x80000); PIN_DCAC_pwm(EAC_power); PWM_sign_acc(50.0, 0.8); } */ break; case key_ok: switch(option) { case ELan_main://语言 set.mune.Langue++; set.mune.Langue&=0x01; //ShowtextLine(mainset_lin+option*mainset_high, mainset_column+0x10,Lanset_p[set.mune.Langue]); break; case EOilset_main://油样设置 oidset(); break; case EView_main://历史数据 Viewdata_Hander(); break; case EClock_main://时钟设置 clockset_mune(); break; } goto mainset_go ; case key_oil: Oilclear();//排油 break; } } }
//***************************************************************************** // // Configure the SysTick and SysTick interrupt with a period of 1 second. // //***************************************************************************** int main(void) { unsigned long ulPrevCount = 0; // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for Systick operation. // InitConsole(); // // Display the setup on the console. // UARTprintf("SysTick Firing Interrupt ->"); UARTprintf("\n Rate = 1sec\n\n"); // // Initialize the interrupt counter. // g_ulCounter = 0; // // Set up the period for the SysTick timer. The SysTick timer period will // be equal to the system clock, resulting in a period of 1 second. // SysTickPeriodSet(SysCtlClockGet()); // // Enable interrupts to the processor. // IntMasterEnable(); // // Enable the SysTick Interrupt. // SysTickIntEnable(); // // Enable SysTick. // SysTickEnable(); // // Loop forever while the SysTick runs. // while(1) { // // Check to see if systick interrupt count changed, and if so then // print a message with the count. // if(ulPrevCount != g_ulCounter) { // // Print the interrupt counter. // UARTprintf("Number of interrupts: %d\r", g_ulCounter); ulPrevCount = g_ulCounter; } } }
/////////////////////////////////////////////////////////////////////////////// //////////////////////////////// MAIN /////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// int main(void) { IntMasterDisable(); //=====SYSTEM PERIPHERAL INITIALIZATION===== // Initialize real time clock mRTCInit(RTC_RATE_HZ); // Millisecond timekeeping variable int time; //Add periodic tasks to be executed by systick mRTCAddTask(heightSample, HEIGHT_SAMPLE_RATE_HZ); // Set up display mDisplayInit(1000000); mDisplayLine(" Waiting... ", 0, 5, 15); // Set up buttons ButtonInit(); // Set up PWM mPWMInit(); mPWMEnable(PWM4, false); // tail rotor, yaw control. mPWMEnable(PWM1, false); // main rotor, height control. //=========CONTROL INITIALIZATION======== //-----altitude PID control------ // Initialize altitude module heightInit(); // =========PID parameters======================== //Phils float H_kp = 1;float H_ki = 1.5;float H_kd = -0.5; short heightPIDOffset = 40; float Y_kp = 0.6;float Y_ki = 0;float Y_kd = 0; short YawPIDOffset = 0;//50; // Windup regulator float H_windup_limit = 10; if (H_ki) H_windup_limit /= H_ki; // height PID controller pid_t heightPID; PIDInit(&heightPID); PIDSet(&heightPID, H_kp, H_ki, H_kd, H_windup_limit); // set PID constants // height PID control variables //35; // PID out offset such that the rotor is at near-takoff speed short height = 0; short heightSetpoint = 0; // in degrees short heightError = 0; short heightPIDOut = 0; //-----yaw PID control------- // Initialise Yaw decoder module yawInit(); // yaw monitor float Y_windup_limit = 20; // Maximum integral contribution to PID output value if (Y_ki) Y_windup_limit /= Y_ki; // devide by Y_ki to find maximum value in terms of error // Yaw PID controller pid_t yawPID; PIDInit(&yawPID); PIDSet(&yawPID, Y_kp, Y_ki, Y_kd, Y_windup_limit); // set PID constants // yaw PID control variables short yaw = 0; short yawSetpoint = 0; short yawError = 0; short yawPIDOut = 0; // // Enable interrupts to the processor. IntMasterEnable(); short takeOffFlag = false; while (!takeOffFlag) { if (ButtonCheck(SELECT)) //if (GPIOPinRead(GPIO_PORTG_BASE, 0x80)) { takeOffFlag = true; } } // Reset setpoints to current position heightSetpoint = heightGet(); yawSetpoint = yawGetAngle(); mPWMEnable(PWM4, true); // tail rotor, yaw control. mPWMEnable(PWM1, true); // main rotor, height control. //spin up routine //spinUp(heightPIDOffset, yawPID); // Reset clock to zero for effective helicopter launch time mRTCSet(0); while (1) { //mDisplayClear(); time = mRTCGetMilliSeconds(); // Update Setpoints updateSetpoints(&yawSetpoint, &heightSetpoint); // ==================PID Control================= if ((time % (RTC_RATE_HZ/PID_RATE_HZ)) /*1000/(float)PID_RATE_HZ*/ == 0) { // // ~~~~~~~~~~~~~~~~~ HEIGHT PID ~~~~~~~~~~~~~~~~ height = heightGet(); heightError = heightSetpoint - height; heightPIDOut = PIDUpdate(&heightPID, heightError, 1.00 / (float)PID_RATE_HZ) + heightPIDOffset; if (heightPIDOut > 79) //heightPIDOut = 79; if (heightPIDOut < 2) heightPIDOut = 2; mPWMSet(PWM1, (unsigned short)heightPIDOut); // // ~~~~~~~~~~~~~~~~~~ YAW PID ~~~~~~~~~~~~~~~~~~~ yaw = yawGetAngle(); yawError = yaw - yawSetpoint; yawPIDOut = PIDUpdate(&yawPID, yawError, 1.00 / (float)PID_RATE_HZ) + YawPIDOffset; if (yawPIDOut > 79) yawPIDOut = 79; if (yawPIDOut < 2) yawPIDOut = 2; mPWMSet(PWM4, (unsigned short)yawPIDOut); // =============================================== } // RTC_RATE_HZ - PID_RATE_HZ if (( (time) % 10) == 0) { mDisplayLine("time:%.6d mS", time, 0, 7); mDisplayLine("Yaw = %.4d' ", (int)yaw, 1, 15); mDisplayLine("YSet = %.4d' ", (int)yawSetpoint, 2, 15); mDisplayLine("YErr = %.4d' ", (int)yawError, 3, 15); mDisplayLine("YOut = %.4d' ", (int)yawPIDOut, 4, 15); mDisplayLine("height = ~%.3d ", (int)height, 5, 15); mDisplayLine("Hset = %.4d ", (int)heightSetpoint, 6, 15); mDisplayLine("Herr = %.4d ", (int)heightError, 7, 15); mDisplayLine("Hout = %.4d ", (int)heightPIDOut, 8, 15); } // should put this as part of the main while loop condition //if (ButtonCheck(SELECT)) //{ // spinDown(); //} } }
//***************************************************************************** // // This example demonstrates how to send a string of data to the UART. // //***************************************************************************** int main(void) { tRectangle sRect; // // Set the clocking to run directly from the crystal. // ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Initialize the display driver. // Formike128x128x16Init(); // // Turn on the backlight. // Formike128x128x16BacklightOn(); // // Initialize the graphics context. // GrContextInit(&g_sContext, &g_sFormike128x128x16); // // Fill the top 15 rows of the screen with blue to create the banner. // sRect.sXMin = 0; sRect.sYMin = 0; sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1; sRect.sYMax = 14; GrContextForegroundSet(&g_sContext, ClrDarkBlue); GrRectFill(&g_sContext, &sRect); // // Put a white box around the banner. // GrContextForegroundSet(&g_sContext, ClrWhite); GrRectDraw(&g_sContext, &sRect); // // Put the application name in the middle of the banner. // GrContextFontSet(&g_sContext, &g_sFontFixed6x8); GrStringDrawCentered(&g_sContext, "uart_echo", -1, GrContextDpyWidthGet(&g_sContext) / 2, 7, 0); // // Initialize the CSTN display and write status. // GrStringDraw(&g_sContext, "Port: Uart 0", -1, 12, 24, 0); GrStringDraw(&g_sContext, "Baud: 115,200 bps", -1, 12, 32, 0); GrStringDraw(&g_sContext, "Data: 8 Bit", -1, 12, 40, 0); GrStringDraw(&g_sContext, "Parity: None", -1, 12, 48, 0); GrStringDraw(&g_sContext, "Stop: 1 Bit", -1, 12, 56, 0); // // Enable the peripherals used by this example. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Enable processor interrupts. // IntMasterEnable(); // // Set GPIO A0 and A1 as UART pins. // ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Configure the UART for 115,200, 8-N-1 operation. // ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // // Enable the UART interrupt. // ROM_IntEnable(INT_UART0); ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT); // // Prompt for text to be entered. // UARTSend((unsigned char *)"Ingrese un Texto: ", 18); // // Loop forever echoing data through the UART. // while(1) { } }
int main(void) { display[0] = '\0'; display2[0] = '\0'; // Set the clocking to run directly from the crystal. SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // Initialize the OLED display and write status. RIT128x96x4Init(1000000); RIT128x96x4StringDraw("----------------------", 0, 50, 15); // Enable the peripherals used by this example. SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // Status SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0,GPIO_STRENGTH_4MA,GPIO_PIN_TYPE_STD); GPIODirModeSet(GPIO_PORTF_BASE,GPIO_PIN_0,GPIO_DIR_MODE_OUT); //PB1 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); GPIOPadConfigSet(GPIO_PORTB_BASE,GPIO_PIN_1,GPIO_STRENGTH_4MA,GPIO_PIN_TYPE_STD); GPIODirModeSet(GPIO_PORTB_BASE,GPIO_PIN_1,GPIO_DIR_MODE_IN); GPIOPortIntRegister(GPIO_PORTB_BASE, PortBIntHandler); GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_1, GPIO_BOTH_EDGES); GPIOPinIntEnable(GPIO_PORTB_BASE, GPIO_PIN_1); IntPrioritySet(INT_GPIOB,0x80); SysTickIntRegister(SysTickHandler); SysTickPeriodSet(SysCtlClockGet()/10000); // 0.1ms SysTickIntEnable(); waitTime = 0; // initialize waitTime2 = 0; SysTickEnable(); // Enable processor interrupts. IntMasterEnable(); // Set GPIO A0 and A1 as UART pins. GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_2 | GPIO_PIN_3); // Configure the UART for 115,200, 8-N-1 operation. UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 9600, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); UARTConfigSetExpClk(UART1_BASE, SysCtlClockGet(), 9600, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // Enable the UART interrupt. IntEnable(INT_UART0); UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT); IntEnable(INT_UART1); UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT); while(1) { } }
//***************************************************************************** // // The main routine // //***************************************************************************** int main(void) { int TypeID; tTRF79x0TRFMode eCurrentTRF79x0Mode = P2P_PASSIVE_TARGET_MODE; uint32_t x; uint16_t ui16MaxSizeRemaining=0; bool bCheck=STATUS_FAIL; uint8_t pui8Instructions[]="Instructions:\n " "You will need a NFC capable device and a NFC boosterpack for " "this demo\n " "To use this demo put the phone or tablet within 2 inches of " "the NFC boosterpack\n " "Messages sent to the microcontroller will be displayed on " "the terminal and screen\n " "Messages can be sent back to the NFC device via the " "'Echo Tag' button on the pull down menu\n"; // // Run from the PLL at 120 MHz. // g_ui32SysClk = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); // // Select NFC Boosterpack Type // g_eRFDaughterType = RF_DAUGHTER_TRF7970ATB; // // Configure the device pins. // PinoutSet(); // // Initialize the UART for console I/O. // UARTStdioConfig(0, 115200, g_ui32SysClk); // // Initialize the display driver. // Kentec320x240x16_SSD2119Init(g_ui32SysClk); // // Initialize the graphics context. // GrContextInit(&g_sContext, &g_sKentec320x240x16_SSD2119); // // Initialize the Touch Screen Frames and related Animations. // ScreenInit(); // // Draw the application frame. // FrameDraw(&g_sContext, "nfc-p2p-demo"); // // Initialize USER LED to Blue. (May Overlap TriColor LED) // ENABLE_LED_PERIPHERAL; SET_LED_DIRECTION; // // Initialize TriColer LED if it exists. // if(BOARD_HAS_TRICOLOR_LED) { ENABLE_LED_TRICOLOR_RED_PERIPH; SET_LED_TRICOLOR_RED_DIRECTION; ENABLE_LED_TRICOLOR_BLUE_PERIPH; SET_LED_TRICOLOR_BLUE_DIRECTION; ENABLE_LED_TRICOLOR_GREEN_PERIPH; SET_LED_TRICOLOR_GREEN_DIRECTION; } // // Initialize the TRF79x0 and SSI. // TRF79x0Init(); // // Initialize Timer0A. // Timer0AInit(); // // Enable First Mode. // NFCP2P_init(eCurrentTRF79x0Mode,FREQ_212_KBPS); // // Enable Interrupts. // IntMasterEnable(); // // Print a prompt to the console. // UARTprintf("\n****************************\n"); UARTprintf("* NFC P2P Demo *\n"); UARTprintf("****************************\n"); // // Print instructions to the console / screen. // UARTprintf((char *)pui8Instructions); ScreenPayloadWrite(pui8Instructions,sizeof(pui8Instructions),1); while(1) { // // Update Screen. // ScreenPeriodic(); // // NFC-P2P-Initiator-Statemachine. // if(NFCP2P_proccessStateMachine() == NFC_P2P_PROTOCOL_ACTIVATION) { if(eCurrentTRF79x0Mode == P2P_INITATIOR_MODE) { eCurrentTRF79x0Mode = P2P_PASSIVE_TARGET_MODE; //Toggle LED's if(BOARD_HAS_TRICOLOR_LED) { TURN_OFF_LED_TRICOLOR_GREEN TURN_OFF_LED_TRICOLOR_RED; TURN_ON_LED_TRICOLOR_BLUE } } else if(eCurrentTRF79x0Mode == P2P_PASSIVE_TARGET_MODE) { eCurrentTRF79x0Mode = P2P_INITATIOR_MODE; // // Toggle LED's. // if(BOARD_HAS_TRICOLOR_LED) { TURN_OFF_LED_TRICOLOR_BLUE TURN_ON_LED_TRICOLOR_RED TURN_ON_LED_TRICOLOR_GREEN } }
int main(void) { #ifdef PART_LM4F120H5QR // ARM code SysCtlClockSet( SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN ); //set system clock to 80 MHz FPUEnable(); //enable the Floating Point Unit // FPULazyStackingEnable(); // Enable stacking for interrupt handlers #endif // Initialize system serial_init(); // Setup serial baud rate and interrupts settings_init(); // Load grbl settings from EEPROM st_init(); // Setup stepper pins and interrupt timers #ifdef PART_LM4F120H5QR // ARM code IntMasterEnable(); #else // AVR code sei(); // Enable interrupts #endif memset(&sys, 0, sizeof(sys)); // Clear all system variables sys.abort = true; // Set abort to complete initialization sys.state = STATE_INIT; // Set alarm state to indicate unknown initial position for(;;) { // Execute system reset upon a system abort, where the main program will return to this loop. // Once here, it is safe to re-initialize the system. At startup, the system will automatically // reset to finish the initialization process. if (sys.abort) { // Reset system. serial_reset_read_buffer(); // Clear serial read buffer plan_init(); // Clear block buffer and planner variables gc_init(); // Set g-code parser to default state protocol_init(); // Clear incoming line data and execute startup lines spindle_init(); coolant_init(); limits_init(); st_reset(); // Clear stepper subsystem variables. // Sync cleared gcode and planner positions to current system position, which is only // cleared upon startup, not a reset/abort. sys_sync_current_position(); // Reset system variables. sys.abort = false; sys.execute = 0; if (bit_istrue(settings.flags,BITFLAG_AUTO_START)) { sys.auto_start = true; } // Check for power-up and set system alarm if homing is enabled to force homing cycle // by setting Grbl's alarm state. Alarm locks out all g-code commands, including the // startup scripts, but allows access to settings and internal commands. Only a homing // cycle '$H' or kill alarm locks '$X' will disable the alarm. // NOTE: The startup script will run after successful completion of the homing cycle, but // not after disabling the alarm locks. Prevents motion startup blocks from crashing into // things uncontrollably. Very bad. #ifdef HOMING_INIT_LOCK if (sys.state == STATE_INIT && bit_istrue(settings.flags,BITFLAG_HOMING_ENABLE)) { sys.state = STATE_ALARM; } #endif // Check for and report alarm state after a reset, error, or an initial power up. if (sys.state == STATE_ALARM) { report_feedback_message(MESSAGE_ALARM_LOCK); } else { // All systems go. Set system to ready and execute startup script. sys.state = STATE_IDLE; protocol_execute_startup(); } } protocol_execute_runtime(); protocol_process(); // ... process the serial protocol // When the serial protocol returns, there are no more characters in the serial read buffer to // be processed and executed. This indicates that individual commands are being issued or // streaming is finished. In either case, auto-cycle start, if enabled, any queued moves. if (sys.auto_start) { st_cycle_start(); } } // return 0; /* never reached */ }
//***************************************************************************** // // Main function performs init and manages system. // // Called automatically after the system and compiler pre-init sequences. // Performs system init calls, restores state from hibernate if needed and // then manages the application context duties of the system. // //***************************************************************************** int main(void) { uint32_t ui32Status; uint32_t ui32ResetCause; int32_t i32CommandStatus; // // Enable stacking for interrupt handlers. This allows floating-point // instructions to be used within interrupt handlers, but at the expense of // extra stack usage. // ROM_FPUEnable(); ROM_FPUStackingEnable(); // // 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); // // Enable the hibernate module // SysCtlPeripheralEnable(SYSCTL_PERIPH_HIBERNATE); // // Enable and Initialize the UART. // ConfigureUART(); UARTprintf("Welcome to the Tiva C Series TM4C123G LaunchPad!\n"); UARTprintf("Type 'help' for a list of commands\n"); UARTprintf("> "); // // Determine why system reset occurred and respond accordingly. // ui32ResetCause = SysCtlResetCauseGet(); SysCtlResetCauseClear(ui32ResetCause); if(ui32ResetCause == SYSCTL_CAUSE_POR) { if(HibernateIsActive()) { // // Read the status bits to see what caused the wake. // ui32Status = HibernateIntStatus(0); HibernateIntClear(ui32Status); // // Wake was due to the push button. // if(ui32Status & HIBERNATE_INT_PIN_WAKE) { UARTprintf("Hibernate Wake Pin Wake Event\n"); UARTprintf("> "); // // Recover the application state variables from battery backed // hibernate memory. Set ui32Mode to normal. // HibernateDataGet((uint32_t*) &g_sAppState, sizeof(tAppState) / 4 + 1); g_sAppState.ui32Mode = APP_MODE_NORMAL; } // // Wake was due to RTC match // else if(ui32Status & HIBERNATE_INT_RTC_MATCH_0) { UARTprintf("Hibernate RTC Wake Event\n"); UARTprintf("> "); // // Recover the application state variables from battery backed // hibernate memory. Set ui32Mode to briefly flash the RGB. // HibernateDataGet((uint32_t*) &g_sAppState, sizeof(tAppState) / 4 + 1); g_sAppState.ui32Mode = APP_MODE_HIB_FLASH; } } else { // // Reset was do to a cold first time power up. // UARTprintf("Power on reset. Hibernate not active.\n"); UARTprintf("> "); g_sAppState.ui32Mode = APP_MODE_NORMAL; g_sAppState.fColorWheelPos = 0; g_sAppState.fIntensity = APP_INTENSITY_DEFAULT; g_sAppState.ui32Buttons = 0; } } else { // // External Pin reset or other reset event occured. // UARTprintf("External or other reset\n"); UARTprintf("> "); // // Treat this as a cold power up reset without restore from hibernate. // g_sAppState.ui32Mode = APP_MODE_NORMAL; g_sAppState.fColorWheelPos = APP_PI; g_sAppState.fIntensity = APP_INTENSITY_DEFAULT; g_sAppState.ui32Buttons = 0; // // colors get a default initialization later when we call AppRainbow. // } // // Initialize clocking for the Hibernate module // HibernateEnableExpClk(SysCtlClockGet()); // // Initialize the RGB LED. AppRainbow typically only called from interrupt // context. Safe to call here to force initial color update because // interrupts are not yet enabled. // RGBInit(0); RGBIntensitySet(g_sAppState.fIntensity); AppRainbow(1); RGBEnable(); // // Initialize the buttons // ButtonsInit(); // // Initialize the SysTick interrupt to process colors and buttons. // SysTickPeriodSet(SysCtlClockGet() / APP_SYSTICKS_PER_SEC); SysTickEnable(); SysTickIntEnable(); IntMasterEnable(); // // spin forever and wait for carriage returns or state changes. // while(1) { UARTprintf("\n>"); // // Peek to see if a full command is ready for processing // while(UARTPeek('\r') == -1) { // // millisecond delay. A SysCtlSleep() here would also be OK. // SysCtlDelay(SysCtlClockGet() / (1000 / 3)); // // Check for change of mode and enter hibernate if requested. // all other mode changes handled in interrupt context. // if(g_sAppState.ui32Mode == APP_MODE_HIB) { AppHibernateEnter(); } } // // a '\r' was detected get the line of text from the user. // UARTgets(g_cInput,sizeof(g_cInput)); // // Pass the line from the user to the command processor. // It will be parsed and valid commands executed. // i32CommandStatus = CmdLineProcess(g_cInput); // // Handle the case of bad command. // if(i32CommandStatus == CMDLINE_BAD_CMD) { UARTprintf("Bad command!\n"); } // // Handle the case of too many arguments. // else if(i32CommandStatus == CMDLINE_TOO_MANY_ARGS) { UARTprintf("Too many arguments for command processor!\n"); } } }
int main(void) { unsigned int i = 0; // Clock (80MHz) SysCtlClockSet(SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); // GPIO SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0); // UART (Serial) SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200, (UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE | UART_CONFIG_WLEN_8)); UARTEnable(UART0_BASE); UARTFIFODisable(UART0_BASE); /*I2CInit(); // PCA9557 i2c_buff[0] = 0x03; i2c_buff[1] = 0x00; // 0: Output 1: Input I2CWrite(0x18, i2c_buff, 2); // IO Direction i2c_buff[0] = 0x02; i2c_buff[1] = 0x00; I2CWrite(0x18, i2c_buff, 2); // IO Polarity i2c_buff[0] = 0x01; i2c_buff[1] = 0x8F; I2CWrite(0x18, i2c_buff, 2); // Output H/L */ //initLEDs(); //initMotors(); //initEncoders(); initServos(); //initBluetooth(); //invertMotor(0); //invertMotor(1); //invertEncoder(0); // Do some tests //setMotor(0, 0.85); //setMotor(1, 0.85); setServoLimits(5, 0.35, 0.85); // Enable Interrupts IntMasterEnable(); while(1) { //for(i=0; i<12; i++) //{ setServo(5, 0.0); toggleRed(); SysCtlDelay(SysCtlClockGet()); // printf("%d\r\n", i*5); setServo(5, 0.6); toggleRed(); SysCtlDelay(SysCtlClockGet()); //} // LED On /* toggleRed(); printf("0:% 6ld 1:% 6ld\r\n", readEnc(0), readEnc(1)); SysCtlDelay(SysCtlClockGet() / 3 / 5); if (i == 10) // 5 Seconds { i2c_buff[0] = 0x01; i2c_buff[1] = 0x0F | 0x00; I2CWrite(0x18, i2c_buff, 2); // Output H/L } i++; */ /*I2CMasterSlaveAddrSet(I2C0_BASE, 0x18, false); // Set Outputs Directions I2CMasterDataPut(I2C0_BASE, 0x01); I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_START); while(I2CMasterBusy(I2C0_BASE)); I2CMasterDataPut(I2C0_BASE, 0x00); I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH); while(I2CMasterBusy(I2C0_BASE)); I2CMasterSlaveAddrSet(I2C0_BASE, 0x18, false); // Set Outputs Directions I2CMasterDataPut(I2C0_BASE, 0x01); I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_START); while(I2CMasterBusy(I2C0_BASE)); I2CMasterDataPut(I2C0_BASE, 0xF0); I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH); while(I2CMasterBusy(I2C0_BASE)); */ //UART1Write("A\r\n", 3); //UARTCharPut(UART1_BASE, 'B'); //UART1WriteChar(UARTCharGet(UART0_BASE)); /* for (i=0; i<8; i++) { unsigned char tmp; i2c_buff[0] = 0x84 | (i << 4); I2CWrite(0x48, i2c_buff, 1); if (I2CMasterErr(I2C0_BASE)) printf("Err: %d\r\n", (unsigned int) I2CMasterErr(I2C0_BASE)); I2CRead(0x48, &tmp, 1); if (I2CMasterErr(I2C0_BASE)) printf("Err: %d\r\n", (unsigned int) I2CMasterErr(I2C0_BASE)); printf("% 3d ", tmp); }*/ /* toggleRed(); for(i=0; i<=100; i++) { setMotor(0, 0.01 * i); setMotor(1, 0.01 * i); setMotor(2, 0.01 * i); setMotor(3, 0.01 * i); printf("%d\r\n", i); SysCtlDelay(SysCtlClockGet() / 3 / 100); } toggleRed(); for(; i>0; i--) { setMotor(0, 0.01 * i); setMotor(1, 0.01 * i); setMotor(2, 0.01 * i); setMotor(3, 0.01 * i); printf("%d\r\n", i); SysCtlDelay(SysCtlClockGet() / 3 / 100); }*/ //printf("%d\r\n", (unsigned int) (((ADCRead(3) >> 4) - 45) * 0.45)); //setServo(0, (((ADCRead(3) >> 4) - 45) * 0.45) / 100.0); /* I2CMasterSlaveAddrSet(I2C0_BASE, 0x18, false); // Set Outputs Directions I2CMasterDataPut(I2C0_BASE, 0x01); I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_START); while(I2CMasterBusy(I2C0_BASE)); if (GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4) == 0) I2CMasterDataPut(I2C0_BASE, 0x80); else I2CMasterDataPut(I2C0_BASE, 0x70); I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH); while(I2CMasterBusy(I2C0_BASE));*/ /*I2CMasterSlaveAddrSet(I2C0_BASE, 0x18, false); I2CMasterDataPut(I2C0_BASE, 0x00); I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_SINGLE_SEND); while(I2CMasterBusy(I2C0_BASE)); I2CMasterSlaveAddrSet(I2C0_BASE, 0x18, true); I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE); while(I2CMasterBusy(I2C0_BASE)); if( (I2CMasterDataGet(I2C0_BASE) & 0x01) != 0) toggleBlue();*/ } }
//***************************************************************************** // // This example demonstrates how to send a string of data to the UART. // //***************************************************************************** int main(void) { // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Initialize the OLED display and write status. // RIT128x96x4Init(1000000); RIT128x96x4StringDraw("UART Echo", 36, 0, 15); RIT128x96x4StringDraw("Port: Uart 0", 12, 16, 15); RIT128x96x4StringDraw("Baud: 115,200 bps", 12, 24, 15); RIT128x96x4StringDraw("Data: 8 Bit", 12, 32, 15); RIT128x96x4StringDraw("Parity: None", 12, 40, 15); RIT128x96x4StringDraw("Stop: 1 Bit", 12, 48, 15); // // Enable the peripherals used by this example. // SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Enable processor interrupts. // IntMasterEnable(); // // Set GPIO A0 and A1 as UART pins. // GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Configure the UART for 115,200, 8-N-1 operation. // UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // // Enable the UART interrupt. // IntEnable(INT_UART0); UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT); // // Prompt for text to be entered. // UARTSend((unsigned char *)"Enter text: ", 12); // // Loop forever echoing data through the UART. // while(1) { } }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(hello_world_process, ev, data) { static struct etimer timer; static int count; PROCESS_BEGIN(); /* i2c_init(I2C_SCL_PORT, I2C_SCL_PIN, I2C_SDA_PORT, I2C_SDA_PIN, I2C_SCL_NORMAL_BUS_SPEED);*/ etimer_set(&timer, CLOCK_CONF_SECOND * 1); count = 0; relay_enable(PORT_D,LED_RELAY_PIN); while(1) { PROCESS_WAIT_EVENT(); if(ev == PROCESS_EVENT_TIMER) { if(count %2 == 0){ //relay_on(PORT_D,LED_RELAY_PIN); int delayIndex; unsigned int pwmDutyCycle = 0x0000; // // Initialize the interrupt counter. // int g_ui32Counter = 0; // // Set the clocking to run directly from the external crystal/oscillator. // (no ext 32k osc, no internal osc) // SysCtrlClockSet(false, false, 32000000); // // Set IO clock to the same as system clock // SysCtrlIOClockSet(32000000); // // The Timer0 peripheral must be enabled for use. // SysCtrlPeripheralEnable(SYS_CTRL_PERIPH_GPT0); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for Timer operation. // //InitConsole(); // // Display the example setup on the console. // UARTprintf("16-Bit Timer PWM ->"); UARTprintf("\n Timer = Timer0B"); UARTprintf("\n Mode = PWM with variable duty cycle"); // // Configure GPTimer0A as a 16-bit PWM Timer. // TimerConfigure(GPTIMER0_BASE, GPTIMER_CFG_SPLIT_PAIR | GPTIMER_CFG_A_PWM | GPTIMER_CFG_B_PWM); // // Set the GPTimer0B load value to 1sec by setting the timer load value // to SYSCLOCK / 255. This is determined by: // Prescaled clock = 16Mhz / 255 // Cycles to wait = 1sec * Prescaled clock TimerLoadSet(GPTIMER0_BASE, GPTIMER_A, SysCtrlClockGet() / 4000); TimerControlLevel(GPTIMER0_BASE, GPTIMER_A, false); // Configure GPIOPortA.0 as the Timer0_InputCapturePin.1 IOCPinConfigPeriphOutput(GPIO_A_BASE, GPIO_PIN_0, IOC_MUX_OUT_SEL_GPT0_ICP1); // Tell timer to use GPIOPortA.0 // Does Direction Selection and PAD Selection GPIOPinTypeTimer(GPIO_A_BASE, GPIO_PIN_0); // // Enable processor interrupts. // IntMasterEnable(); // // Enable GPTimer0B. // TimerEnable(GPTIMER0_BASE, GPTIMER_A); UARTprintf("\n"); // // Loop forever while the Timer0B runs. // while(1) { for (delayIndex = 0; delayIndex < 100000; delayIndex++); pwmDutyCycle += 0x0F; pwmDutyCycle &= 0xFFFF; TimerMatchSet(GPTIMER0_BASE, GPTIMER_A, pwmDutyCycle); UARTprintf("PWM DC Value: %04X -- %04X -- %04X\r", pwmDutyCycle, TimerValueGet(GPTIMER0_BASE, GPTIMER_A), TimerMatchGet(GPTIMER0_BASE, GPTIMER_A) ); } //SENSORS_ACTIVATE(cc2538_temp_sensor); // printf( "%d is temp\n",cc2538_temp_sensor.value); } else { //relay_off(PORT_D,LED_RELAY_PIN); } /* if(count %2 == 0) { relay_toggle(PORT_D,LED_RELAY_PIN); relay_status(PORT_D,LED_RELAY_PIN); } */ count ++; etimer_reset(&timer); } } PROCESS_END(); }
//***************************************************************************** // // This example demonstrates how to send a string of data to the UART. // //***************************************************************************** int main(void) { uint32_t ui32SysClock; tContext sContext; // // Run from the PLL at 120 MHz. // ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); // // Configure the device pins. // PinoutSet(); // // Initialize the display driver. // Kentec320x240x16_SSD2119Init(ui32SysClock); // // Initialize the graphics context. // GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119); // // Draw the application frame. // FrameDraw(&sContext, "uart-echo"); // // Display UART configuration on the display. // GrStringDraw(&sContext, "Port:", -1, 70, 70, 0); GrStringDraw(&sContext, "Baud:", -1, 70, 95, 0); GrStringDraw(&sContext, "Data:", -1, 70, 120, 0); GrStringDraw(&sContext, "Parity:", -1, 70, 145, 0); GrStringDraw(&sContext, "Stop:", -1, 70, 170, 0); GrStringDraw(&sContext, "Uart 0", -1, 150, 70, 0); GrStringDraw(&sContext, "115,200 bps", -1, 150, 95, 0); GrStringDraw(&sContext, "8 Bit", -1, 150, 120, 0); GrStringDraw(&sContext, "None", -1, 150, 145, 0); GrStringDraw(&sContext, "1 Bit", -1, 150, 170, 0); // // Enable the (non-GPIO) peripherals used by this example. PinoutSet() // already enabled GPIO Port A. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // // Enable processor interrupts. // IntMasterEnable(); // // Configure the UART for 115,200, 8-N-1 operation. // ROM_UARTConfigSetExpClk(UART0_BASE, ui32SysClock, 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // // Enable the UART interrupt. // ROM_IntEnable(INT_UART0); ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT); // // Prompt for text to be entered. // UARTSend((uint8_t *)"Enter text: ", 12); // // Loop forever echoing data through the UART. // while(1) { } }
//***************************************************************************** // // This is the main example program. It checks to see that the interrupts are // processed in the correct order when they have identical priorities, // increasing priorities, and decreasing priorities. This exercises interrupt // preemption and tail chaining. // //***************************************************************************** int main(void) { unsigned long ulError; // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_6MHZ); // // Enable the peripherals used by this example. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // // Initialize the OLED display and write status. // Display96x16x1Init(false); Display96x16x1StringDraw("Act: Pend: ", 0, 1); // // Configure the first three pins of GPIO port D to be outputs to indicate // entry/exit of one of the interrupt handlers. // GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2); GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2, 0); // // Set up and enable the SysTick timer. It will be used as a reference // for delay loops in the interrupt handlers. The SysTick timer period // will be set up for one second. // SysTickPeriodSet(SysCtlClockGet()); SysTickEnable(); // // Reset the error indicator. // ulError = 0; // // Enable interrupts to the processor. // IntMasterEnable(); // // Enable the interrupts. // IntEnable(INT_GPIOA); IntEnable(INT_GPIOB); IntEnable(INT_GPIOC); // // Indicate that the equal interrupt priority test is beginning. // Display96x16x1StringDraw("Equal Priority ", 0, 0); // // Set the interrupt priorities so they are all equal. // IntPrioritySet(INT_GPIOA, 0x00); IntPrioritySet(INT_GPIOB, 0x00); IntPrioritySet(INT_GPIOC, 0x00); // // Reset the interrupt flags. // g_ulGPIOa = 0; g_ulGPIOb = 0; g_ulGPIOc = 0; g_ulIndex = 1; // // Trigger the interrupt for GPIO C. // HWREG(NVIC_SW_TRIG) = INT_GPIOC - 16; // // Put the current interrupt state on the LCD. // DisplayIntStatus(); // // Verify that the interrupts were processed in the correct order. // if((g_ulGPIOa != 3) || (g_ulGPIOb != 2) || (g_ulGPIOc != 1)) { ulError |= 1; } // // Wait two seconds. // Delay(2); // // Indicate that the decreasing interrupt priority test is beginning. // Display96x16x1StringDraw("Dec. Priority ", 0, 0); // // Set the interrupt priorities so that they are decreasing (i.e. C > B > // A). // IntPrioritySet(INT_GPIOA, 0x80); IntPrioritySet(INT_GPIOB, 0x40); IntPrioritySet(INT_GPIOC, 0x00); // // Reset the interrupt flags. // g_ulGPIOa = 0; g_ulGPIOb = 0; g_ulGPIOc = 0; g_ulIndex = 1; // // Trigger the interrupt for GPIO C. // HWREG(NVIC_SW_TRIG) = INT_GPIOC - 16; // // Put the current interrupt state on the LCD. // DisplayIntStatus(); // // Verify that the interrupts were processed in the correct order. // if((g_ulGPIOa != 3) || (g_ulGPIOb != 2) || (g_ulGPIOc != 1)) { ulError |= 2; } // // Wait two seconds. // Delay(2); // // Indicate that the increasing interrupt priority test is beginning. // Display96x16x1StringDraw("Inc. Priority ", 0, 0); // // Set the interrupt priorities so that they are increasing (i.e. C < B < // A). // IntPrioritySet(INT_GPIOA, 0x00); IntPrioritySet(INT_GPIOB, 0x40); IntPrioritySet(INT_GPIOC, 0x80); // // Reset the interrupt flags. // g_ulGPIOa = 0; g_ulGPIOb = 0; g_ulGPIOc = 0; g_ulIndex = 1; // // Trigger the interrupt for GPIO C. // HWREG(NVIC_SW_TRIG) = INT_GPIOC - 16; // // Put the current interrupt state on the LCD. // DisplayIntStatus(); // // Verify that the interrupts were processed in the correct order. // if((g_ulGPIOa != 1) || (g_ulGPIOb != 2) || (g_ulGPIOc != 3)) { ulError |= 4; } // // Wait two seconds. // Delay(2); // // Disable the interrupts. // IntDisable(INT_GPIOA); IntDisable(INT_GPIOB); IntDisable(INT_GPIOC); // // Disable interrupts to the processor. // IntMasterDisable(); // // Print out the test results. // Display96x16x1StringDraw("Int Priority ", 0, 0); if(ulError) { Display96x16x1StringDraw("=: P >: P <: P", 0, 1); if(ulError & 1) { Display96x16x1StringDraw("F", 18, 1); } if(ulError & 2) { Display96x16x1StringDraw("F", 54, 1); } if(ulError & 4) { Display96x16x1StringDraw("F", 90, 1); } } else { Display96x16x1StringDraw("Success. ", 0, 1); } // // Finished. // while(1) { } }
void GPS::InterruptEnable(){ // Enable interrupts for GPS-side UART IntMasterEnable(); // master interrupt enable IntEnable(INT_UART1); UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT); // receiver RX and receiver timeout interrupts RT(timeout = 32 bits) }
// void setup(void) runs ONCE when the program just STARTS void setup() { // First SET the SYSTEM CLOCK to 80 [MHz] // Sets the Clock DIVIDER to 2.5, so that SYS_CLOCK runs at 200/2.5 ==> 80 [MHz] SysCtlClockSet( SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); uint32_t Timer0_Period; // Enable & Configure Serial(UART0) to BAUDRATE = 9216000 Serial.begin(BAUDRATE); // Configure PINS for LED OUTPUT pinMode(RED,OUTPUT); pinMode(BLUE,OUTPUT); pinMode(GREEN,OUTPUT); // Set LED OUTPUT pins to OFF initially digitalWrite(RED,LOW); digitalWrite(BLUE,LOW); digitalWrite(GREEN,LOW); state_led=0; // initialize the STATE to STATE0 // Initialize the 'Wire' class for the I2C-bus. Wire.begin(); // Clear the 'sleep' bit to start the sensor. MPU9150_writeSensor(MPU9150_PWR_MGMT_1, 0); int temp0; temp0= MPU9150_readSensor(0x1c); temp0 |= (0x10); temp0 &=~(0x08); MPU9150_writeSensor(0x1c,temp0); MPU9150_writeSensor(0x19,0x0f); MPU9150_setupCompass(); SysCtlPeripheralEnable( SYSCTL_PERIPH_TIMER0); // Enable Timer0 TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); // Set Timer0 mode PERIODIC // Timer0_Period ==> 80e6 * A / B, (1/2)=0.5 Timer0_Period = ( 80000000 * A ) / B; TimerLoadSet( TIMER0_BASE, TIMER_A, Timer0_Period-1); // REGISTER ISR to TIMER0 INTERRUPT TimerIntRegister( TIMER0_BASE, TIMER_A, Timer0_isr ); // Enable Interrupts from Timer0_A IntEnable( INT_TIMER0A); // Set Timer Interrupt Condition and Enable Timer Interrupt TimerIntEnable( TIMER0_BASE, TIMER_TIMA_TIMEOUT); // Enable INTERRUPTS for the SYSTEM IntMasterEnable(); // Start Timer0 TimerEnable(TIMER0_BASE, TIMER_A); }
/* ISR to key-scan, i have been thinking to just raise a flag and then later on check keypad */ void scan_key(void) { /* convention *='e' #='f' */ int i; int key=0; /* switch case is heavily hard-coded to actual pin connection, i need to think how to parametrize * this */ IntMasterDisable(); //disable interrupts //we have 4 rows so check one by one for (i=0;i<4;i++) { GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_0, (i==0)?0:GPIO_PIN_0); GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_1, (i==1)?0:GPIO_PIN_1); GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4, (i==2)?0:GPIO_PIN_4); GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_5, (i==3)?0:GPIO_PIN_5); if ( GPIOPinRead(GPIO_PORTA_BASE,GPIO_PIN_7) == 0) { switch (i) { case 0: key=0x0a;break; case 1: key=0x0b;break; case 2: key=0x0c;break; case 3: key=0x0d;break; default: key=-1; } break; } else if (GPIOPinRead(GPIO_PORTA_BASE,GPIO_PIN_6) == 0) { switch (i) { case 0: key=3;break; case 1: key=6;break; case 2: key=9;break; case 3: key=0x0f;break; default: key=-1; } break; } else if (GPIOPinRead(GPIO_PORTA_BASE,GPIO_PIN_5) == 0) { switch (i) { case 0: key=2;break; case 1: key=5;break; case 2: key=8;break; case 3: key=0;break; default: key=-1; } break; } else if (GPIOPinRead(GPIO_PORTB_BASE,GPIO_PIN_4) == 0) { switch (i) { case 0: key=1;break; case 1: key=4;break; case 2: key=7;break; case 3: key=0x0e;break; default: key=-1; } break; } } //get ready for next interruption GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_0, 0); GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_1, 0); GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4, 0); GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_5, 0); //store the value num = key; GPIOPinIntClear(GPIO_PORTB_BASE,GPIO_PIN_4); GPIOPinIntClear(GPIO_PORTA_BASE,GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7); IntMasterEnable(); }
//***************************************************************************** // // Toggle the JTAG pins between JTAG and GPIO mode with a push button selecting // between the two. // //***************************************************************************** int main(void) { uint32_t ui32Mode; // // Set the clocking to run directly from the crystal at 120MHz. // g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); // // Enable the peripherals used by this application. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION); // // Initialize the button driver. // ButtonsInit(); // // Set up a SysTick Interrupt to handle polling and debouncing for our // buttons. // SysTickPeriodSet(g_ui32SysClock / 100); SysTickIntEnable(); SysTickEnable(); IntMasterEnable(); // // Configure the LEDs as outputs and turn them on in the JTAG state. // ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1); ROM_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1, GPIO_PIN_0); // // Set the global and local indicator of pin mode to zero, meaning JTAG. // g_ui32Mode = 0; ui32Mode = 0; // // Initialize the UART, clear the terminal, print banner. // ConfigureUART(); UARTprintf("\033[2J\033[H"); UARTprintf("GPIO <-> JTAG\n"); // // Indicate that the pins start out as JTAG. // UARTprintf("Pins are JTAG\n"); // // Loop forever. This loop simply exists to display on the UART the // current state of PC0-3; the handling of changing the JTAG pins to and // from GPIO mode is done in GPIO Interrupt Handler. // while(1) { // // Wait until the pin mode changes. // while(g_ui32Mode == ui32Mode) { } // // Save the new mode locally so that a subsequent pin mode change can // be detected. // ui32Mode = g_ui32Mode; // // See what the new pin mode was changed to. // if(ui32Mode == 0) { // // Indicate that PC0-3 are currently JTAG pins. // UARTprintf("Pins are JTAG\n"); } else { // // Indicate that PC0-3 are currently GPIO pins. // UARTprintf("Pins are GPIO\n"); } } }
/* * main.c */ int main(void) { float fTemperature, fHumidity; int32_t i32IntegerPart; int32_t i32FractionPart; g_ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); //confiugre the GPIO pins PinoutSet(false,false); ConfigureUART(); //configure I2C pins SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C8); GPIOPinConfigure(GPIO_PA2_I2C8SCL); GPIOPinConfigure(GPIO_PA3_I2C8SDA); GPIOPinTypeI2C(GPIO_PORTA_BASE,GPIO_PIN_2); GPIOPinTypeI2C(GPIO_PORTA_BASE,GPIO_PIN_3); //enable interrupts IntMasterEnable(); //initialize I2C I2CMInit(&g_sI2CInst,I2C8_BASE,INT_I2C8,0xff,0xff,g_ui32SysClock); IntPrioritySet(INT_I2C7,0xE0); //initialize the sensors SHT21Init(&g_sSHT21Inst, &g_sI2CInst, SHT21_I2C_ADDRESS, SHT21AppCallback,&g_sSHT21Inst); //delay for 20 ms SysCtlDelay(g_ui32SysClock / (50 * 3)); while(1){ // // Turn on D2 to show we are starting a transaction with the sensor. // This is turned off in the application callback. // LEDWrite(CLP_D1 | CLP_D2 , CLP_D2); // // Write the command to start a humidity measurement. // SHT21Write(&g_sSHT21Inst, SHT21_CMD_MEAS_RH, g_sSHT21Inst.pui8Data, 0, SHT21AppCallback, &g_sSHT21Inst); // // Wait for the I2C transactions to complete before moving forward. // SHT21AppI2CWait(__FILE__, __LINE__); // // Wait 33 milliseconds before attempting to get the result. Datasheet // claims this can take as long as 29 milliseconds. // SysCtlDelay(g_ui32SysClock / (30 * 3)); // // Turn on D2 to show we are starting a transaction with the sensor. // This is turned off in the application callback. // LEDWrite(CLP_D1 | CLP_D2 , CLP_D2); // // Get the raw data from the sensor over the I2C bus. // SHT21DataRead(&g_sSHT21Inst, SHT21AppCallback, &g_sSHT21Inst); // // Wait for the I2C transactions to complete before moving forward. // SHT21AppI2CWait(__FILE__, __LINE__); // // Get a copy of the most recent raw data in floating point format. // SHT21DataHumidityGetFloat(&g_sSHT21Inst, &fHumidity); // // Turn on D2 to show we are starting a transaction with the sensor. // This is turned off in the application callback. // LEDWrite(CLP_D1 | CLP_D2 , CLP_D2); // // Write the command to start a temperature measurement. // SHT21Write(&g_sSHT21Inst, SHT21_CMD_MEAS_T, g_sSHT21Inst.pui8Data, 0, SHT21AppCallback, &g_sSHT21Inst); // // Wait for the I2C transactions to complete before moving forward. // SHT21AppI2CWait(__FILE__, __LINE__); // // Wait 100 milliseconds before attempting to get the result. Datasheet // claims this can take as long as 85 milliseconds. // SysCtlDelay(g_ui32SysClock / (10 * 3)); // // Turn on D2 to show we are starting a transaction with the sensor. // This is turned off in the application callback. // LEDWrite(CLP_D1 | CLP_D2 , CLP_D2); // // Read the conversion data from the sensor over I2C. // SHT21DataRead(&g_sSHT21Inst, SHT21AppCallback, &g_sSHT21Inst); // // Wait for the I2C transactions to complete before moving forward. // SHT21AppI2CWait(__FILE__, __LINE__); // // Get the most recent temperature result as a float in celcius. // SHT21DataTemperatureGetFloat(&g_sSHT21Inst, &fTemperature); // // Convert the floats to an integer part and fraction part for easy // print. Humidity is returned as 0.0 to 1.0 so multiply by 100 to get // percent humidity. // fHumidity *= 100.0f; i32IntegerPart = (int32_t) fHumidity; i32FractionPart = (int32_t) (fHumidity * 1000.0f); i32FractionPart = i32FractionPart - (i32IntegerPart * 1000); if(i32FractionPart < 0) { i32FractionPart *= -1; } // // Print the humidity value using the integers we just created. // UARTprintf("Humidity %3d.%03d\t", i32IntegerPart, i32FractionPart); // // Perform the conversion from float to a printable set of integers. // i32IntegerPart = (int32_t) fTemperature; i32FractionPart = (int32_t) (fTemperature * 1000.0f); i32FractionPart = i32FractionPart - (i32IntegerPart * 1000); if(i32FractionPart < 0) { i32FractionPart *= -1; } // // Print the temperature as integer and fraction parts. // UARTprintf("Temperature %3d.%03d\n", i32IntegerPart, i32FractionPart); // // Delay for one second. This is to keep sensor duty cycle // to about 10% as suggested in the datasheet, section 2.4. // This minimizes self heating effects and keeps reading more accurate. // SysCtlDelay(g_ui32SysClock / 3); } return 0; }
//***************************************************************************** // // Main application entry point. // //***************************************************************************** int main(void) { int_fast32_t i32IPart[16], i32FPart[16]; uint_fast32_t ui32Idx, ui32CompDCMStarted; float pfData[16]; float *pfAccel, *pfGyro, *pfMag, *pfEulers, *pfQuaternion; // // Initialize convenience pointers that clean up and clarify the code // meaning. We want all the data in a single contiguous array so that // we can make our pretty printing easier later. // pfAccel = pfData; pfGyro = pfData + 3; pfMag = pfData + 6; pfEulers = pfData + 9; pfQuaternion = pfData + 12; // // Setup the system clock to run at 40 Mhz from PLL with crystal reference // SysCtlClockSet(SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); clock_rate = SysCtlClockGet(); // Note this is bug in TivaWare // Doesn't return correct clock frequency if clock frequency is greater than 50 MHz // // Enable port B used for motion interrupt. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // // Initialize the UART. // ConfigureUART(); uint32_t k; for(k=0;k<1024;++k) { SysCtlDelay( clock_rate/3); UARTprintf("iteration = %4u%c%c",k,0x0d,0x0a); } // // Print the welcome message to the terminal. // UARTprintf("\033[2JMPU9150 Raw Example\n"); // // Set the color to a purple approximation. // g_pui32Colors[RED] = 0x8000; g_pui32Colors[BLUE] = 0x8000; g_pui32Colors[GREEN] = 0x0000; // // Initialize RGB driver. // RGBInit(0); RGBColorSet(g_pui32Colors); RGBIntensitySet(0.5f); RGBEnable(); // // The I2C3 peripheral must be enabled before use. // SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // // Configure the pin muxing for I2C3 functions on port D0 and D1. // GPIOPinConfigure(GPIO_PD0_I2C3SCL); GPIOPinConfigure(GPIO_PD1_I2C3SDA); // // Select the I2C function for these pins. This function will also // configure the GPIO pins pins for I2C operation, setting them to // open-drain operation with weak pull-ups. Consult the data sheet // to see which functions are allocated per pin. // GPIOPinTypeI2CSCL(GPIO_PORTD_BASE, GPIO_PIN_0); GPIOPinTypeI2C(GPIO_PORTD_BASE, GPIO_PIN_1); // // Configure and Enable the GPIO interrupt. Used for INT signal from the // MPU9150 // GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_2); GPIOIntEnable(GPIO_PORTB_BASE, GPIO_PIN_2); GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_2, GPIO_FALLING_EDGE); IntEnable(INT_GPIOB); // // Keep only some parts of the systems running while in sleep mode. // GPIOB is for the MPU9150 interrupt pin. // UART0 is the virtual serial port // TIMER0, TIMER1 and WTIMER5 are used by the RGB driver // I2C3 is the I2C interface to the ISL29023 // SysCtlPeripheralClockGating(true); SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOB); SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UART1); SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_TIMER0); SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_TIMER1); SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_I2C3); SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_WTIMER5); // // Enable interrupts to the processor. // IntMasterEnable(); // // Initialize I2C3 peripheral. // I2CMInit(&g_sI2CInst, I2C3_BASE, INT_I2C3, 0xff, 0xff, SysCtlClockGet()); // // Initialize the MPU9150 Driver. // MPU9150Init(&g_sMPU9150Inst, &g_sI2CInst, MPU9150_I2C_ADDRESS, MPU9150AppCallback, &g_sMPU9150Inst); // // Wait for transaction to complete // MPU9150AppI2CWait(__FILE__, __LINE__); // // Write application specifice sensor configuration such as filter settings // and sensor range settings. // g_sMPU9150Inst.pui8Data[0] = MPU9150_CONFIG_DLPF_CFG_94_98; g_sMPU9150Inst.pui8Data[1] = MPU9150_GYRO_CONFIG_FS_SEL_250; g_sMPU9150Inst.pui8Data[2] = (MPU9150_ACCEL_CONFIG_ACCEL_HPF_5HZ | MPU9150_ACCEL_CONFIG_AFS_SEL_2G); MPU9150Write(&g_sMPU9150Inst, MPU9150_O_CONFIG, g_sMPU9150Inst.pui8Data, 3, MPU9150AppCallback, &g_sMPU9150Inst); // // Wait for transaction to complete // MPU9150AppI2CWait(__FILE__, __LINE__); // // Configure the data ready interrupt pin output of the MPU9150. // g_sMPU9150Inst.pui8Data[0] = MPU9150_INT_PIN_CFG_INT_LEVEL | MPU9150_INT_PIN_CFG_INT_RD_CLEAR | MPU9150_INT_PIN_CFG_LATCH_INT_EN; g_sMPU9150Inst.pui8Data[1] = MPU9150_INT_ENABLE_DATA_RDY_EN; MPU9150Write(&g_sMPU9150Inst, MPU9150_O_INT_PIN_CFG, g_sMPU9150Inst.pui8Data, 2, MPU9150AppCallback, &g_sMPU9150Inst); // // Wait for transaction to complete // MPU9150AppI2CWait(__FILE__, __LINE__); // // Initialize the DCM system. 50 hz sample rate. // accel weight = .2, gyro weight = .8, mag weight = .2 // CompDCMInit(&g_sCompDCMInst, 1.0f / 50.0f, 0.2f, 0.6f, 0.2f); UARTprintf("\033[2J\033[H"); UARTprintf("MPU9150 9-Axis Simple Data Application Example\n\n"); UARTprintf("\033[20GX\033[31G|\033[43GY\033[54G|\033[66GZ\n\n"); UARTprintf("Accel\033[8G|\033[31G|\033[54G|\n\n"); UARTprintf("Gyro\033[8G|\033[31G|\033[54G|\n\n"); UARTprintf("Mag\033[8G|\033[31G|\033[54G|\n\n"); UARTprintf("\n\033[20GRoll\033[31G|\033[43GPitch\033[54G|\033[66GYaw\n\n"); UARTprintf("Eulers\033[8G|\033[31G|\033[54G|\n\n"); UARTprintf("\n\033[17GQ1\033[26G|\033[35GQ2\033[44G|\033[53GQ3\033[62G|" "\033[71GQ4\n\n"); UARTprintf("Q\033[8G|\033[26G|\033[44G|\033[62G|\n\n"); // // Enable blinking indicates config finished successfully // RGBBlinkRateSet(1.0f); ui32CompDCMStarted = 0; while(1) { // // Go to sleep mode while waiting for data ready. // while(!g_vui8I2CDoneFlag) { SysCtlSleep(); } // // Clear the flag // g_vui8I2CDoneFlag = 0; // // Get floating point version of the Accel Data in m/s^2. // MPU9150DataAccelGetFloat(&g_sMPU9150Inst, pfAccel, pfAccel + 1, pfAccel + 2); // // Get floating point version of angular velocities in rad/sec // MPU9150DataGyroGetFloat(&g_sMPU9150Inst, pfGyro, pfGyro + 1, pfGyro + 2); // // Get floating point version of magnetic fields strength in tesla // MPU9150DataMagnetoGetFloat(&g_sMPU9150Inst, pfMag, pfMag + 1, pfMag + 2); // // Check if this is our first data ever. // if(ui32CompDCMStarted == 0) { // // Set flag indicating that DCM is started. // Perform the seeding of the DCM with the first data set. // ui32CompDCMStarted = 1; CompDCMMagnetoUpdate(&g_sCompDCMInst, pfMag[0], pfMag[1], pfMag[2]); CompDCMAccelUpdate(&g_sCompDCMInst, pfAccel[0], pfAccel[1], pfAccel[2]); CompDCMGyroUpdate(&g_sCompDCMInst, pfGyro[0], pfGyro[1], pfGyro[2]); CompDCMStart(&g_sCompDCMInst); } else { // // DCM Is already started. Perform the incremental update. // CompDCMMagnetoUpdate(&g_sCompDCMInst, pfMag[0], pfMag[1], pfMag[2]); CompDCMAccelUpdate(&g_sCompDCMInst, pfAccel[0], pfAccel[1], pfAccel[2]); CompDCMGyroUpdate(&g_sCompDCMInst, -pfGyro[0], -pfGyro[1], -pfGyro[2]); CompDCMUpdate(&g_sCompDCMInst); } // // Increment the skip counter. Skip counter is used so we do not // overflow the UART with data. // g_ui32PrintSkipCounter++; if(g_ui32PrintSkipCounter >= PRINT_SKIP_COUNT) { // // Reset skip counter. // g_ui32PrintSkipCounter = 0; // // Get Euler data. (Roll Pitch Yaw) // CompDCMComputeEulers(&g_sCompDCMInst, pfEulers, pfEulers + 1, pfEulers + 2); // // Get Quaternions. // CompDCMComputeQuaternion(&g_sCompDCMInst, pfQuaternion); // // convert mag data to micro-tesla for better human interpretation. // pfMag[0] *= 1e6; pfMag[1] *= 1e6; pfMag[2] *= 1e6; // // Convert Eulers to degrees. 180/PI = 57.29... // Convert Yaw to 0 to 360 to approximate compass headings. // pfEulers[0] *= 57.295779513082320876798154814105f; pfEulers[1] *= 57.295779513082320876798154814105f; pfEulers[2] *= 57.295779513082320876798154814105f; if(pfEulers[2] < 0) { pfEulers[2] += 360.0f; } // // Now drop back to using the data as a single array for the // purpose of decomposing the float into a integer part and a // fraction (decimal) part. // for(ui32Idx = 0; ui32Idx < 16; ui32Idx++) { // // Conver float value to a integer truncating the decimal part. // i32IPart[ui32Idx] = (int32_t) pfData[ui32Idx]; // // Multiply by 1000 to preserve first three decimal values. // Truncates at the 3rd decimal place. // i32FPart[ui32Idx] = (int32_t) (pfData[ui32Idx] * 1000.0f); // // Subtract off the integer part from this newly formed decimal // part. // i32FPart[ui32Idx] = i32FPart[ui32Idx] - (i32IPart[ui32Idx] * 1000); // // make the decimal part a positive number for display. // if(i32FPart[ui32Idx] < 0) { i32FPart[ui32Idx] *= -1; } } // // Print the acceleration numbers in the table. // UARTprintf("\033[5;17H%3d.%03d", i32IPart[0], i32FPart[0]); UARTprintf("\033[5;40H%3d.%03d", i32IPart[1], i32FPart[1]); UARTprintf("\033[5;63H%3d.%03d", i32IPart[2], i32FPart[2]); // // Print the angular velocities in the table. // UARTprintf("\033[7;17H%3d.%03d", i32IPart[3], i32FPart[3]); UARTprintf("\033[7;40H%3d.%03d", i32IPart[4], i32FPart[4]); UARTprintf("\033[7;63H%3d.%03d", i32IPart[5], i32FPart[5]); // // Print the magnetic data in the table. // UARTprintf("\033[9;17H%3d.%03d", i32IPart[6], i32FPart[6]); UARTprintf("\033[9;40H%3d.%03d", i32IPart[7], i32FPart[7]); UARTprintf("\033[9;63H%3d.%03d", i32IPart[8], i32FPart[8]); // // Print the Eulers in a table. // UARTprintf("\033[14;17H%3d.%03d", i32IPart[9], i32FPart[9]); UARTprintf("\033[14;40H%3d.%03d", i32IPart[10], i32FPart[10]); UARTprintf("\033[14;63H%3d.%03d", i32IPart[11], i32FPart[11]); // // Print the quaternions in a table format. // UARTprintf("\033[19;14H%3d.%03d", i32IPart[12], i32FPart[12]); UARTprintf("\033[19;32H%3d.%03d", i32IPart[13], i32FPart[13]); UARTprintf("\033[19;50H%3d.%03d", i32IPart[14], i32FPart[14]); UARTprintf("\033[19;68H%3d.%03d", i32IPart[15], i32FPart[15]); } } }
//***************************************************************************** // // Configure Timer0B as a 16-bit periodic counter with an interrupt // every 1ms. // //***************************************************************************** int main(void) { #if defined(TARGET_IS_TM4C129_RA0) || \ defined(TARGET_IS_TM4C129_RA1) || \ defined(TARGET_IS_TM4C129_RA2) uint32_t ui32SysClock; #endif uint32_t ui32PrevCount = 0; // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // #if defined(TARGET_IS_TM4C129_RA0) || \ defined(TARGET_IS_TM4C129_RA1) || \ defined(TARGET_IS_TM4C129_RA2) ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_OSC), 25000000); #else SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); #endif // // The Timer0 peripheral must be enabled for use. // SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for Timer operation. // InitConsole(); // // Display the example setup on the console. // UARTprintf("16-Bit Timer Interrupt ->"); UARTprintf("\n Timer = Timer0B"); UARTprintf("\n Mode = Periodic"); UARTprintf("\n Number of interrupts = %d", NUMBER_OF_INTS); UARTprintf("\n Rate = 1ms\n\n"); // // Configure Timer0B as a 16-bit periodic timer. // TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_B_PERIODIC); // // Set the Timer0B load value to 1ms. // #if defined(TARGET_IS_TM4C129_RA0) || \ defined(TARGET_IS_TM4C129_RA1) || \ defined(TARGET_IS_TM4C129_RA2) TimerLoadSet(TIMER0_BASE, TIMER_B, ui32SysClock / 1000); #else TimerLoadSet(TIMER0_BASE, TIMER_B, SysCtlClockGet() / 1000); #endif // // Enable processor interrupts. // IntMasterEnable(); // // Configure the Timer0B interrupt for timer timeout. // TimerIntEnable(TIMER0_BASE, TIMER_TIMB_TIMEOUT); // // Enable the Timer0B interrupt on the processor (NVIC). // IntEnable(INT_TIMER0B); // // Initialize the interrupt counter. // g_ui32Counter = 0; // // Enable Timer0B. // TimerEnable(TIMER0_BASE, TIMER_B); // // Loop forever while the Timer0B runs. // while(1) { // // If the interrupt count changed, print the new value // if(ui32PrevCount != g_ui32Counter) { // // Print the periodic interrupt counter. // UARTprintf("Number of interrupts: %d\r", g_ui32Counter); ui32PrevCount = g_ui32Counter; } } }
int main(void) { uint8_t token = 0U; SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ); PSO_PeripheralEnable(); PSO_GPIOConfig(); PSO_UART0Config(); IntMasterEnable(); /* Timer initialization */ PSO_Timers(); while(1){ if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00) { switch (token) { case 0: PSO_LEDRedOn(); break; case 1: PSO_LEDGreenOn(); break; case 2: PSO_LEDBlueOn(); break; case 3: PSO_LEDCyanOn(); break; case 4: PSO_LEDPurpleOn(); break; case 5: PSO_LEDYellowOn(); break; case 6: PSO_LEDWhiteOn(); break; default: PSO_LEDAllOff(); } /* switch */ SysCtlDelay(100000); SysCtlDelay(100000); token++; if (token > 6) { token = 0; } } /* if */ if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00) { PSO_LEDAllOff(); } SysCtlDelay(100000); read_raw_data (&g_uart0_data); copy_raw_data (&g_tx_buffer_uart, &g_uart0_data); uart_write(); uartBatchWrite (UART0_BASE, uart_tx_buffer, 10); } }
int main(void) { //Set clock so it runs directly on the crystal ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); volatile unsigned long ulLoop; // Initialisation des ports ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH); //Enable les GPIO pour les timings des interrupts et autres GPIOPadConfigSet(GPIO_PORTA_BASE, GPIO_PIN_2, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPD); GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_2); //Mettre les interrupts du port E en haute prorités: évite collisions avec QEI logiciel IntPrioritySet(INT_GPIOE,0); //Activer les interruptions IntMasterEnable(); //Initialisation des variables globales ulLoop = 0; receive_buffer.read=0; receive_buffer.write=0; send_buffer.read=0; send_buffer.write=0; send_buffer2.read=0; send_buffer2.write=0; buffer_commande.read = 0; buffer_commande.write = 0; //QEI position=0; speed=0; state=0; state_m2=0; state_m3=0; position_m2=0; position_m3=0; //Asservissement previous_error0=0; previous_error1=0; previous_error2=0; previous_error3=0; I0=0; I1=0; I2=0; I3=0; consigne0=0; consigne1=0; consigne2=0; consigne3=0; //Pour les déplacements rapides @6400 Kd0 = 0.1; Ki0 = 7; Kp0 = 1.75; Kd1 = 0.1; Ki1 = 7; Kp1 = 1.75; Kd2 = 0.1; Ki2 = 7; Kp2 = 1.75; Kd3 = 0.1; Ki3 = 7; Kp3 = 1.75; Tf0 = 0.1; Tf1 = 0.1; Tf2 = 0.1; Tf3 = 0.1; //Pour les déplacements moyens @3200 Kd0_m = 0.05; Ki0_m = 10; Kp0_m = 1.6; Kd1_m = 0.05; Ki1_m = 10; Kp1_m = 1.5; Kd2_m = 0.05; Ki2_m = 10; Kp2_m = 1.5; Kd3_m = 0.05; Ki3_m = 10; Kp3_m = 1.6; //Pour les mouvements lents @1600 Kd0_s = 0.05; Ki0_s = 12; Kp0_s = 1.2; Kd1_s = 0.05; Ki1_s = 12; Kp1_s = 1.2; Kd2_s = 0.05; Ki2_s = 12; Kp2_s = 1.2; Kd3_s = 0.2; Ki3_s = 12; Kp3_s = 1.2; //Pour les mouvements de dessin @800 Kd0_d = 0.2; Ki0_d = 10; Kp0_d = 1.2; Kd1_d = 0.05; Ki1_d = 10; Kp1_d = 1.2; Kd2_d = 0.05; Ki2_d = 10; Kp2_d = 1.2; Kd3_d = 0.2; Ki3_d = 10; Kp3_d = 1.2; /*Kd0_s = 0.05; Ki0_s = 12;//5.64; Kp0_s = 1.2; Kd1_s = 0.05; Ki1_s = 12;//5.64; Kp1_s = 1.2; Kd2_s = 0.05; Ki2_s = 12;//5.64; Kp2_s = 1.2; Kd3_s = 0.05; Ki3_s = 12;//5.64; Kp3_s = 1.2;*/ dt = 0.1; tolerancePos = 0; posqei1 = 0; speedqei1=0; initCommande(); initMotorCommand(); initLED(); initPrehenseur(); initPWM(); initUART(); initQEI(); //init_lcd(); initTimer(); while(1) { EncoderHandler(); // Traitement des encodeurs en quadrature pour les moteurs 2 et 3 //si un charactère dans la Receive FIFO /*if(!(UART0_FR_R & UART_FR_RXFE)) //&& (send_buffer.read > send_buffer.write-256)) { receive_buffer.buffer[receive_buffer.write%BUFFER_LEN] = UART0_DR_R; receive_buffer.write++; }*/ /* if(!(UART0_FR_R & UART_FR_TXFF) && (send_buffer.read < send_buffer.write)) { UART0_DR_R = send_buffer.buffer[send_buffer.read%BUFFER_LEN]; send_buffer.read++; }*/ /*if(receive_buffer.write - receive_buffer.read > 7){ long i; short commande[8]; for(i=0; i < 8; i++){ commande[i] = receive_buffer.buffer[receive_buffer.read%BUFFER_LEN]; receive_buffer.read++; } traiterNouvelleCommande(commande); //Traitement des commandes } if(buffer_commande.write - buffer_commande.read >= 8){ CommandHandler(); }*/ } }