int32_t main()
{
STR_UART_T sParam;
UNLOCKREG();
DrvSYS_Open(50000000);
LOCKREG();
DrvGPIO_InitFunction(E_FUNC_UART0); // Set UART pins
/* UART Setting */
sParam.u32BaudRate = 9600;
sParam.u8cDataBits = DRVUART_DATABITS_8;
sParam.u8cStopBits = DRVUART_STOPBITS_1;
sParam.u8cParity = DRVUART_PARITY_NONE;
sParam.u8cRxTriggerLevel= DRVUART_FIFO_1BYTES;
/* Set UART Configuration */
if(DrvUART_Open(UART_PORT0,&sParam) != E_SUCCESS);
DrvUART_EnableInt(UART_PORT0, DRVUART_RDAINT, UART_INT_HANDLE);
init_LCD(); // initialize LCD panel
clear_LCD(); // clear LCD panel
print_Line(0, "Smpl_UART0_HC05"); // print title
while(1)
{
}
//DrvUART_Close(UART_PORT0);
}
void main(void)
{
WDTCTL = WDTPW+WDTHOLD; // Paramos el watchdog timer
init_botons(); // Iniciamos los botones y Leds.
_enable_interrupt(); // Activamos las interrupciones a nivel global del chip
init_LCD(); // Inicializamos la pantalla
init_UCS(); //Inicialitzem UCS
init_UART(); //Inicialitzem UART
halLcdPrintLine( saludo,linea,textstyle);
linea++;
sprintf(cadena,"bID = %d",bID);
halLcdPrintLine( cadena,linea,textstyle);
Encendre_LED();
TxPacket(0xFE, 2, 0x19);
do
{
P1OUT ^= 0x03;
i = 25000;
do {
i--;
}
while (i != 0);
}
while(1);
}
int main(void)
{
init_PM();
init_LCD();
init_Potentiometer();
init_CurrentSensor();
init_INTC();
fill_Display();
set_Velocidad(velocidad);
set_Direccion(direccion);
init_PWM(velocidad,direccion);
while (1)
{
adc_start(&AVR32_ADC);
adc_value_pot = adc_get_value(&AVR32_ADC,EXAMPLE_ADC_POTENTIOMETER_CHANNEL);
adc_start(&AVR32_ADC);
adc_value_current = adc_get_value(&AVR32_ADC,3);
set_Duty_Cycle(adc_value_pot);
set_Current(adc_value_current);
if(bandera ==1){
set_Velocidad(velocidad);
set_Direccion(direccion);
update_PWM(velocidad, direccion);
}
delay_ms(400);
}//WHILE
}//MAIN
int main()
{
DDRB=0xff;
DDRD=0x07;
init_LCD(); // initialization of LCD
_delay_ms(50); // delay of 50 mili seconds
LCD_write_string("A"); // function to print string on LCD
return 0;
}
/* Functions */
int main(void) {
u32 OutputEnableTimeout;
init_SystemClock(); //RCC config
init_Discovery(); //leds & user button
init_TimeBase(); //timebase & clock
init_LCD(); //HD44780 based display
init_UART(&urt2,2);
init_IO();
/* program loop */ //******************************************* main loop
time.fast = actualTime() + FASTINTERVAL;
time.slow = actualTime() + SLOWINTERVAL;
while (1) {
//realtick:
if(gValues.filter.output){
//output enable, timeout restart
OutputEnableTimeout = actualTime() + OUTPUT_TIMEOUT;
GPIO_WriteBit(GPIOC, GPIO_Pin_9, (BitAction)1);
}else if (timeElapsed(OutputEnableTimeout)){
//output disable after timeout
GPIO_WriteBit(GPIOC, GPIO_Pin_9, (BitAction)0);
}
if(timeElapsed(time.fast)){
time.fast += FASTINTERVAL;
//fasttick
fast_Tick();
}
if(timeElapsed(time.slow)){
time.slow += SLOWINTERVAL;
//slowtick
LCD_periodic_update();
slow_Tick();
}
//COMM_DESC * PC_com = &urt2.parent;
/*Ticks*/
//PC_com->Tick(PC_com);
//urt2.Tick(&urt2.parent);
} //end while
} //end main()
void setup()
{
DDRA = 0xFF;
DDRC = 0xE0;;
PORTA = 0x00;
PORTC = 0x00;
init_LCD();
clear_LCD();
write_LCD("Welcome!");
}
/**********************MAIN***********/
void main(void) {
DisableInterrupts;
init();
init_LCD();
init_TSCR(128); //1,2,4,8,16,32,64,128
init_SCI();
EnableInterrupts;
for(;;);
}
int main()
{
init_LCD();
init_Relay();
init_Switch();
init_Buzzer();
init_LCD();
init_PWM();
sei();
while(1)
{
stop();
int ile_petli = 0; //wartosc zadana przez uzytkownika
int dlugosc = 0;
int wait = TAK;
wyswietl_LCD("Start -> OK");
_delay_ms(200);
wait = TAK;
while(wait)
if(bit_is_clear(PIN_SWITCH, SWITCH_OK)) wait = NIE;
dlugosc = get_distance();
ile_petli = ilosc_petli();
wykonaj(ile_petli, dlugosc);
_delay_ms(200);
}
}
void lcd_init()
{
// знакогенератор розм_щується в EEPROM
init_LCD();
delay_ms(10);
setcg(2,arrov);
setcg(1,valve);
setcg(3,up);
setcg(4,dw);
setcg(5,tg);
setcg(6,mg);
setcg(7,grad);
}
int main(int argc, char **argv)
{
const char *filename = std::string("/dev/i2c-0").c_str(); // Name of the port we will be using
int i2c_address = 0x3E; // Address of LCD display
if(init_LCD(filename, i2c_address)) {
printf("initilization error, exiting...\n");
return 1;
}
if (argc>2){
sendStr(argv[1],argv[2]);
} else if (argc==2) {
sendStr(argv[1],"");
} else {
sendStr("","");
}
}
int main() {
Thread * thread;
pc.baud(115200);
pc.printf("\r\nStarting Mbed ...\r\n");
//Initialize the LCD
pc.printf("Initializing LCD ...\r\n");
init_LCD();
printf("Initializing USB Mass Storage ...\r\n");
printf("Inititalizing ethernet ....\r\n");
eth.init(); // Use DHCP
eth.connect();
printf("IP Address is %s\n", eth.getIPAddress());
// After initializing the ethernet interface
// run it in its own thread
printf("Starting blinker thread ...\r\n");
thread = new Thread(led1_thread);
// Start the shell
printf("Starting debug shell ...\r\n");
shell.addCommand("ls", cmd_ls);
shell.addCommand("load", cmd_load);
shell.addCommand("mem", cmd_mem);
shell.addCommand("sensor", cmd_sensor);
shell.start(osPriorityNormal, SHELL_STACK_SIZ, shellStack);
printf("Shell now running!\r\n");
printf("Available Memory : %d\r\n", get_mem());
// Do something logical here
// other than looping
while(1) {
printf("Temperature : %d °C\r\n", htu21d.sample_ctemp());
printf("Humitdity : %d%%\r\n", htu21d.sample_humid());
wait(10);
}
thread->terminate();
delete thread;
}
// == Program Code
int main(int argc, char* argv[]) {
// Initialisations
programState = PROG_STATE_INIT;
init_LCD();
init_ports();
init_EXTI();
init_NVIC();
init_ADC();
init_TIM14();
display(DISP_WELCOME, 0);
programState = PROG_STATE_WAIT_FOR_SW0;
// Infinite loop
while (1) {
__asm("nop");
}
}
int main(void)
{
/* Variables */
uint16_t ad_value = 0;
char ad_value_text[8];
init_LCD();
init_ADC();
DDRD = 0xFF;
PORTD = 0;
while(1)
{
ad_value = read_ADC();
itoa(ad_value,ad_value_text,10);
LCDGotoXY(0,1);
LCDstring((uint8_t*) ad_value_text, (uint8_t) strlen(ad_value_text));
}
}
//====================================================================
// MAIN FUNCTION
//====================================================================
void main (void){
init_LCD();
init_GPIO();
//Get operating CLK freq
RCC_ClocksTypeDef CLK;
RCC_GetClocksFreq(&CLK);
sysclock= (CLK.SYSCLK_Frequency)/((float)(pow(10,6)));
//Sys clocks in MHz
sprintf(lcdstring,"CLK %d MHz",sysclock);
lcd_putstring(lcdstring);
lcd_command(LINE_TWO);
lcd_putstring("Servo Step Test, SW0");
//Init procedure waits for SW0
while(GPIO_ReadInputData(GPIOA)&GPIO_IDR_0){}
lcd_command(CLEAR);
init_ADC();
init_EXTI();
init_USART1();
init_TIM2();
init_TIM3();
init_TIM14();
init_TIM17();
for(;;){
while(TIM3OC2<=3800){
TIM3OC2++;
TIM_SetCompare2(TIM3,TIM3OC2);
for(int x=0;x<=255;x++){
for(int y=0;y<=255;y++){}
}
}
lcd_command(CURSOR_HOME);
sprintf(lcdstring,"ADC:%d ",(int) ADCval);
lcd_putstring(lcdstring);
lcd_command(LINE_TWO);
sprintf(lcdstring,"TIM:%d ",(int) TIM2->CCR3);//TIMcmp);
//TIM_SetCompare2(TIM3,(int)(64000*((0.9+1.1*ADCval/2047.0)/20.0)));
lcd_putstring(lcdstring);
}
} // End of main
void wykonaj (int ile_petli, int dlugosc)
{
int licznik=0;
char ch_liczba[3];
pozycjonowanie();
_delay_ms(500);
relay_on();
_delay_ms(50);
init_LCD();
init_PWM();
_delay_ms(200);
int delay = 370;
if(dlugosc>MIN_DLUGOSC)
delay = delay + (dlugosc-MIN_DLUGOSC)*190;
for (licznik=0; licznik<ile_petli; licznik++)
{
int do_konca = ile_petli-licznik;
gen_char(ch_liczba, &do_konca); //wyswietla ile cykli pozostało do konca naswietlania
wyswietl_LCD(ch_liczba);
kierunek(PRZOD);
_delay_ms(delay); //odleglosc dokad dojadą lampy
stop();
_delay_ms(2000);
pozycjonowanie(); //jezdie do tylu az napotka krancowe
_delay_ms(2000);
}
_delay_ms(1000);
wyswietl_LCD("KONIEC PRACY");
_delay_ms(1000);
relay_off();
beep();
}
void main(void)
{
WDTCTL = WDTPW+WDTHOLD; // Paramos el watchdog timer
init_botons(); // Iniciamos los botones y Leds.
config_P4_LEDS(); // Iniciamos los LEDS del puerto 4
_enable_interrupt(); // Activamos las interrupciones a nivel global del chip
init_LCD(); // Inicializamos la pantalla
write(saludo,linea); //escribimos saludo en la primera linea
linea++; //Aumentamos el valor de linea y con ello pasamos a la linea siguiente
do
{
if (estado_anterior != estado) // Dependiendo el valor del estado se encenderá un LED externo u otro.
{
//clearLine(linea);
sprintf(cadena," estado %02d", estado); // Guardamos en cadena lo siguiente frase: estado "valor del estado"
write(cadena, linea); // Escribimos cadena
estado_anterior = estado; // Actualizamos el valor de estado_anterior, para que no esté siempre escribiendo.
}
halLed_rx_setLed(LED_RX_ALL, OFF);
halLed_rx_setLed(bitled, ON);
if ( estado <= 2 || estado == 5 )
halLed_sx_toggleLed(LED_SX_ALL); //P1OUT^= 0x03; // Encender los LEDS con intermitencia
delay(2); // retraso de aprox 1 segundo
if ( bitled == LED_R8 )
bitled = BIT0;
else
bitled = bitled << 1;
}
while(1);
}
int main()
{
DDRD=0xff;
DDRB=0x07;
_delay_ms(50); // delay of 50 mili seconds
ADC_init(); // initialization of ADC
/*variable init*/
float value;
int temp;
char str[5];
while(1)
{
init_LCD(); // initialization of LCD
value=ADC_read(0); // function to read the Adc value
temp=(value/1023)*5*100; // temp=100*voltage
sprintf(str, "%d", temp); // function to convert int to string
LCD_write_string(str); // function to print string on LCD
_delay_ms(1000); // delay for visual
}
return 0;
}
int main(void) {
DDRA = 0xFF;
DDRF = 0xFF;
PORTA = 0x00;
PORTF = 0x00;
init_LCD();
char* string = "haeri";
while(1) {
LCD_wr_string(0x80, string);
}
return 0;
}
int main()
{
void *buffer1,*buffer2,*buffer3,*buffer4;
unsigned short *image;
unsigned char *grayscale;
unsigned char current_mode;
unsigned char mode;
init_LCD();
init_camera();
vga_set_swap(VGA_QuarterScreen|VGA_Grayscale);
printf("Hello from Nios II!\n");
cam_get_profiling();
buffer1 = (void *) malloc(cam_get_xsize()*cam_get_ysize());
buffer2 = (void *) malloc(cam_get_xsize()*cam_get_ysize());
buffer3 = (void *) malloc(cam_get_xsize()*cam_get_ysize());
buffer4 = (void *) malloc(cam_get_xsize()*cam_get_ysize());
cam_set_image_pointer(0,buffer1);
cam_set_image_pointer(1,buffer2);
cam_set_image_pointer(2,buffer3);
cam_set_image_pointer(3,buffer4);
enable_continues_mode();
init_sobel_arrays(cam_get_xsize()>>1,cam_get_ysize());
do {
if (new_image_available() != 0) {
if (current_image_valid()!=0) {
current_mode = DIPSW_get_value();
mode = current_mode&(DIPSW_SW1_MASK|DIPSW_SW3_MASK|DIPSW_SW2_MASK);
image = (unsigned short*)current_image_pointer();
switch (mode) {
case 0 : transfer_LCD_with_dma(&image[16520],
cam_get_xsize()>>1,
cam_get_ysize(),0);
if ((current_mode&DIPSW_SW8_MASK)!=0) {
vga_set_swap(VGA_QuarterScreen);
vga_set_pointer(image);
}
break;
case 1 : conv_grayscale((void *)image,
cam_get_xsize()>>1,
cam_get_ysize());
grayscale = get_grayscale_picture();
transfer_LCD_with_dma(&grayscale[16520],
cam_get_xsize()>>1,
cam_get_ysize(),1);
if ((current_mode&DIPSW_SW8_MASK)!=0) {
vga_set_swap(VGA_QuarterScreen|VGA_Grayscale);
vga_set_pointer(grayscale);
}
break;
case 2 : conv_grayscale((void *)image,
cam_get_xsize()>>1,
cam_get_ysize());
grayscale = get_grayscale_picture();
sobel_x_with_rgb(grayscale);
image = GetSobel_rgb();
transfer_LCD_with_dma(&image[16520],
cam_get_xsize()>>1,
cam_get_ysize(),0);
if ((current_mode&DIPSW_SW8_MASK)!=0) {
vga_set_swap(VGA_QuarterScreen);
vga_set_pointer(image);
}
break;
case 3 : conv_grayscale((void *)image,
cam_get_xsize()>>1,
cam_get_ysize());
grayscale = get_grayscale_picture();
sobel_x(grayscale);
sobel_y_with_rgb(grayscale);
image = GetSobel_rgb();
transfer_LCD_with_dma(&image[16520],
cam_get_xsize()>>1,
cam_get_ysize(),0);
if ((current_mode&DIPSW_SW8_MASK)!=0) {
vga_set_swap(VGA_QuarterScreen);
vga_set_pointer(image);
}
break;
default: conv_grayscale((void *)image,
cam_get_xsize()>>1,
cam_get_ysize());
grayscale = get_grayscale_picture();
sobel_x(grayscale);
sobel_y(grayscale);
sobel_threshold(128);
grayscale=GetSobelResult();
transfer_LCD_with_dma(&grayscale[16520],
cam_get_xsize()>>1,
cam_get_ysize(),1);
if ((current_mode&DIPSW_SW8_MASK)!=0) {
vga_set_swap(VGA_QuarterScreen|VGA_Grayscale);
vga_set_pointer(grayscale);
}
break;
}
}
}
} while (1);
return 0;
}
/*lint -save -e970 Disable MISRA rule (6.3) checking. */
int main(void)
/*lint -restore Enable MISRA rule (6.3) checking. */
{
/* Write your local variable definition here */
/*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/
PE_low_level_init();
/*** End of Processor Expert internal initialization. ***/
/* Write your code here */
init_LCD();
isReady = 0;
tick_counter = 0;
EInt1_Enable();
buttons[0] = (int*) malloc (3*sizeof(int));
buttons[1] = (int*) malloc (3*sizeof(int));
buttons[2] = (int*) malloc (3*sizeof(int));
buttons[3] = (int*) malloc (3*sizeof(int));
uint8 data, cont = 30, result;
send_string("LCD works");
//char r = 0;
//while (1)
//if ((r = read_keys()) != 0 )
//send_data(r);
for (;;) {
char buffer [16];
/*
int i = 0;
for (i = INTERRUPT_PERIOD; i <= 1000*INTERRUPT_PERIOD; i += 99*INTERRUPT_PERIOD) {
send_cmd(0x01, ceil(1535 / INTERRUPT_PERIOD));
memset(buffer, 0, 16);
sprintf(buffer,"QUAD: %d us", i);
send_string(buffer);
generate_square_wave(i, 3.3);
}
for (i = 10*INTERRUPT_PERIOD; i < 1000*INTERRUPT_PERIOD; i += 99*INTERRUPT_PERIOD) {
send_cmd(0x01, ceil(1535 / INTERRUPT_PERIOD));
memset(buffer, 0, 16);
sprintf(buffer,"TRIAN: %d us", i);
send_string(buffer);
generate_triangular_wave(i, 3.3);
}
for (i = 10*INTERRUPT_PERIOD; i < 1000*INTERRUPT_PERIOD; i += 99*INTERRUPT_PERIOD) {
send_cmd(0x01, ceil(1535 / INTERRUPT_PERIOD));
memset(buffer, 0, 16);
sprintf(buffer,"SIN: %d us", i);
send_string(buffer);
generate_sinoidal_wave(i, 3.3);
}*/
for (;;) {
char wave = read_keys();
switch (wave) {
case '1':
send_cmd(0x01, ceil(1535 / INTERRUPT_PERIOD));
send_string("Onda Quad.");
generate_square_wave(250000, 3.3);
send_cmd(0x01, ceil(1535 / INTERRUPT_PERIOD));
send_string("Fim onda Quad.");
break;
case '2':
send_cmd(0x01, ceil(1535 / INTERRUPT_PERIOD));
send_string("Onda Triang.");
generate_triangular_wave(250000, 3.3);
send_cmd(0x01, ceil(1535 / INTERRUPT_PERIOD));
send_string("Fim onda Triang.");
break;
case '3':
send_cmd(0x01, ceil(1535 / INTERRUPT_PERIOD));
send_string("Onda Senoi.");
generate_sinoidal_wave(250000, 3.3);
send_cmd(0x01, ceil(1535 / INTERRUPT_PERIOD));
send_string("Fim onda Senoi.");
break;
}
}
}
/* For example: for(;;) { } */
/*** Don't write any code pass this line, or it will be deleted during code generation. ***/
/*** RTOS startup code. Macro PEX_RTOS_START is defined by the RTOS component. DON'T MODIFY THIS CODE!!! ***/
#ifdef PEX_RTOS_START
PEX_RTOS_START(); /* Startup of the selected RTOS. Macro is defined by the RTOS component. */
#endif
/*** End of RTOS startup code. ***/
/*** Processor Expert end of main routine. DON'T MODIFY THIS CODE!!! ***/
for(;;){}
/*** Processor Expert end of main routine. DON'T WRITE CODE BELOW!!! ***/
} /*** End of main routine. DO NOT MODIFY THIS TEXT!!! ***/
Void main()
{
int i = 0;
// unlock the system config registers.
SYSCONFIG->KICKR[0] = KICK0R_UNLOCK;
SYSCONFIG->KICKR[1] = KICK1R_UNLOCK;
SYSCONFIG1->PUPD_SEL |= 0x10000000; // change pin group 28 to pullup for GP7[12/13] (LCD switches)
// Initially set McBSP1 pins as GPIO ins
CLRBIT(SYSCONFIG->PINMUX[1], 0xFFFFFFFF);
SETBIT(SYSCONFIG->PINMUX[1], 0x88888880); // This is enabling the McBSP1 pins
CLRBIT(SYSCONFIG->PINMUX[16], 0xFFFF0000);
SETBIT(SYSCONFIG->PINMUX[16], 0x88880000); // setup GP7.8 through GP7.13
CLRBIT(SYSCONFIG->PINMUX[17], 0x000000FF);
SETBIT(SYSCONFIG->PINMUX[17], 0x00000088); // setup GP7.8 through GP7.13
//Rick added for LCD DMA flagging test
GPIO_setDir(GPIO_BANK0, GPIO_PIN8, GPIO_OUTPUT);
GPIO_setOutput(GPIO_BANK0, GPIO_PIN8, OUTPUT_HIGH);
GPIO_setDir(GPIO_BANK0, GPIO_PIN0, GPIO_INPUT);
GPIO_setDir(GPIO_BANK0, GPIO_PIN1, GPIO_INPUT);
GPIO_setDir(GPIO_BANK0, GPIO_PIN2, GPIO_INPUT);
GPIO_setDir(GPIO_BANK0, GPIO_PIN3, GPIO_INPUT);
GPIO_setDir(GPIO_BANK0, GPIO_PIN4, GPIO_INPUT);
GPIO_setDir(GPIO_BANK0, GPIO_PIN5, GPIO_INPUT);
GPIO_setDir(GPIO_BANK0, GPIO_PIN6, GPIO_INPUT);
GPIO_setDir(GPIO_BANK7, GPIO_PIN8, GPIO_OUTPUT);
GPIO_setDir(GPIO_BANK7, GPIO_PIN9, GPIO_OUTPUT);
GPIO_setDir(GPIO_BANK7, GPIO_PIN10, GPIO_OUTPUT);
GPIO_setDir(GPIO_BANK7, GPIO_PIN11, GPIO_OUTPUT);
GPIO_setDir(GPIO_BANK7, GPIO_PIN12, GPIO_INPUT);
GPIO_setDir(GPIO_BANK7, GPIO_PIN13, GPIO_INPUT);
GPIO_setOutput(GPIO_BANK7, GPIO_PIN8, OUTPUT_HIGH);
GPIO_setOutput(GPIO_BANK7, GPIO_PIN9, OUTPUT_HIGH);
GPIO_setOutput(GPIO_BANK7, GPIO_PIN10, OUTPUT_HIGH);
GPIO_setOutput(GPIO_BANK7, GPIO_PIN11, OUTPUT_HIGH);
CLRBIT(SYSCONFIG->PINMUX[13], 0xFFFFFFFF);
SETBIT(SYSCONFIG->PINMUX[13], 0x88888811); //Set GPIO 6.8-13 to GPIOs and IMPORTANT Sets GP6[15] to /RESETOUT used by PHY, GP6[14] CLKOUT appears unconnected
#warn GP6.15 is also connected to CAMERA RESET This is a Bug in my board design Need to change Camera Reset to different IO.
GPIO_setDir(GPIO_BANK6, GPIO_PIN8, GPIO_OUTPUT);
GPIO_setDir(GPIO_BANK6, GPIO_PIN9, GPIO_OUTPUT);
GPIO_setDir(GPIO_BANK6, GPIO_PIN10, GPIO_OUTPUT);
GPIO_setDir(GPIO_BANK6, GPIO_PIN11, GPIO_OUTPUT);
GPIO_setDir(GPIO_BANK6, GPIO_PIN12, GPIO_OUTPUT);
GPIO_setDir(GPIO_BANK6, GPIO_PIN13, GPIO_INPUT);
// on power up wait until Linux has initialized Timer1
while ((T1_TGCR & 0x7) != 0x7) {
for (index=0;index<50000;index++) {} // small delay before checking again
}
USTIMER_init();
// Turn on McBSP1
EVMOMAPL138_lpscTransition(PSC1, DOMAIN0, LPSC_MCBSP1, PSC_ENABLE);
// If Linux has already booted It sets a flag so no need to delay
if ( GET_ISLINUX_BOOTED == 0) {
USTIMER_delay(4*DELAY_1_SEC); // delay allowing Linux to partially boot before continuing with DSP code
}
// init the us timer and i2c for all to use.
I2C_init(I2C0, I2C_CLK_100K);
init_ColorVision();
init_LCD_mem(); // added rick
EVTCLR0 = 0xFFFFFFFF;
EVTCLR1 = 0xFFFFFFFF;
EVTCLR2 = 0xFFFFFFFF;
EVTCLR3 = 0xFFFFFFFF;
init_DMA();
init_McBSP();
init_LADAR();
CLRBIT(SYSCONFIG->PINMUX[1], 0xFFFFFFFF);
SETBIT(SYSCONFIG->PINMUX[1], 0x22222220); // This is enabling the McBSP1 pins
CLRBIT(SYSCONFIG->PINMUX[5], 0x00FF0FFF);
SETBIT(SYSCONFIG->PINMUX[5], 0x00110111); // This is enabling SPI pins
CLRBIT(SYSCONFIG->PINMUX[16], 0xFFFF0000);
SETBIT(SYSCONFIG->PINMUX[16], 0x88880000); // setup GP7.8 through GP7.13
CLRBIT(SYSCONFIG->PINMUX[17], 0x000000FF);
SETBIT(SYSCONFIG->PINMUX[17], 0x00000088); // setup GP7.8 through GP7.13
init_LCD();
LADARps.x = 3.5/12; // 3.5/12 for front mounting
LADARps.y = 0;
LADARps.theta = 1; // not inverted
OPTITRACKps.x = 0;
OPTITRACKps.y = 0;
OPTITRACKps.theta = 0;
for(i = 0;i<LADAR_MAX_DATA_SIZE;i++)
{ LADARdistance[i] = LADAR_MAX_READING; } //initialize all readings to max value.
// ROBOTps will be updated by Optitrack during gyro calibration
// TODO: specify the starting position of the robot
ROBOTps.x = 0; //the estimate in array form (useful for matrix operations)
ROBOTps.y = 0;
ROBOTps.theta = 0; // was -PI: need to flip OT ground plane to fix this
// flag pins
GPIO_setDir(IMAGE_TO_LINUX_BANK, IMAGE_TO_LINUX_FLAG, GPIO_OUTPUT);
GPIO_setDir(OPTITRACKDATA_FROM_LINUX_BANK, OPTITRACKDATA_FROM_LINUX_FLAG, GPIO_OUTPUT);
GPIO_setDir(DATA_TO_LINUX_BANK, DATA_TO_LINUX_FLAG, GPIO_OUTPUT);
GPIO_setDir(DATA_FROM_LINUX_BANK, DATA_FROM_LINUX_FLAG, GPIO_OUTPUT);
GPIO_setDir(DATAFORFILE_TO_LINUX_BANK, DATAFORFILE_TO_LINUX_FLAG, GPIO_OUTPUT);
GPIO_setDir(LVDATA_FROM_LINUX_BANK, LVDATA_FROM_LINUX_FLAG, GPIO_OUTPUT);
GPIO_setDir(LVDATA_TO_LINUX_BANK, LVDATA_TO_LINUX_FLAG, GPIO_OUTPUT);
CLR_OPTITRACKDATA_FROM_LINUX; // Clear = tell linux DSP is ready for new Opitrack data
CLR_DATA_FROM_LINUX; // Clear = tell linux that DSP is ready for new data
CLR_DATAFORFILE_TO_LINUX; // Clear = linux not requesting data
SET_DATA_TO_LINUX; // Set = put float array data into shared memory for linux
SET_IMAGE_TO_LINUX; // Set = put image into shared memory for linux
CLR_LVDATA_FROM_LINUX; // Clear = tell linux that DSP is ready for new LV data
SET_LVDATA_TO_LINUX; // Set = put LV char data into shared memory for linux
// clear all possible EDMA
EDMA3_0_Regs->SHADOW[1].ICR = 0xFFFFFFFF;
// Add your init code here
}
int main(void) //main
{
//motor_test();
return 1;
initialize();
init_LCD();
_delay_ms(1000);
clear_display();
sei(); //enabling global interrupts
while(1)
{
next_node();
clear_display();
print_string("NEXT NODE 1");
get_to_node();
clear_display();
print_string("REACHED NODE 1");
next_node();
clear_display();
print_string("NEXT NODE 2");
get_to_node();
clear_display();
print_string("REACHED NODE 2");
change_dir(1);
if (obstacle_detection()){
}
next_node();
clear_display();
print_string("NEXT NODE 3");
get_to_node();
clear_display();
print_string("REACHED NODE 3");
if (obstacle_detection()){
}
}
return 0;
}
