void systick_init(void) {
// 1 ms period
SysTickPeriodSet(8000);
SysTickIntEnable();
SysTickIntRegister(schedule);
SysTickEnable();
}
int ConnectNetwork(Network* n, char* addr, int port)
{
SlSockAddrIn_t sAddr;
int addrSize;
int retVal;
unsigned long ipAddress;
sl_NetAppDnsGetHostByName(addr, strlen(addr), &ipAddress, AF_INET);
sAddr.sin_family = AF_INET;
sAddr.sin_port = sl_Htons((unsigned short)port);
sAddr.sin_addr.s_addr = sl_Htonl(ipAddress);
addrSize = sizeof(SlSockAddrIn_t);
n->my_socket = sl_Socket(SL_AF_INET,SL_SOCK_STREAM, 0);
if( n->my_socket < 0 ) {
// error
return -1;
}
retVal = sl_Connect(n->my_socket, ( SlSockAddr_t *)&sAddr, addrSize);
if( retVal < 0 ) {
// error
sl_Close(n->my_socket);
return retVal;
}
SysTickIntRegister(SysTickIntHandler);
SysTickPeriodSet(80000);
SysTickEnable();
return retVal;
}
static void system_SystickConfig(uint32_t ui32_msInterval)
{
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() * ui32_msInterval / 1000);
SysTickIntRegister(&SysTickIntHandle);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
}
// **********************************************
// Initializes the real-time clock (systick).
void mRTCInit(unsigned short rtc_rate_given)
{
g_uiRTCRateHz = rtc_rate_given;
clockInit();
SysTickPeriodSet(SysCtlClockGet() / g_uiRTCRateHz);
//SysTickPeriodSet((SysTickPeriodGet()/4294967296) / (SYSTICK_RATE));
//
// Reset real time clock
g_ullRTCTicks = 0;
//
// Register the interrupt handler
SysTickIntRegister(SysTickISR);
//
// Enable interrupt and device
SysTickIntEnable();
SysTickEnable();
// clear the systick() task list.
short i = 0;
g_RTCNumTasks = 0;
for (i = 0; i < SYSTICK_TASK_LIST_SIZE; i++)
{
g_RTCTaskList[i] = 0;
}
}
int NetworkConnectTLS(Network *n, char* addr, int port, SlSockSecureFiles_t* certificates, unsigned char sec_method, unsigned int cipher, char server_verify)
{
SlSockAddrIn_t sAddr;
int addrSize;
int retVal;
unsigned long ipAddress;
retVal = sl_NetAppDnsGetHostByName(addr, strlen(addr), &ipAddress, AF_INET);
if (retVal < 0) {
return -1;
}
sAddr.sin_family = AF_INET;
sAddr.sin_port = sl_Htons((unsigned short)port);
sAddr.sin_addr.s_addr = sl_Htonl(ipAddress);
addrSize = sizeof(SlSockAddrIn_t);
n->my_socket = sl_Socket(SL_AF_INET, SL_SOCK_STREAM, SL_SEC_SOCKET);
if (n->my_socket < 0) {
return -1;
}
SlSockSecureMethod method;
method.secureMethod = sec_method;
retVal = sl_SetSockOpt(n->my_socket, SL_SOL_SOCKET, SL_SO_SECMETHOD, &method, sizeof(method));
if (retVal < 0) {
return retVal;
}
SlSockSecureMask mask;
mask.secureMask = cipher;
retVal = sl_SetSockOpt(n->my_socket, SL_SOL_SOCKET, SL_SO_SECURE_MASK, &mask, sizeof(mask));
if (retVal < 0) {
return retVal;
}
if (certificates != NULL) {
retVal = sl_SetSockOpt(n->my_socket, SL_SOL_SOCKET, SL_SO_SECURE_FILES, certificates->secureFiles, sizeof(SlSockSecureFiles_t));
if (retVal < 0)
{
return retVal;
}
}
retVal = sl_Connect(n->my_socket, (SlSockAddr_t *)&sAddr, addrSize);
if (retVal < 0) {
if (server_verify || retVal != -453) {
sl_Close(n->my_socket);
return retVal;
}
}
SysTickIntRegister(SysTickIntHandler);
SysTickPeriodSet(80000);
SysTickEnable();
return retVal;
}
void SystickIntInit(){
//Enables Systick
SysTickIntEnable();
//Registers the Systick interrupt handler
SysTickIntRegister(SystickIntHandler);
//Set the countdown time to about .1 ms
SysTickPeriodSet(90000);
}
/*************************************************************************************************
* Initializes the system clock to run from the crystal
* and enables the board's systick functionality.
************************************************************************************************/
void systemInit() {
// Set the clocking to run directly from the crystal.
SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
// Configure and Enable SysTick mechanism
SysTickPeriodSet(SysCtlClockGet() / SYSTICK_FREQUENCY);
SysTickIntRegister(sysTickISR);
SysTickIntEnable();
SysTickEnable();
}
int
main(void)
{
//set clock
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
//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);
// Status
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_2,GPIO_STRENGTH_4MA,GPIO_PIN_TYPE_STD);
GPIODirModeSet(GPIO_PORTF_BASE,GPIO_PIN_2,GPIO_DIR_MODE_OUT);
//UART
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 9600,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
IntEnable(INT_UART0);
UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
IntPrioritySet(INT_UART0, 0x7F);
IntPrioritySet(INT_GPIOB,0x80);
IntMasterEnable();
SysTickIntRegister(SysTickHandler);
SysTickPeriodSet(SysCtlClockGet()/10000); // 0.1ms
SysTickIntEnable();
waitTime = 0; // initialize
waitTime2 = 0;
SysTickEnable();
while(1)
{
}
}
void cc32xx_init_timer(void)
{
static int init = 0;
if (!init) {
SysTickEnable();
SysTickIntEnable();
SysTickIntRegister(sysTickIntHandler);
SysTickPeriodSet(MPU_FREQUENCY / 1000);/* 1 ms */
init = 1;
}
}
// Main
void main(void) {
mainSetup();
IntMasterEnable();
GPIOIntRegister(GPIO_PORTJ_BASE, interruptHandler);
GPIOIntTypeSet(GPIO_PORTJ_BASE, GPIO_PIN_0, GPIO_FALLING_EDGE);
GPIOIntEnable(GPIO_PORTJ_BASE, GPIO_PIN_0);
//GPIOIntTypeSet(GPIO_PORTJ_BASE, GPIO_PIN_1, GPIO_FALLING_EDGE);
//GPIOIntEnable(GPIO_PORTJ_BASE, GPIO_PIN_1);
SysTickEnable();
SysTickPeriodSet(currentFreq);
SysTickIntRegister(timerstep);
SysTickIntEnable();
while (true);
}
int main(void) {
// Set the system clock to the full 120MHz
uint32_t sysClkFreq = SysCtlClockFreqSet(SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480, 120000000);
debug_init(sysClkFreq);
status_led_init();
network_driver_init(sysClkFreq);
networking_init();
telemetry_init();
transducer_init();
thermocouple_init();
solenoid_init();
debug_print("Initialization complete. starting main loop.\r\n");
// Set up the SysTick timer and its interrupts
SysTickPeriodSet(6000); // 40 kHz
SysTickIntRegister(sys_tick);
SysTickIntEnable();
SysTickEnable();
uint32_t loopIterations = 0;
uint32_t frame_start = systick_clock;
while(1) {
status_led_periodic();
network_driver_periodic();
telemetry_periodic();
solenoid_periodic();
// debug_print_u32(systick_clock);
//count loop iterations per second
loopIterations++;
if(systick_clock - frame_start >= 1000) {
loops_per_second = loopIterations;
loopIterations = 0;
frame_start = systick_clock;
}
}
}
/* This function is to initialize the SysTick relate configurations */
void BSP_SysTickInit()
{
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr;
#endif
OS_ENTER_CRITICAL();
SysTickIntDisable();
SysTickIntRegister(OSTimeTickIsr);
SysTickPeriodSet(80000);
SysTickIntEnable();
SysTickEnable();
OS_EXIT_CRITICAL();
SysTickOut = 0x01;
SysTickLedOut = GPIO_LED_PIN1;
}
//*****************************************************************************
// Initialisation functions for the clock (incl. SysTick), ADC, display
//*****************************************************************************
void initClock (void)
{
// Set the clock rate. From Section 19.1 in stellaris_peripheral_lib_UG.doc:
// "In order to use the ADC, the PLL must be used; the PLL output will be
// used to create the clock required by the ADC." ADC rate = 8 MHz / 10.
// The processor clock rate = 20 MHz.
SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
// Set up the period for the SysTick timer. The SysTick timer period is
// set as a function of the system clock.
SysTickPeriodSet(SysCtlClockGet() / SAMPLE_RATE_HZ);
// Register the interrupt handler
SysTickIntRegister(SysTickIntHandler);
//
// Enable interrupt and device
SysTickIntEnable();
SysTickEnable();
}
//*****************************************************************************
//
// Main Program
//
//*****************************************************************************
int
main(void)
{
unsigned long ulPeriod;
// 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);
// Enable the peripherals used by this application
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
// Set GPIO F0 and G1 as PWM pins. They are used to output the PWM0 and
// PWM1 signals.
GPIOPinTypePWM(GPIO_PORTG_BASE, GPIO_PIN_1);
// Compute the PWM period based on the system clock.
ulPeriod = SysCtlClockGet() / 440;
// Set the PWM period to 440 (A) Hz.
PWMGenConfigure(PWM0_BASE, PWM_GEN_0,
PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod);
// Set PWM0 to a duty cycle of 25% and PWM1 to a duty cycle of 75%.
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, ulPeriod / 4);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, ulPeriod * 3 / 4);
// Enable the PWM0 and PWM1 output signals.
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, true);
// Configure the 'up' button as input and enable the pin to interrupt on
// the falling edge (i.e. when the push button is pressed).
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_0);
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0,
GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
// Configure the 'down' button as input and enable the pin to interrupt on
// the falling edge (i.e. when the push button is pressed).
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_1);
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
// Configure the 'left' button as input and enable the pin to interrupt on
// the falling edge (i.e. when the push button is pressed).
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_2);
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_2, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
// Configure the 'right' button as input and enable the pin to interrupt on
// the falling edge (i.e. when the push button is pressed).
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_3);
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_3, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
GPIOIntTypeSet(GPIO_PORTE_BASE, GPIO_PIN_2 | GPIO_PIN_3,
GPIO_FALLING_EDGE);
GPIOPortIntRegister(GPIO_PORTE_BASE, GPIOEIntHandler);
GPIOPinIntEnable(GPIO_PORTE_BASE, GPIO_PIN_2 | GPIO_PIN_3);
IntEnable(INT_GPIOE);
// Configure the LED
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
// Configure the select buttons as input and enable the pin to interrupt on
// the falling edge (i.e. when the push button is pressed).
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_FALLING_EDGE);
GPIOPortIntRegister(GPIO_PORTF_BASE, GPIOFIntHandler);
GPIOPinIntEnable(GPIO_PORTF_BASE, GPIO_PIN_1);
IntEnable(INT_GPIOF);
// Initial time to display
static char pcInitTime[10];
usprintf(pcInitTime, "%d%d:%d%d AM", h2, h1, m2, m1);
// Set the time between SysTick interrupts and register the interrupt handle
SysTickPeriodSet(SysCtlClockGet());
SysTickIntRegister(SysTickIntHandler);
// Begin a blinking display of the initial start message
while (!start){
int a;
for (a=0; a<300000; a++){
if (a%20000==0){
RIT128x96x4StringDraw(pcInitTime, 40, 40, a/20000);
}
}
}
// The clock has started so we can clear the message
RIT128x96x4Clear();
// Loop forever
while(1)
{
// Display the updated time
DisplayTime();
// Check if we should sound the alarm
TisA();
}
}
int main(void)
{
/*Set the clocking to run at 80Mhz from the crystal of 16MHz using PLL*/
SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
/* Set the clock for the GPIO Port A,B, E and F */
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
/* Set the type of the GPIO Pin */
GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);
GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3);
/* Set the clock for the SSI Module0 */
SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
//Initialising UART
InitConsole();
/*Configure SysTick for a 100Hz interrupt. The FatFs driver wants a 10 milliseconds interrupt.*/
SysTickPeriodSet(SysCtlClockGet() / 10000);
SysTickIntRegister(SysTickHandler);
SysTickEnable();
SysTickIntEnable();
/* Set the type of the GPIO Pin of PORTF */
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2 );
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4);
/* GPIO Pin2 on PORT F initialized to 0 */
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2 , 0 );
/* Configure GPIO pad with internal pull-up enabled */
GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
/* Enable global interupts */
IntMasterEnable();
UARTprintf("MOUNT initialize!!!\n");
rc=f_mount(0, &fatfs); // Register volume work area (never fails)
if(rc!=FR_OK)
{
UARTprintf("1.rc=%d\nERROR MOUNT!!!",rc);
}
/* Reset and Initialise the LCD */
TSLCDRst();
TSLCDInit();
setBitBL;
/* TFT Home Display */
TSLCDFillRect(0,TS_SIZE_X-1,0,TS_SIZE_Y-1,TS_COL_AQUA,TS_MODE_NORMAL);
TSLCDFillRect(0,TS_SIZE_X-1,120,200,TS_COL_YELLOW,TS_MODE_NORMAL);
TSLCDSetFontColor(TS_COL_RED);
TSLCDPrintStr(4,0,"Tiva Launchpad Based .BMP Image Display ",TS_MODE_NORMAL);
TSLCDPrintStr(5,0," TI-CEPD, NSIT ",TS_MODE_NORMAL);
TSLCDShowPic(157,175,218,236,smile,TS_MODE_FULL);
while(1)
{
while(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)!=0);
SysCtlDelay(SysCtlClockGet()/100);
flag1++;
flag2=0;
if(flag1==8)
flag1=1;
if(flag2==0)
{
//Opening test1.bmp
if(flag1==1)
{
rc=f_open(&fil,"test1.bmp",FA_OPEN_EXISTING|FA_WRITE|FA_READ);
SysCtlDelay(SysCtlClockGet()/100);
// UARTprintf("Test1::::\n");
if(rc!=FR_OK)
{
UARTprintf("2.rc=%d\n ERROR OPEN!!!\n",rc);
}
}
//Opening test2.bmp
else if((flag1==2)&&(flag2==0))
{
rc=f_open(&fil,"test2.bmp",FA_OPEN_EXISTING|FA_WRITE|FA_READ);
SysCtlDelay(SysCtlClockGet()/100);
// UARTprintf("Test2::::\n");
if(rc!=FR_OK)
{
UARTprintf("2.rc=%d\n ERROR OPEN!!!\n",rc);
}
}
//Opening test3.bmp
else if((flag1==3)&&(flag2==0))
{
rc=f_open(&fil,"test3.bmp",FA_OPEN_EXISTING|FA_WRITE|FA_READ);
SysCtlDelay(SysCtlClockGet()/100);
// UARTprintf("Test3::::\n");
if(rc!=FR_OK)
{
UARTprintf("2.rc=%d\n ERROR OPEN!!!\n",rc);
}
}
//Opening test4.bmp
else if((flag1==4)&&(flag2==0))
{
rc=f_open(&fil,"test4.bmp",FA_OPEN_EXISTING|FA_WRITE|FA_READ);
SysCtlDelay(SysCtlClockGet()/100);
// UARTprintf("Test4::::\n");
if(rc!=FR_OK)
{
UARTprintf("2.rc=%d\n ERROR OPEN!!!\n",rc);
}
}
//Opening test5.bmp
else if((flag1==5)&&(flag2==0))
{
rc=f_open(&fil,"test5.bmp",FA_OPEN_EXISTING|FA_WRITE|FA_READ);
SysCtlDelay(SysCtlClockGet()/100);
// UARTprintf("Test4::::\n");
if(rc!=FR_OK)
{
UARTprintf("2.rc=%d\n ERROR OPEN!!!\n",rc);
}
}
//Opening test6.bmp
else if((flag1==6)&&(flag2==0))
{
rc=f_open(&fil,"test6.bmp",FA_OPEN_EXISTING|FA_WRITE|FA_READ);
SysCtlDelay(SysCtlClockGet()/100);
// UARTprintf("Test4::::\n");
if(rc!=FR_OK)
{
UARTprintf("2.rc=%d\n ERROR OPEN!!!\n",rc);
}
}
//Opening test7.bmp
else if((flag1==7)&&(flag2==0))
{
rc=f_open(&fil,"test7.bmp",FA_OPEN_EXISTING|FA_WRITE|FA_READ);
SysCtlDelay(SysCtlClockGet()/100);
// UARTprintf("Test4::::\n");
if(rc!=FR_OK)
{
UARTprintf("2.rc=%d\n ERROR OPEN!!!\n",rc);
}
}
//Setting background colour
TSLCDFillRect(0,TS_SIZE_X-1,0,TS_SIZE_Y-1,TS_COL_AQUA,TS_MODE_NORMAL);
//Printing Image data
rc=f_read(&fil,&dummy,10, &br);
//Reading bmp offset address 10 or 0xA
rc=f_read(&fil,&addr,4, &br);
// UARTprintf("address::%04d\n",addr);
rc=f_read(&fil,&dummy,4, &br);
//Reading Width at address 18 or 0x12
rc=f_read(&fil,&width,4, &br);
// UARTprintf("width::%04d\n",width);
//Reading height at address 22 or 0x16
rc=f_read(&fil,&height,4, &br);
// UARTprintf("height::%04d\n",height);
rc=f_read(&fil,&dummy,4, &br);
//Reading compression method of image at address 30 or 0x1E
rc=f_read(&fil,&c_method,4, &br);
// UARTprintf("Compression method::%04d\n",c_method);
rc=f_read(&fil,&dummy,addr-34, &br);
//Finding the number of bytes for padding
remainder=(width*3)%4;
if(remainder!=0)
{
remainder=4-remainder;
}
// UARTprintf("dummy bytes::%04d\n",remainder);
//Setting the offset to display the image in centre
_height=120+height/2;
//Reading Bitmap data at address::54
for(j=1;j<=height;j++)
{
for(i=1;i<=width;i++)
{
rc=f_read(&fil,&pix1,1, &br);
rc=f_read(&fil,&pix2,1, &br);
rc=f_read(&fil,&pix3,1, &br);
_pix1=pix1/8;
_pix2=pix2/4;
_pix3=pix3/8;
/* UARTprintf("blue::%04d\n",pix1);
UARTprintf("blue::%04d\n",_pix1<<11);
UARTprintf("green::%06d\n",pix2);
UARTprintf("green::%06d\n",_pix2<<5);
UARTprintf("red::%04d\n",pix3);
UARTprintf("red::%04d\n",_pix3);
*/
tft_pix=(_pix1<<11)+(_pix2<<5)+_pix3;
// UARTprintf("tft pix::%04d\n",tft_pix);
pix[i-1]=tft_pix;
}
TSLCDShowPic(160-(width/2),159+(width/2),_height-j,_height-j,pix,TS_MODE_FULL);
rc=f_read(&fil,&dummy,remainder, &br);
}
rc = f_close(&fil);
flag2=1;
}
}
return 0;
}
//This configures the Systick to interrupt every mili-second
void SysTickbegin(){
SysTickPeriodSet(80000);
SysTickIntRegister(SycTickInt);
SysTickIntEnable();
SysTickEnable();
}
// Functions
void SAD_Initialize(DriverRegisters* sadreg, role_t setRole, unsigned short setBaud)
{
#ifdef SAD_DEBUG
RIT128x96x4Init(1000000);
#endif
// initializing these values is messy but works for now
sadreg->hs_baud.validbauds[0] = 1200;
sadreg->hs_baud.validbauds[1] = 2400;
sadreg->hs_baud.validbauds[2] = 9600;
sadreg->hs_baud.validbauds[3] = 38400;
// Initialize global flags and vars
//UARTRX_FLAG = 0;
//SYSTICKINT_FLAG = 0;
//GLOBALTIME.hours = 0;
//GLOBALTIME.mins = 0;
//GLOBALTIME.seconds = 0;
//GLOBALTIME.milisecs = 0;
// set relevent structure attributes based on provided parameters
sadreg->role = setRole;
sadreg->txbaud = setBaud;
// Based on the role, set the initial state for the state machine
//sadreg->state = (sadreg->role == TXER) ? HANDSHAKE_TX : HANDSHAKE_RX;
// Initialize the hand shake counter to 0
//sadreg->hs_cnt = 0;
// Initialize the circle buffer
//init_cbuff(&sadreg->circbuf);
SAD_timerinit(sadreg);
// Initialize rx baud to 0
//sadreg->rxbaud = 0;
// Initialize hand shake baude pointer
//sadreg->hs_baud.currentbaudchoice = 0;
// Initialize tx baud to first element in valid baud rates array
//sadreg->txbaud = sadreg->hs_baud.validbauds[sadreg->hs_baud.currentbaudchoice];
// Use Systick timer
SysTickIntRegister(&SysTickTimerHandler);
SysTickPeriodSet(sadreg->timer.limit); // set to rollover every 1ms
SysTickIntEnable();
SysTickEnable();
// Initialize HW Timer
/* SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); */
/* TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); */
/* TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet()); */
/* IntEnable(INT_TIMER0A); */
/* TimerEnable(TIMER0_BASE, TIMER_A); */
// Initialize UART0
// UART0_TX : PA1
// UART0_RX : PA0
// Enable UART Peripherals
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
// 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);
// Initialize UART1
// UART1_TX : PD3
// UART1_RX : PD2
// disable fifos
// Enable UART Peripherals
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
// Set GPIO A0 and A1 as UART pins.
GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_2 | GPIO_PIN_3);
// Configure the UART for SADreg baud, 8-N-1 operation.
UARTConfigSetExpClk(UART1_BASE, SysCtlClockGet(), sadreg->txbaud,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
// Disable fifos, fifo is of depth 1,
//UARTFIFODisable(UART1_BASE);
// Enable the UART interrupt.
IntEnable(INT_UART1);
UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT);
// Enable processor interrupts.
IntMasterEnable();
}
//
// Main - It performs initialization, then runs a command processing loop to
// read commands from the console.
//
int
main(void)
{
int nStatus;
FRESULT fresult;
//
// Set the clocking to run from the PLL at 50MHz
//
SysCtlClockSet(SYSCTL_OSCSRC_OSC2 | SYSCTL_PLL_ENABLE | SYSCTL_IMULT(10) |
SYSCTL_SYSDIV(2));
SysCtlAuxClockSet(SYSCTL_OSCSRC_OSC2 | SYSCTL_PLL_ENABLE |
SYSCTL_IMULT(12) | SYSCTL_SYSDIV(2)); //60 MHz
#ifdef _FLASH
//
// Copy time critical code and Flash setup code to RAM
// This includes the following functions: InitFlash_Bank0();
// The RamfuncsLoadStart, RamfuncsLoadSize, and RamfuncsRunStart
// symbols are created by the linker. Refer to the device .cmd file.
//
memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
//
// Call Flash Initialization to setup flash waitstates
// This function must reside in RAM
//
InitFlash_Bank0();
#endif
//
// Initialize interrupt controller and vector table
//
InitPieCtrl();
InitPieVectTable();
//
// Set the system tick to fire 100 times per second.
//
SysTickInit();
SysTickPeriodSet(SysCtlClockGet(SYSTEM_CLOCK_SPEED) / 100);
SysTickIntRegister(SysTickHandler);
SysTickIntEnable();
SysTickEnable();
//
// Enable Interrupts
//
IntMasterEnable();
//
// Configure UART0 for debug output.
//
ConfigureUART();
//
// Print hello message to user.
//
UARTprintf("\n\nSD Card Example Program\n");
UARTprintf("Type \'help\' for help.\n");
//
// Mount the file system, using logical disk 0.
//
fresult = f_mount(0, &g_sFatFs);
if(fresult != FR_OK)
{
UARTprintf("f_mount error: %s\n", StringFromFresult(fresult));
return(1);
}
//
// Enter an (almost) infinite loop for reading and processing commands from
// the user.
//
while(1)
{
//
// Print a prompt to the console. Show the CWD.
//
UARTprintf("\n%s> ", g_cCwdBuf);
//
// Get a line of text from the user.
//
UARTgets(g_cCmdBuf, sizeof(g_cCmdBuf));
//
// Pass the line from the user to the command processor.
// It will be parsed and valid commands executed.
//
nStatus = CmdLineProcess(g_cCmdBuf);
//
// Handle the case of bad command.
//
if(nStatus == CMDLINE_BAD_CMD)
{
UARTprintf("Bad command!\n");
}
//
// Handle the case of too many arguments.
//
else if(nStatus == CMDLINE_TOO_MANY_ARGS)
{
UARTprintf("Too many arguments for command processor!\n");
}
//
// Otherwise the command was executed. Print the error
// code if one was returned.
//
else if(nStatus != 0)
{
UARTprintf("Command returned error code %s\n",
StringFromFresult((FRESULT)nStatus));
}
}
}
int
main(void)
{
char stringbuffer[17];
int distance = 0;
// Enable lazy 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_FPULazyStackingEnable();
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_EEPROM0); //This wasn't clear at all. Note to self, everything needs enabling on this chip.
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_HIBERNATE);
ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, WAKEPIN);
ROM_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, REEDPIN);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, V5POWER);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, V3POWER);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, SERVO);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
// ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3);
ROM_GPIOPinWrite(GPIO_PORTE_BASE, V3POWER, 0xFF);
#ifdef EASYOPEN
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_0);
#endif
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
GPIOPinConfigure(GPIO_PC6_U3RX);
GPIOPinConfigure(GPIO_PC7_U3TX);
ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_6 | GPIO_PIN_7);
ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), GPSBAUD,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
ROM_UARTConfigSetExpClk(UART3_BASE, ROM_SysCtlClockGet(), GPSBAUD,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
ROM_IntEnable(INT_UART0);
ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
ROM_IntEnable(INT_UART3);
ROM_UARTIntEnable(UART3_BASE, UART_INT_RX | UART_INT_RT);
SysTickPeriodSet(SysCtlClockGet()/10000);
SysTickIntRegister(&ServoDriver);
SysTickIntEnable();
SysTickEnable();
ROM_IntMasterEnable();
GPIOIntTypeSet(GPIO_PORTA_BASE, REEDPIN, GPIO_FALLING_EDGE);
GPIOPinIntClear(GPIO_PORTA_BASE, REEDPIN);
GPIOPinIntEnable(GPIO_PORTA_BASE, REEDPIN);
IntEnable(INT_GPIOA);
// while(1){}
/* SysCtlDelay(SysCtlClockGet()/1000);//Make sure the servo is going to get a pulse soon.
ROM_GPIOPinWrite(GPIO_PORTE_BASE, V5POWER, 0xFF); //Turn on the 5V power to LCD + servo.
SysCtlDelay(SysCtlClockGet()/1000);//Make sure the servo is going to get a pulse soon.*/
EEPROMInit();
initLCD();
LCDCommand(0x0c);
#ifdef LOOPBACKUART
while(1){}
#endif
#ifdef FIRSTRUN //First run, sets the eeprom to have as many tries as is desired.
EEPROMMassErase();
EEPROMProgram(&initialNumTries,eepromAddress,sizeof(initialNumTries));
LCDWriteText("Setup Complete. ", 0, 0);
LCDWriteText("Reflash Firmware", 1, 0);
while (1){} //Don't want to do anything else now.
#endif
EEPROMRead(&numTrieslong,eepromAddress,sizeof(numTrieslong));
// numTries=(int)numTrieslong;
// openLock();
// numTrieslong=0;
if (numTrieslong > initialNumTries-3) //Has already opened once, so just open as needed if stuck.
{
openLock();
numTrieslong--;
EEPROMProgram(&numTrieslong,eepromAddress,sizeof(numTrieslong)); //Decrement EEPROM counter.
}
else
{
distance = getDistance();
if(distance==99999){ //No fix :/
LCDWriteText("Location unknown", 0, 0);
LCDWriteText("Take me outside ", 1, 0);
SysCtlDelay(SysCtlClockGet()); //Waits 3 seconds.
}
else if (distance>NEARENOUGH) //Valid fix, too far away.
{
if ((int)numTrieslong>0) //Any attempts remaining?
{
usnprintf(stringbuffer,17,"Distance: %4dm ",distance);
LCDWriteText(stringbuffer, 0, 0);
numTrieslong--;
// numTries=(int)numTrieslong;
EEPROMProgram(&numTrieslong,eepromAddress,sizeof(numTrieslong)); //Decrement EEPROM counter.
usnprintf(stringbuffer,17,"%2d Attempts left",(int)numTrieslong);
LCDWriteText(stringbuffer, 1, 0);
SysCtlDelay(SysCtlClockGet()*2);
}
else
{
LCDWriteText("Oh dear... ", 0, 0); //Not really sure what to do, hopefully this code never runs.
LCDWriteText("Opening anyway. ", 1, 0);
// numTrieslong=initialNumTries+1;
// EEPROMProgram(&numTrieslong,eepromAddress,sizeof(initialNumTries)); //Set to big value
SysCtlDelay(10*SysCtlClockGet()/3);
openLock();
}
}
else //Found the location!
{
openLock();
numTrieslong=initialNumTries+1;
//numTries=(int)numTrieslong;
EEPROMProgram(&numTrieslong,eepromAddress,sizeof(initialNumTries)); //Lock will now open straight away.
}
}
// BLINK(RED);
HibernateEnableExpClk(SysCtlClockGet());
HibernateGPIORetentionEnable(); //Enables GPIO retention after wake from hibernate.
HibernateClockSelect(HIBERNATE_CLOCK_SEL_RAW);
HibernateWakeSet(HIBERNATE_WAKE_PIN);
HibernateIntRegister(&HibernateInterrupt);
HibernateIntEnable(HIBERNATE_INT_PIN_WAKE);
//BLINK(BLUE);
ROM_GPIOPinWrite(GPIO_PORTE_BASE, V5POWER, 0); //GPIO pins keep state on hibernate, so make sure to power everything else down.
ROM_GPIOPinWrite(GPIO_PORTE_BASE, V3POWER, 0); //GPIO pins keep state on hibernate, so make sure to power everything else down.
ROM_GPIOPinWrite(GPIO_PORTB_BASE, RS|E|D4|D5|D6|D7, 0xFF); //Pull all data pins to LCD high so we're not phantom powering it through ESD diodes.
ROM_GPIOPinWrite(GPIO_PORTF_BASE, SERVO, 0xFF); //Likewise for the servo
SysCtlDelay(SysCtlClockGet()/6);
HibernateRequest();// we want to be looping'n'shit.
while(1){} //Lalala, I'm a sleeping right now.
}
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)
{
}
}
/**********************************************************************************************
* Main
*********************************************************************************************/
void main(void) {
//After tomorrow's test flight. FOR THE LOVE OF GOD MOVE THESE INITALIZATIONS TO FUNCTIONS
/**********************************************************************************************
* Local Variables
*********************************************************************************************/
unsigned long ultrasonic = 0;
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
FPULazyStackingEnable();
//Set the clock speed to 80MHz aka max speed
SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
/*unsigned long test[2];
test[0] = 180;
test[1] = 10;
short bob[1];
bob[0] = ((char)test[0]<<8)|(char)test[1];
float jimmy = (short)(((char)test[0]<<8)|(char)test[1]);
jimmy /= 26;*/
/**********************************************************************************************
* Peripheral Initialization Awake
*********************************************************************************************/
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //Turn on GPIO communication on F pins for switches
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); //Turn on GPIO for ADC
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); //Turn on GPIO for the PWM comms
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); //Turn on GPIO for LED test
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); //Turn on GPIO for UART
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); //Turn on Timer for PWM
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); //Turn on Timer for PWM
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER2); //Turn on Timer for PWM
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER3); //Turn on Timer for PWM
SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C1); //Turn on I2C communication I2C slot 0
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2); //Turn on the UART com
SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG); //Turn on the watchdog timer. This is a risky idea but I think it's for the best.
/**********************************************************************************************
* Peripheral Initialization Sleep
*********************************************************************************************/
/*SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOF); //This sets what peripherals are still enabled in sleep mode while UART would be nice, it would require the clock operate at full speed which is :P
SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_TIMER0);
SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_TIMER1);
SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_TIMER2);
SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_TIMER3);
SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_SSI0);
SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_I2C1);
SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_ADC);
SysCtlPeripheralClockGating(true); //I'm not sure about this one maybe remove it
*/
/**********************************************************************************************
* PWM Initialization
*********************************************************************************************/
SysCtlDelay((SysCtlClockGet() / (1000 * 3))*100); //This shouldn't be needed will test to remove
//PWM pin Setup
//PWM 0 on GPIO PB6, PWM 1 on pin 4... etc
GPIOPinConfigure(GPIO_PB6_T0CCP0); //Pitch - yaw +
GPIOPinConfigure(GPIO_PB4_T1CCP0); //Pitch + yaw +
GPIOPinConfigure(GPIO_PB0_T2CCP0); //Roll - yaw -
GPIOPinConfigure(GPIO_PB2_T3CCP0); //Roll + yaw -
GPIOPinTypeTimer(GPIO_PORTB_BASE, (GPIO_PIN_6|GPIO_PIN_4|GPIO_PIN_0|GPIO_PIN_2));
//Prescale the timers so they are slow enough to work with the ESC
TimerPrescaleSet(TIMER0_BASE,TIMER_A,2);
TimerPrescaleSet(TIMER1_BASE,TIMER_A,2);
TimerPrescaleSet(TIMER2_BASE,TIMER_A,2);
TimerPrescaleSet(TIMER3_BASE,TIMER_A,2);
//Basic LED Out Test Not sure why this is here look into This just turns on an LED that I don't have plugged in. should remove later
GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_3);
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_3,0xFF);
//GPIOPinTypeGPIOOutputOD(GPIO_PORTB_BASE,GPIO_PIN_0);
//Timers Setup for PWM and the load for the countdown
TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_PWM);
TimerLoadSet(TIMER0_BASE, TIMER_A, ulPeriod -1);
TimerConfigure(TIMER1_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_PWM);
TimerLoadSet(TIMER1_BASE, TIMER_A, ulPeriod -1);
TimerConfigure(TIMER2_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_PWM);
TimerLoadSet(TIMER2_BASE, TIMER_A, (ulPeriod -1));
TimerConfigure(TIMER3_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_PWM);
TimerLoadSet(TIMER3_BASE, TIMER_A, ulPeriod -1);
//TimerPrescaleSet(TIMER2_BASE, TIMER_A, extender1);
//TimerLoadSet(TIMER2_BASE, TIMER_A, period1);
//Set the match which is when the thing will pull high
TimerMatchSet(TIMER0_BASE, TIMER_A, 254); //Duty cycle = (1-%desired)*1000 note this means this number is percent low not percent high
TimerMatchSet(TIMER1_BASE, TIMER_A, 254);
TimerMatchSet(TIMER2_BASE, TIMER_A, 254);
TimerMatchSet(TIMER3_BASE, TIMER_A, 254);
//TimerPrescaleMatchSet(TIMER2_BASE, TIMER_A, extender2);
//TimerMatchSet(TIMER2_BASE, TIMER_A, period2);
//Enable the timers
TimerEnable(TIMER0_BASE, TIMER_A);
TimerEnable(TIMER1_BASE, TIMER_A);
TimerEnable(TIMER2_BASE, TIMER_A);
TimerEnable(TIMER3_BASE, TIMER_A);
/**********************************************************************************************
* onboard Chip interrupt Initialization
*********************************************************************************************/
//These two buttons are used to reset the bluetooth module in case of disconnection
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); //RGB LED's
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x00);
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD; //Sw1 (PF4) is unaviable unless you make it only a GPIOF input via these commands
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) = 0x1;
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4); //Onboard buttons (PF0=Sw2,PF4=Sw1
GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0|GPIO_PIN_4, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); //This will make the buttons falling edge (a press pulls them low)
//void (*functionPtr)(void) = &onBoardInteruptHandle;
GPIOPortIntRegister(GPIO_PORTF_BASE, onBoardInteruptHandle); //set function to handle interupt
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4,GPIO_FALLING_EDGE); //Set the interrupt as falling edge
GPIOPinIntEnable(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4); //Enable the interrupt
//IntMasterEnable();
IntEnable(INT_GPIOF);
/**********************************************************************************************
* UART Initialization
*********************************************************************************************/
//Unlock PD7
HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD;
HWREG(GPIO_PORTD_BASE + GPIO_O_CR) = 0x80;
GPIOPinConfigure(GPIO_PD7_U2TX); //Set PD7 as TX
GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_7);
GPIOPinConfigure(GPIO_PD6_U2RX); //Set PD6 as RX
GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_6);
UARTConfigSetExpClk(UART2_BASE,SysCtlClockGet(),115200,UART_CONFIG_WLEN_8|UART_CONFIG_STOP_ONE|UART_CONFIG_PAR_NONE); //I believe the Xbee defaults to no parity I do know it's 9600 baud though, changed to 115200 for bluetooth reasons
UARTFIFOLevelSet(UART2_BASE,UART_FIFO_TX1_8,UART_FIFO_RX1_8); //Set's how big the fifo needs to be in order to call the interrupt handler, 2byte
UARTIntRegister(UART2_BASE,Uart2IntHandler); //Regiester the interrupt handler
UARTIntClear(UART2_BASE, UART_INT_TX | UART_INT_RX); //Clear the interrupt
UARTIntEnable(UART2_BASE, UART_INT_TX | UART_INT_RX); //Enable the interrupt to trigger on both TX and RX event's. Could possibly remove TX
UARTEnable(UART2_BASE); //Enable UART
IntEnable(INT_UART2); //Second way to enable handler not sure if needed using anyway
/**********************************************************************************************
* I2C Initialization
*********************************************************************************************/
//Serious credit to the man who made the Arduino version of this. he gave me addresses and equations. Sadly Arduino obfuscates what really is happening
//Link posted on blog page
//gyro address = 0x68 not 0x69
GPIOPinConfigure(GPIO_PA7_I2C1SDA);
GPIOPinTypeI2C(GPIO_PORTA_BASE, GPIO_PIN_7); //Set GPA7 as SDA
GPIOPinConfigure(GPIO_PA6_I2C1SCL);
GPIOPinTypeI2CSCL(GPIO_PORTA_BASE, GPIO_PIN_6); //Set GPA6 as SCL
I2CMasterInitExpClk(I2C1_MASTER_BASE,SysCtlClockGet(),false); //I think it operates at 100kbps
I2CMasterEnable(I2C1_MASTER_BASE);
//Initalize the accelerometer Address = 0x53
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x02);
UARTSend(0xAB);
I2CTransmit(0x53,0x2D,0x00);
I2CTransmit(0x53,0x2D,0x10);
I2CTransmit(0x53,0x2D,0x08);
//Initalize the gyroscope Address = 0x68
I2CTransmit(0x68,0x3E,0x00);
I2CTransmit(0x68,0x15,0x07);
I2CTransmit(0x68,0x16,0x1E);
I2CTransmit(0x68,0x17,0x00);
UARTSend(0xAC);
/**********************************************************************************************
* SysTick Initialization
*********************************************************************************************/
SysTickIntRegister(SysTickIntHandler);
SysTickIntEnable();
SysTickPeriodSet((SysCtlClockGet() / (1000 * 3))*timeBetweenCalculations); //This sets the period for the delay. the last num is the num of milliseconds
SysTickEnable();
/**********************************************************************************************
* Watchdog Initialization
*********************************************************************************************/
WatchdogReloadSet(WATCHDOG_BASE, 0xFEEFEEFF); //Set the timer for a reset
WatchdogIntRegister(WATCHDOG_BASE,WatchdogIntHandler); //Enable interrupt
WatchdogIntClear(WATCHDOG_BASE);
WatchdogIntEnable(WATCHDOG_BASE);
WatchdogEnable(WATCHDOG_BASE); //Enable the actual timer
IntEnable(INT_WATCHDOG);
/**********************************************************************************************
* Preflight motor inialization maybe not necessary not going to test
*********************************************************************************************/
PWMSet(TIMER0_BASE,998);
PWMSet(TIMER1_BASE,998);
PWMSet(TIMER2_BASE,998);
PWMSet(TIMER3_BASE,998);
recievedCommands[0]=253;
SysCtlDelay((SysCtlClockGet() / (1000 * 3))*100); //Very important to ensure motor see's a start high (998 makes 0 sense but it works so shhhh don't tell anyone)
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x06);
while(1){
WatchdogReloadSet(WATCHDOG_BASE, 0xFEEFEEFF); //Feed the dog a new time
//UARTSend(recievedCommands[0]);
//SysCtlDelay(50000);
//Set 4 PWM Outputs
//Get Acc data
I2CRead(0x53,0x32,6,quadAcc); //Address blah blah 2 for each axis
rawAccToG(quadAcc,RwAcc);
/*GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x04); //Blue
//Get Gyro data
/**************************************
Gyro ITG-3200 I2C
registers:
temp MSB = 1B, temp LSB = 1C
x axis MSB = 1D, x axis LSB = 1E
y axis MSB = 1F, y axis LSB = 20
z axis MSB = 21, z axis LSB = 22
*************************************/
I2CRead(0x68,0x1B,8,quadGyro); //Address blah blah 2 for each axis + 2 for temperature. why. because why not
rawGyroToDegsec(quadGyro,Gyro_ds);
//GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x02); //Red
//Get the actual angles in XYZ. Store them in RwEst
//getInclination(RwAcc, RwEst, RwGyro, Gyro_ds, Awz);
//After this function is called RwEst will hold the roll pitch and yaw
//RwEst will be returned in PITCH, ROLL, YAW 0, 1, 2 remember this order very important. Little obvious but yaw is worthless
/*if(RwEst[1]>0.5){
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x06); //Red Blue, Correct data read in
}else{
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x0A); //Red Green, The correct data is not there
}*/
/*GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x06); //Red Blue, Correct data read in
float test=RwAcc[0]*100; //These two commands work
char temp = (char)test;
//UARTSend((char)(RwAcc[0])*100); //This one does not
UARTSend(temp);
//UARTSend((char)(RwAcc[1])*100);
UARTSend(0xAA);
SysCtlDelay((SysCtlClockGet() / (1000 * 3))*1);
*/
}
}
int main(void)
{
long dir;
unsigned long vel, pos;
//
// Set the clocking to run directly from the crystal.
//
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
//
// Set up low level I/O for printf()
//
llio_init(115200);
//
// Set up GPIO for LED
//
LED_INIT();
//
// Set up QEI peripheral
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_QEI);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
GPIOPinTypeQEI(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_6);
QEIConfigure(QEI0_BASE, (QEI_CONFIG_CAPTURE_A_B | QEI_CONFIG_NO_RESET |
QEI_CONFIG_QUADRATURE | QEI_CONFIG_NO_SWAP), 0xffffffff);
QEIVelocityConfigure(QEI0_BASE, QEI_VELDIV_1, SysCtlClockGet() / 10);
QEIEnable(QEI0_BASE);
QEIVelocityEnable(QEI0_BASE);
//
// Set up GPIO for encoder push switch
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_5);
GPIOPadConfigSet(GPIO_PORTC_BASE, GPIO_PIN_5, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
GPIOIntTypeSet(GPIO_PORTC_BASE, GPIO_PIN_5, GPIO_FALLING_EDGE);
GPIOPortIntRegister(GPIO_PORTC_BASE, SW_IntHandler);
GPIOPinIntEnable(GPIO_PORTC_BASE, GPIO_PIN_5);
//
// Set up the period for the SysTick timer.
//
SysTickPeriodSet(SysCtlClockGet() / 10); // 10Hz SysTick timer
//
// Enable the SysTick Interrupt.
//
SysTickIntEnable();
SysTickIntRegister(SysTickIntHandler);
//
// Enable SysTick.
//
SysTickEnable();
printf("\r\nEncoder example\r\n");
//
// Loop forever.
//
while(1)
{
SysCtlSleep(); // sleep here till interrupt
LED_TOGGLE();
dir = QEIDirectionGet(QEI0_BASE);
vel = QEIVelocityGet(QEI0_BASE);
pos = QEIPositionGet(QEI0_BASE);
printf("%d,%d,%d\r\n", dir, vel, pos);
}
}
//*****************************************************************************
//
//! Main function for uDMA Application
//!
//! \param none
//!
//! \return none
//!
//*****************************************************************************
void
main()
{
static unsigned long ulPrevSeconds;
static unsigned long ulPrevUARTCount = 0;
unsigned long ulXfersCompleted;
unsigned long ulBytesAvg=0;
int iCount=0;
//
// Initailizing the board
//
BoardInit();
//
// Muxing for Enabling UART_TX and UART_RX.
//
PinMuxConfig();
//
// Initialising the Terminal.
//
InitTerm();
//
// Display Welcome Message
//
DisplayBanner();
//
// SysTick Enabling
//
SysTickIntRegister(SysTickHandler);
SysTickPeriodSet(SYSTICK_RELOAD_VALUE);
SysTickEnable();
//
// uDMA Initialization
//
UDMAInit();
//
// Register interrupt handler for UART
//
MAP_UARTIntRegister(UARTA0_BASE,UART0IntHandler);
UART_PRINT("Completed DMA Initialization \n\r\n\r");
//
// Auto DMA Transfer
//
UART_PRINT("Starting Auto DMA Transfer \n\r");
InitSWTransfer();
//
// Scatter Gather DMA Transfer
//
UART_PRINT("Starting Scatter Gather DMA Operation\n\r");
InitSGTransfer();
while(!Done){}
MAP_UtilsDelay(80000000);
//
// Ping Pong UART Transfer
//
InitUART0Transfer();
//
// Remember the current SysTick seconds count.
//
ulPrevSeconds = g_ulSeconds;
while(1)
{
//
// Check to see if one second has elapsed. If so, the make some
// updates.
//
if(g_ulSeconds != ulPrevSeconds)
{
uiCount++;
//
// Remember the new seconds count.
//
ulPrevSeconds = g_ulSeconds;
//
// Calculate how many UART transfers have occurred since the last
// second.
//
ulXfersCompleted = (g_ulRxBufACount + g_ulRxBufBCount -
ulPrevUARTCount);
//
// Remember the new UART transfer count.
//
ulPrevUARTCount = g_ulRxBufACount + g_ulRxBufBCount;
//
// Compute how many bytes were transferred by the UART.
//
ulBytesTransferred[iCount] = (ulXfersCompleted * UART_RXBUF_SIZE );
iCount++;
//
// Print a message to the display showing the memory transfer rate.
//
if(UARTDone)
{
MAP_PRCMPeripheralReset(PRCM_UARTA0);
MAP_PRCMPeripheralClkEnable(PRCM_UARTA0,PRCM_RUN_MODE_CLK);
UARTConfigSetExpClk(CONSOLE,SYSCLK, UART_BAUD_RATE,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
}
}
//
// See if we have run long enough and exit the loop if so.
//
if(g_ulSeconds >= 6 && UARTDone)
{
break;
}
}
//
// Compute average Bytes Transfer Rate for the past 5 seconds
//
for(iCount=1;iCount<=5;iCount++)
{
ulBytesAvg += ulBytesTransferred[iCount];
}
ulBytesAvg=ulBytesAvg/5;
UART_PRINT("\n\r");
UART_PRINT("\n\r");
UART_PRINT("\n\rCompleted Ping Pong Transfer from Memory to UART "
"Peripheral \n\r");
UART_PRINT(" \n\rTransfer Rate is %lu Bytes/Sec \n\r", ulBytesAvg);
UART_PRINT("\n\rTest Ended\n\r");
return ;
}
void sysTickInit(void){
SysTickEnable();
SysTickIntEnable();
SysTickIntRegister(sysTickCallBack);
SysTickPeriodSet(0xffff);
}
