int main(void)
{
volatile uint32_t ui32Load;
volatile uint32_t ui32PWMClock;
volatile uint8_t ui8Adjust;
ui8Adjust = 254;
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ);
SysCtlPWMClockSet(SYSCTL_PWMDIV_64);
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOPinConfigure(GPIO_PF1_M1PWM5);
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);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, ui32Load);
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8Adjust * ui32Load / 1000);
PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT, true);
PWMGenEnable(PWM1_BASE, PWM_GEN_2);
while(1)
{
if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00)
{
ui8Adjust--;
if (ui8Adjust < 10)
{
ui8Adjust = 10;
}
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8Adjust * ui32Load / 1000);
}
if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00)
{
ui8Adjust++;
if (ui8Adjust > 254)
{
ui8Adjust = 254;
}
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8Adjust * ui32Load / 1000);
}
SysCtlDelay(100000);
}
}
//*****************************************************************************
//
//! Sets the value of the RTC match 0 register.
//!
//! \param ulMatch is the value for the match register.
//!
//! Sets the match 0 register for the RTC. The Hibernation module can be
//! configured to wake from hibernation, and/or generate an interrupt when the
//! value of the RTC counter is the same as the match register.
//!
//! \return None.
//
//*****************************************************************************
void
HibernateRTCMatch0Set(unsigned long ulMatch)
{
//
// Write the new match value to the match register.
//
HWREG(HIB_RTCM0) = ulMatch;
//
// Add a delay here to enforce the required delay between write accesses to
// certain Hibernation module registers.
//
if(CLASS_IS_FURY)
{
//
// Delay a fixed time on Fury-class devices
//
SysCtlDelay(g_ulWriteDelay);
}
else
{
//
// Wait for write complete to be signaled on later devices.
//
HibernateWriteComplete();
}
}
void
UTUtilsDelayCycles(unsigned long ulTimeoutCycles)
{
//
// Call the assembler delay function to spin uselessly for the desired
// period of time.
//
#ifdef ENABLE_PREFETCH
SysCtlDelay((ulTimeoutCycles * PREFETCH_FUDGE_NUM)/
(DELAY_LOOP_INSTRUCTIONS * PREFETCH_FUDGE_DEN));
#else
SysCtlDelay(ulTimeoutCycles / DELAY_LOOP_INSTRUCTIONS);
#endif
return;
}
/**
* Configures the temperature sensor for continuous read mode and reads the
* status register
* Utilizes SSI0
*
* \param statusreg - A pointer to store the status information that is read
**/
void temp_configSensorContinuousRead(uint32_t *statusreg) {
uint32_t commandWriteConfigReg = 0x00000C01;
uint32_t commandReadStatusReg = 0x00000040; // 0b01000000
uint32_t commandReadStatusEmpty = 0x00000000;
uint32_t trashBin[2];
// Setup Configuration Register (register address: 0x01
SSIDataPut(SSI0_BASE, commandWriteConfigReg);
SSIDataPut(SSI0_BASE, commandReadStatusEmpty);
// SysCtlDelay(4170000); // (3 cycles/loop) * (1/50MHz) * (4170000 loop cycles) = 250.2ms
// Read any residual data from the SSI port. This makes sure the receive
// FIFOs are empty, so we don't read any unwanted junk. This is done here
// because the SPI SSI mode is full-duplex, which allows you to send and
// receive at the same time. The SSIDataGetNonBlocking function returns
// "true" when data was returned, and "false" when no data was returned.
// The "non-blocking" function checks if there is any data in the receive
// FIFO and does not "hang" if there isn't.
while(SSIDataGetNonBlocking(SSI0_BASE, &trashBin[0]))
{
}
// Read status register (Address: 0x0)
SSIDataPut(SSI0_BASE, commandReadStatusReg);
SSIDataGet(SSI0_BASE, &trashBin[1]);
SSIDataPut(SSI0_BASE, commandReadStatusEmpty);
SSIDataGet(SSI0_BASE, statusreg);
//Need to adjust for different processor frequencies
SysCtlDelay(4170000); // (3 cycles/loop) * (1/50MHz) * (4170000 loop cycles) = 250.2ms
}
void SampleLightCO(void){
unsigned long ulADC0_Value[1];
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_3);
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE |
ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 3);
ADCIntClear(ADC0_BASE, 3);
while(1){
ADCProcessorTrigger(ADC0_BASE, 3);
while(!ADCIntStatus(ADC0_BASE, 3, false)){
}
ADCIntClear(ADC0_BASE, 3);
ADCSequenceDataGet(ADC0_BASE, 3, ulADC0_Value);
Log("Breath Level = ");
LogD(ulADC0_Value[0]);
Log("\r");
SysCtlDelay(SysCtlClockGet() / 12);
}
}
void uartprinntf()
{
//
// Initionalize system clock.
//
xSysCtlPeripheralClockSourceSet( 10000000, xSYSCTL_XTAL_6MHZ );
SysCtlDelay(10000);
xSPinTypeUART(UART0RX,PB0);
xSPinTypeUART(UART0TX,PB1);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_UART_S_EXT12M);
//
// Config 8 bit word length, 1 stop bit,
// and none parity bit, receive FIFO 1 byte.
//
UARTConfigSetExpClk(UART0_BASE, 115200, (UART_CONFIG_WLEN_8 |
UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
UARTEnable(UART0_BASE, (UART_BLOCK_UART | UART_BLOCK_TX | UART_BLOCK_RX));
UARTBufferWrite(UART0_BASE, "NUC1xx.UART.BAUDRATE EXAMPLE \r\n", sizeof("NUC1xx.UART.BAUDRATE EXAMPLE \r\n"));
}
//*****************************************************************************
//
//! \internal
//!
//! Write a sequence of bytes to the SSD0303 or SD1300 controller.
//!
//! This function continues a transfer to the display controller by writing a
//! sequence of bytes over the I2C bus. This must only be called after calling
//! Display96x16x1WriteFirst(), but before calling Display96x16x1WriteFinal().
//!
//! The data is written in a polled fashion; this function will not return
//! until the entire byte sequence has been written to the controller.
//!
//! \return None.
//
//*****************************************************************************
static void
Display96x16x1WriteArray(uint8_t const *pucBuffer, uint32_t ulCount)
{
//
// Loop while there are more bytes left to be transferred.
//
while(ulCount != 0)
{
//
// Wait until the current byte has been transferred.
//
while(I2C0_MASTER->MRIS == 0)
{
}
//
// Provide the required inter-byte delay.
//
SysCtlDelay(g_ulDelay);
//
// Write the next byte to the controller.
//
I2C0_MASTER->MDR = *pucBuffer++;
ulCount--;
//
// Continue the transfer.
//
I2C0_MASTER->MCS = I2C_MASTER_CMD_BURST_SEND_CONT;
}
}
//*****************************************************************************
//
//! \internal
//!
//! Write a byte to the SSD0303 or SSD1300 controller.
//!
//! \param ucChar is the byte to be transmitted to the controller.
//!
//! This function continues a transfer to the display controller by writing
//! another byte over the I2C bus. This must only be called after calling
//! Display96x16x1WriteFirst(), but before calling Display96x16x1WriteFinal().
//!
//! The data is written in a polled faashion; this function will not return
//! until the byte has been written to the controller.
//!
//! \return None.
//
//*****************************************************************************
static void
Display96x16x1WriteByte(uint8_t ucChar)
{
//
// Wait until the current byte has been transferred.
//
while(I2C0_MASTER->MRIS == 0)
{
}
//
// Provide the required inter-byte delay.
//
SysCtlDelay(g_ulDelay);
//
// Write the next byte to the controller.
//
I2C0_MASTER->MDR = ucChar;
//
// Continue the transfer.
//
I2C0_MASTER->MCS = I2C_MASTER_CMD_BURST_SEND_CONT;
}
void BPMTimerSetUp()
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); // timer 0
SysCtlDelay(3);
//
// Enable processor interrupts.
//
//IntPrioritySet(INT_TIMER0A_TM4C123, 2);
//
// Configure the two 32-bit periodic timers.
//
ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet()/500);
//ROM_SysCtlClockGet()/100000
//ROM_SysCtlClockGet()/500
// Setup the interrupts for the timer timeouts.
ROM_IntEnable(INT_TIMER0A);
ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//
// Enable the timers.
//
ROM_TimerEnable(TIMER0_BASE, TIMER_A);
}
int main(void) {
SysCtlClockSet(
SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
UARTStdioConfig(0, 115200, 16000000);
ADCSequenceDisable(ADC0_BASE, 1);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 3,
ADC_CTL_TS | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
UARTprintf("This is ADC examlpe");
while (1) {
UARTprintf("Temperature is: %d \210 C\n", ADC_getVal());
SysCtlDelay(40000000 / 3);
}
}
int main(void) {
SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_SYSDIV_5| SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE,1,3,ADC_CTL_TS|ADC_CTL_IE|ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
ledPinConfig();
while (1)
{
Test2();
//print_temc();
SysCtlDelay(SysCtlClockGet()/3);
}
}
int main(void)
{
unsigned char i;
xSysCtlClockSet(16000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
// xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
SensorShieldInit();
SensorShieldIOInit();
xGPIOSPinDirModeSet(SENSOR_SHIELD_I0, xGPIO_DIR_MODE_IN);
xGPIOSPinDirModeSet(SENSOR_SHIELD_I1, xGPIO_DIR_MODE_IN);
xGPIOSPinDirModeSet(SENSOR_SHIELD_I2, xGPIO_DIR_MODE_IN);
xGPIOSPinIntEnable(SENSOR_SHIELD_I0, xGPIO_RISING_EDGE);
xGPIOSPinIntEnable(SENSOR_SHIELD_I1, xGPIO_RISING_EDGE);
xGPIOSPinIntEnable(SENSOR_SHIELD_I2, xGPIO_RISING_EDGE);
xGPIOSPinIntCallbackInit(SENSOR_SHIELD_I0, Key1Callback);
xGPIOSPinIntCallbackInit(SENSOR_SHIELD_I1, Key2Callback);
xGPIOSPinIntCallbackInit(SENSOR_SHIELD_I2, Key3Callback);
xIntEnable(xINT_GPIOB);
xIntEnable(xINT_GPIOB);
SensorShieldOutWrite(SENSOR_SHIELD_O0, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O1, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O2, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O3, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O4, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O5, 1);
while(1)
{
if(key2)
{
key2 = 0;
for(i=0;i<10;i++){
SensorShieldOutWrite(SENSOR_SHIELD_O0, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O1, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O2, 1);
SysCtlDelay(1000000);
SensorShieldOutWrite(SENSOR_SHIELD_O0, 0);
SensorShieldOutWrite(SENSOR_SHIELD_O1, 0);
SensorShieldOutWrite(SENSOR_SHIELD_O2, 0);
SysCtlDelay(1000000);
}
}
}
}
void _EncoderInit(){
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralEnable(SYSCTL_PERIPH_QEI0);
SysCtlDelay(1);
HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTD_BASE + GPIO_O_CR) |= 0x80;
//Set Pins to be PHA0 and PHB0
GPIOPinConfigure(GPIO_PD6_PHA0);
GPIOPinConfigure(GPIO_PD7_PHB0);
GPIOPinTypeQEI(GPIO_PORTD_BASE, GPIO_PIN_6 | GPIO_PIN_7);
QEIDisable(QEI0_BASE);
QEIIntDisable(QEI0_BASE,QEI_INTERROR | QEI_INTDIR | QEI_INTTIMER | QEI_INTINDEX);
QEIConfigure(QEI0_BASE, (QEI_CONFIG_CAPTURE_A_B | QEI_CONFIG_NO_RESET | QEI_CONFIG_QUADRATURE | QEI_CONFIG_NO_SWAP), 1000);
QEIVelocityConfigure(QEI0_BASE, QEI_VELDIV_1,80000000/12);
QEIEnable(QEI0_BASE);
QEIVelocityEnable(QEI0_BASE);
//Set position to a middle value so we can see if things are working
QEIPositionSet(QEI0_BASE, 500);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralEnable(SYSCTL_PERIPH_QEI1);
SysCtlDelay(1);
//Set Pins to be PHA0 and PHB0
GPIOPinConfigure(GPIO_PC5_PHA1);
GPIOPinConfigure(GPIO_PC6_PHB1);
GPIOPinTypeQEI(GPIO_PORTC_BASE, GPIO_PIN_5 | GPIO_PIN_6);
QEIDisable(QEI1_BASE);
QEIIntDisable(QEI1_BASE,QEI_INTERROR | QEI_INTDIR | QEI_INTTIMER | QEI_INTINDEX);
QEIConfigure(QEI1_BASE, (QEI_CONFIG_CAPTURE_A_B | QEI_CONFIG_NO_RESET | QEI_CONFIG_QUADRATURE | QEI_CONFIG_SWAP), 1000);
QEIVelocityConfigure(QEI1_BASE, QEI_VELDIV_1,80000000/12);
QEIEnable(QEI1_BASE);
QEIVelocityEnable(QEI1_BASE);
//Set position to a middle value so we can see if things are working
QEIPositionSet(QEI1_BASE, 500);
}
//*****************************************************************************
//
// Configure the USB controller and power the bus.
//
// This function configures the USB controller for host operation.
// It is assumed that the main system clock has been configured at this point.
//
// \return None.
//
//*****************************************************************************
void
ConfigureUSBInterface(void)
{
//
// Enable the uDMA controller and set up the control table base.
// This is required by usblib.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
uDMAEnable();
uDMAControlBaseSet(g_sDMAControlTable);
//
// Enable the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Set the USB pins to be controlled by the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
ROM_GPIOPinConfigure(GPIO_PG4_USB0EPEN);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Register the host class driver
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, NUM_CLASS_DRIVERS);
//
// Open an instance of the mass storage class driver.
//
g_psMSCInstance = USBHMSCDriveOpen(0, MSCCallback);
//
// Initialize the power configuration. This sets the power enable signal
// to be active high and does not enable the power fault.
//
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
//
// Force the USB mode to host with no callback on mode changes since
// there should not be any.
//
USBStackModeSet(0, eUSBModeForceHost, 0);
//
// Wait 10ms for the pin to go low.
//
SysCtlDelay(SysCtlClockGet()/100);
//
// Initialize the host controller.
//
USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE);
}
int getDistance()
{
int i,j;
float lat_proper; //These store the properly formatted lat/longs in decimal.
float long_proper;
LCDWriteText("Locating... ", 0, 0);
LCDWriteText(" ", 1, 0);
#ifdef EASYOPEN //Untested, should work.
int open=true;
for(int i=0;i<3000;i++)
{
if (GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)!=0) {open = false;}
}
if (open == true) {return 0;}
#endif
for (i = 0;i<TIMEOUT;i++) //for TIMEOUT seconds of trying
{
if (haveFix == 1)
{
//This should all work - the values given are reasonable, but needs to be tested outside.
lat_proper = 10*(latitude[0]-ATD)+latitude[1]-ATD;
lat_proper += ((float)(10*(latitude[2]-ATD) + latitude[3]-ATD))/60.0;
long_proper = 10*(longitude[1]-ATD)+longitude[2]-ATD;
long_proper += ((float)(10*(longitude[3]-ATD)+longitude[4]-ATD))/60.0;
for (j=0;j<5;j++)
{
lat_proper += ((float)(latitude[5+j]-ATD) /(600.0 * (float)(10^j)));
long_proper += ((float)(longitude[6+j]-ATD) /(600.0 * (float)(10^j)));
}
if (neglat){lat_proper = -lat_proper;}
if (neglong){long_proper = -long_proper;}
double dlat1=lat_proper*(M_PI/180);
double dlong1=long_proper*(M_PI/180);
double dlat2 = FINALLAT * (M_PI/180);
double dlong2= FINALLONG * (M_PI/180);
double dLong=dlong1-dlong2;
double dLat=dlat1-dlat2;
double aHarv= pow(sin(dLat/2.0),2.0) + cos(dlat1)*cos(dlat2)*pow(sin(dLong/2),2);
double cHarv=2*atan2(sqrt(aHarv),sqrt(1.0-aHarv));
//double distance=EARTHRADIUS*cHarv;
haveFix = 0;
return (int)(EARTHRADIUS*cHarv*1000); //whatever, need to get correct distance here.
}
SysCtlDelay(SysCtlClockGet()/3);
}
//if got fix, return distance.
//else, return 99999 to signal couldn't fix so no penalty
return 99999;
}
void pause (unsigned int amount)
{
/*
static unsigned int fudge_factor = 0 ;
unsigned long ul ;
*/
SysCtlDelay(SysCtlClockGet() / (1000 * 3));
}
//*****************************************************************************
//
// This function provides a 1 second delay using a simple polling method.
//
//*****************************************************************************
void
SimpleDelay(void)
{
//
// Delay cycles for 1 second
//
SysCtlDelay(16000000 / 3);
}
void glcd_setpage (unsigned char page)
{
/*set CS1(CS1=1 ans CS2=0)right side is selected for column>64 */
GPIOPinWrite(GPIO_PORTD_BASE,GPIO_PIN_3, 0x00);
/*Select the page*/
glcd_cmd(0xB8 | page);
SysCtlDelay(100);
/*set CS2(CS1=0 ans CS2=1)left side is selected for column<64 */
GPIOPinWrite(GPIO_PORTD_BASE,GPIO_PIN_3, 0x08);
/*select the page*/
glcd_cmd(0xB8 | page);
SysCtlDelay(100);
}
int main(void)
{
SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // Enable the GPIO A ports
GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_7); // Set pin 7 as the output port
while(1)
{
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_7,0);
SysCtlDelay(4000000);
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_7,128); // Give '1' to pin 7
SysCtlDelay(4000000);
}
}
uint8_t cc112x_write_regs(const int xcvr, const uint16_t const regSettings[][2], const int arrLen)
{
while(SSIBusy(SSI0_BASE));
SysCtlDelay(SysCtlClockGet() / (3*1000));
int i;
for(i = 0; i < arrLen; i++)
{
//cc112x_print_status_byte(cc112x_sgl_reg_access(xcvr, REG_WRITE, regSettings[i][0], regSettings[i][1]));
cc112x_sgl_reg_access(xcvr, REG_WRITE, regSettings[i][0], regSettings[i][1]);
//UART_TX_string("\n\r");
}
SysCtlDelay(SysCtlClockGet() / (3*100));
return 0;
}
void loop(){
char le = (char) UARTCharGet(b5);
putChar(le);
UARTCharPut(b5, (char)((int) le - 32));
SysCtlDelay(3000);
}
void main(void)
{
//unsigned long ulTmp = 0;
/********************** Configure System clock *************************/
SysCtlClockSet(100000000, SYSCTL_OSC_INT | SYSCTL_XTAL_12_MHZ);
SysCtlDelay(TICK_SLOW);
// Configure LED(PC3) pin
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
xGPIOSPinTypeGPIOOutput(PC3);
// Turn off LED
GPIOPinClr(GPIOC_BASE, GPIO_PIN_3);
// Disable NVIC RTC interrupt
xIntDisable(xINT_RTC);
RTCDisable();
RTCIntCallbackInit(RTCHandler);
// Enable RTC second increment interrupt.
// Enable RTC minute interrupt.
RTCIntCfg( INT_SEC_EN | INT_MIN_DIS |
INT_HOUR_DIS | INT_DOM_DIS |
INT_DOW_DIS | INT_DOY_DIS |
INT_MON_DIS | INT_YEAR_DIS |
INT_ALARM_SEC_DIS | INT_ALARM_MIN_EN |
INT_ALARM_HOUR_DIS | INT_ALARM_DOM_DIS |
INT_ALARM_DOW_DIS | INT_ALARM_DOY_DIS |
INT_ALARM_MON_DIS | INT_ALARM_YEAR_DIS );
RTCTimeSet(RTC_TIMETYPE_SECOND, 0);
RTCTimeSet(RTC_TIMETYPE_MINUTE, 0);
RTCTimeSet(RTC_TIMETYPE_HOUR, 0);
RTCTimeSet(RTC_TIMETYPE_DAYOFWEEK, 0);
RTCTimeSet(RTC_TIMETYPE_DAYOFMONTH, 0);
RTCTimeSet(RTC_TIMETYPE_DAYOFYEAR, 0);
RTCTimeSet(RTC_TIMETYPE_MONTH, 0);
RTCTimeSet(RTC_TIMETYPE_YEAR, 0);
RTCAlarmSet(RTC_TIMETYPE_SECOND, 0);
RTCAlarmSet(RTC_TIMETYPE_MINUTE, 1);
RTCAlarmSet(RTC_TIMETYPE_HOUR, 0);
RTCAlarmSet(RTC_TIMETYPE_DAYOFWEEK, 0);
RTCAlarmSet(RTC_TIMETYPE_DAYOFMONTH, 0);
RTCAlarmSet(RTC_TIMETYPE_DAYOFYEAR, 0);
RTCAlarmSet(RTC_TIMETYPE_MONTH, 0);
RTCAlarmSet(RTC_TIMETYPE_YEAR, 0);
RTCEnable();
RTCCounterReset();
xIntEnable(xINT_RTC);
while (1)
{
; // DoNothing
}
}
void initLCD() {
// -- paramra LED test
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, 0x0F);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0x0F );
SysCtlPeripheralEnable(LCDPORTENABLE);
// -- paramra port A as control
SysCtlPeripheralEnable(LCDCTRLENABLE);
GPIOPinTypeGPIOOutput(LCDPORT,
0xff);
// -- paramra port A as control
GPIOPinTypeGPIOOutput(LCDCTRL,
0xff);
// Please refer to the HD44780 datasheet for how these initializations work!
SysCtlDelay((500e-3)*CLKSPEED/3);
GPIOPinWrite(LCDCTRL, RS, 0x00 );
GPIOPinWrite(LCDPORT, D4 | D5 | D6 | D7, 0x30 );
GPIOPinWrite(LCDCTRL, E, 0x10);SysCtlDelay((20e-6)*CLKSPEED/3); GPIOPinWrite(LCDCTRL, E, 0x00);
SysCtlDelay((50e-3)*CLKSPEED/3);
GPIOPinWrite(LCDPORT, D4 | D5 | D6 | D7, 0x30 );
GPIOPinWrite(LCDCTRL, E, 0x10);SysCtlDelay((20e-6)*CLKSPEED/3);GPIOPinWrite(LCDCTRL, E, 0x00);
SysCtlDelay((50e-3)*CLKSPEED/3);
GPIOPinWrite(LCDPORT, D4 | D5 | D6 | D7, 0x30 );
GPIOPinWrite(LCDCTRL, E, 0x10);SysCtlDelay((20e-6)*CLKSPEED/3); GPIOPinWrite(LCDCTRL, E, 0x00);
SysCtlDelay((10e-3)*CLKSPEED/3);
GPIOPinWrite(LCDPORT, D4 | D5 | D6 | D7, 0x20 );
GPIOPinWrite(LCDCTRL, E, 0x10);SysCtlDelay((20e-6)*CLKSPEED/3); GPIOPinWrite(LCDCTRL, E, 0x00);
SysCtlDelay((10e-3)*CLKSPEED/3);
LCDCommand(0x01); // Clear the screen.
LCDCommand(0x06); // Cursor moves right.
LCDCommand(0x0f); // Cursor blinking, turn on LCD.
}
void delaymycode(uint16_t delaytime) {
uint16_t i = 0;
while(i < delaytime){
SysCtlDelay(200000); //100ms. argument of 100 is 2uS
i++;
}
return;
}
void CHRONO_Delay_1ms(uint32_t delay)
{
uint32_t i = 0;
while(i<delay)
{
SysCtlDelay((SysCtlClockGet() / FREQ_1KHz / NUM_LOOP_CYCLES ));
i++;
}
}
static void SysInit(void)
{
// Close watchdog
(*((volatile unsigned long *)(0x40048100))) = 0x00;
// Configure System clock
xSysCtlClockSet(F_CLK, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
SysCtlDelay(100*TICK_1MS);
}
void delayMicroseconds(unsigned long nTime) {
if (!nTime) return;
else if (nTime < 3) SysCtlDelay(12 * nTime); // empirical
else {
// Compensates for latency
unsigned long endtime = micros() + nTime - 1;
while(micros() < endtime);
}
}
void delay_ms(unsigned long ms)
{
unsigned long t;
t = ms * (SysCtlClockGet() / 3000);
SysCtlDelay(t); //3 cycles
return;
}
//*****************************************************************************
//
// Configure the USB controller and power the bus.
//
// This function configures the USB controller for host operation.
// It is assumed that the main system clock has been configured at this point.
//
// \return None.
//
//*****************************************************************************
void
ConfigureUSBInterface(void)
{
//
// Enable the uDMA controller and set up the control table base.
// This is required by usblib.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
uDMAEnable();
uDMAControlBaseSet(g_sDMAControlTable);
//
// Enable the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Set the USB pins to be controlled by the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
GPIOPinConfigure(GPIO_PH3_USB0EPEN);
GPIOPinConfigure(GPIO_PH4_USB0PFLT);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTH_BASE, GPIO_PIN_3 | GPIO_PIN_4);
//
// Register the host class driver
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, NUM_CLASS_DRIVERS);
//
// Open an instance of the mass storage class driver.
//
g_ulMSCInstance = USBHMSCDriveOpen(0, MSCCallback);
//
// Initialize the power configuration. This sets the power enable signal
// to be active high and does not enable the power fault.
//
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
//
// Set the ID pin to be driven low so that OTG calls are not necessary.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_0);
GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_0, 0);
//
// Wait 10ms for the pin to go low.
//
SysCtlDelay(SysCtlClockGet()/100);
//
// Initialize the host controller.
//
USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE);
}
void initMPU6500(mpu6500_t *mpu6500) {
uint8_t i2cBuffer[5]; // Buffer for I2C data
i2cBuffer[0] = i2cRead(MPU6500_ADDRESS, MPU6500_WHO_AM_I);
if (i2cBuffer[0] == MPU6500_WHO_AM_I_ID) { // Read "WHO_AM_I" register
#if UART_DEBUG
UARTprintf("MPU-6500 found\n");
#endif
} else if (i2cBuffer[0] == MPU9250_WHO_AM_I_ID) {
#if UART_DEBUG
UARTprintf("MPU-9250 found\n");
#endif
} else {
#if UART_DEBUG
UARTprintf("Could not find MPU-6500 or MPU-9250: %2X\n", i2cBuffer[0]);
#endif
while (1);
}
i2cWrite(MPU6500_ADDRESS, MPU6500_PWR_MGMT_1, (1 << 7)); // Reset device, this resets all internal registers to their default values
delay(100);
while (i2cRead(MPU6500_ADDRESS, MPU6500_PWR_MGMT_1) & (1 << 7)) {
// Wait for the bit to clear
};
delay(100);
i2cWrite(MPU6500_ADDRESS, MPU6500_PWR_MGMT_1, (1 << 3) | (1 << 0)); // Disable sleep mode, disable temperature sensor and use PLL as clock reference
i2cBuffer[0] = 0; // Set the sample rate to 1kHz - 1kHz/(1+0) = 1kHz
i2cBuffer[1] = 0x03; // Disable FSYNC and set 41 Hz Gyro filtering, 1 KHz sampling
i2cBuffer[2] = 3 << 3; // Set Gyro Full Scale Range to +-2000deg/s
i2cBuffer[3] = 2 << 3; // Set Accelerometer Full Scale Range to +-8g
i2cBuffer[4] = 0x03; // 41 Hz Acc filtering
i2cWriteData(MPU6500_ADDRESS, MPU6500_SMPLRT_DIV, i2cBuffer, 5); // Write to all five registers at once
// Set accelerometer and gyroscope scale factor from datasheet
mpu6500->gyroScaleFactor = MPU6500_GYRO_SCALE_FACTOR_2000;
mpu6500->accScaleFactor = MPU6500_ACC_SCALE_FACTOR_8;
/* Enable Raw Data Ready Interrupt on INT pin and enable bypass/passthrough mode */
i2cBuffer[0] = (1 << 5) | (1 << 4) | (1 << 1); // Enable LATCH_INT_EN, INT_ANYRD_2CLEAR and BYPASS_EN
// When this bit is equal to 1, the INT pin is held high until the interrupt is cleared
// When this bit is equal to 1, interrupt status is cleared if any read operation is performed
// When asserted, the I2C_MASTER interface pins (ES_CL and ES_DA) will go into 'bypass mode' when the I2C master interface is disabled
i2cBuffer[1] = (1 << 0); // Enable RAW_RDY_EN - When set to 1, Enable Raw Sensor Data Ready interrupt to propagate to interrupt pin
i2cWriteData(MPU6500_ADDRESS, MPU6500_INT_PIN_CFG, i2cBuffer, 2); // Write to both registers at once
// Set INT input pin
SysCtlPeripheralEnable(GPIO_MPU_INT_PERIPH); // Enable GPIO peripheral
SysCtlDelay(2); // Insert a few cycles after enabling the peripheral to allow the clock to be fully activated
GPIOPinTypeGPIOInput(GPIO_MPU_INT_BASE, GPIO_MPU_INT_PIN); // Set as input
delay(100); // Wait for sensor to stabilize
while (calibrateMPU6500Gyro()) { // Get gyro zero values
// Loop until calibration is successful
}
}
