void gui_display_infobox(void)
{
int i;
#if BOARD != EVK1100
// Draw info box
et024006_DrawFilledRect(SCROLL_X,
SCROLL_Y,
SCROLL_W,
SCROLL_H,
infobox_contents.bg_color);
for (i = 0; i < INFO_MAX_LINES; i++)
{
if (strlen(infobox_contents.lines[i]))
{
int x;
x = 160 - ((strlen(infobox_contents.lines[i]) / 2)*10);
if (x < 0) x = 10;
et024006_PrintString(infobox_contents.lines[i],
(const unsigned char*)&FONT8x8,
x,
(i+1)*12+SCROLL_Y,
INFO_FG_COLOR,
infobox_contents.bg_color);
}
}
if (info_bitmap.data && info_bitmap.data_len) {
printk("Displaying pixmap (size %d)\n", info_bitmap.data_len);
et024006_PutPixmap( (et024006_color_t *)info_bitmap.data,
info_bitmap.width, // Map width
0, // map_x
0, // map_y
40, // x
40, // y
info_bitmap.width, // width
info_bitmap.height); // height
}
else {
printk("Not displaying picture\n");
}
#else
dip204_clear_display();
for (i = 0; i < INFO_MAX_LINES; i++)
{
int len = strlen(infobox_contents.lines[i]);
int col = (MAX_LINE_LEN/2) - (len/2);
if ( col <= 0) col = 1;
dip204_set_cursor_position(col,i+1); /* col,line */
dip204_write_string(infobox_contents.lines[i]);
dip204_hide_cursor();
}
#endif
}
//Initialize LCD display
void init_disp (void)
{
static const gpio_map_t DIP204_SPI_GPIO_MAP =
{
{DIP204_SPI_SCK_PIN, DIP204_SPI_SCK_FUNCTION }, // SPI Clock.
{DIP204_SPI_MISO_PIN, DIP204_SPI_MISO_FUNCTION}, // MISO.
{DIP204_SPI_MOSI_PIN, DIP204_SPI_MOSI_FUNCTION}, // MOSI.
{DIP204_SPI_NPCS_PIN, DIP204_SPI_NPCS_FUNCTION} // Chip Select NPCS.
};
// add the spi options driver structure for the LCD DIP204
spi_options_t spiOptions =
{
.reg = DIP204_SPI_NPCS,
.baudrate = 1000000,
.bits = 8,
.spck_delay = 0,
.trans_delay = 0,
.stay_act = 1,
.spi_mode = 0,
.modfdis = 1
};
// Assign I/Os to SPI
gpio_enable_module(DIP204_SPI_GPIO_MAP,
sizeof(DIP204_SPI_GPIO_MAP) / sizeof(DIP204_SPI_GPIO_MAP[0]));
// Initialize as master
spi_initMaster(DIP204_SPI, &spiOptions);
// Set selection mode: variable_ps, pcs_decode, delay
spi_selectionMode(DIP204_SPI, 0, 0, 0);
// Enable SPI
spi_enable(DIP204_SPI);
// setup chip registers
spi_setupChipReg(DIP204_SPI, &spiOptions, FOSC0);
// initialize LCD
dip204_init(backlight_IO, true);
dip204_hide_cursor();
}
int main (void)
{
// Switch the CPU main clock to oscillator 0
pm_switch_to_osc0(&AVR32_PM, FOSC0, OSC0_STARTUP);
board_init();
init_disp();
U32 x = 12345678;
U32 y = 87654321;
U64 z =0;
F32 a = 1234.5678;
F32 b = 8765.4321;
F32 c = 0;
U32 calc_time_z = 0;
U32 calc_time_c = 0;
U32 cnt_1 = 0;
U32 cnt_2 = 0;
U32 cnt_3 = 0;
U32 cnt_res_z = 0;
U32 cnt_res_c = 0;
char cycl_str_z[9];
char cycl_str_c[9];
char result[19];
char cycl_c[9];
char cycl_z[9];
//Calculation:
//Cycle count 1
cnt_1 = Get_sys_count();
//Calculation part 1:
z = x*y;
//Cycle count 2
cnt_2 = Get_sys_count();
//Calculation part 2:
c = a*b;
//Cycle count 3
cnt_3 = Get_sys_count();
//Cycle count result
cnt_res_z = cnt_2 - cnt_1 ;
cnt_res_c = cnt_3 - cnt_2 ;
//Use cycle count result to find calculation time
calc_time_c = (cnt_res_c * 1000000 + FOSC0 - 1) / FOSC0;
calc_time_z = (cnt_res_z * 1000000 + FOSC0 - 1) / FOSC0;
//Compose strings for display output
sprintf(result, "%f", c);
sprintf(cycl_str_z, "%lu", calc_time_z);
sprintf(cycl_str_c, "%lu", calc_time_c);
sprintf(cycl_c, "%lu", cnt_res_c);
sprintf(cycl_z, "%lu", cnt_res_z);
//Display calculation time, cycles and multiplication result on monitor
dip204_clear_display();
dip204_set_cursor_position(1,1);
dip204_write_string("x*y=z");
dip204_set_cursor_position(1,2);
dip204_write_string("Time:");
dip204_set_cursor_position(7,2);
dip204_write_string(cycl_str_z);
dip204_set_cursor_position(1,3);
dip204_write_string("Cycles:");
dip204_set_cursor_position(9,3);
dip204_write_string(cycl_z);
dip204_set_cursor_position(11,1);
dip204_write_string("a*b=c");
dip204_set_cursor_position(11,2);
dip204_write_string("Time:");
dip204_set_cursor_position(17,2);
dip204_write_string(cycl_str_c);
dip204_set_cursor_position(11,3);
dip204_write_string("Cycles:");
dip204_set_cursor_position(19,3);
dip204_write_string(cycl_c);
while (1)
{
}
}
int main(void)
{
//-------------------------USART INTERRUPT REGISTRATION.------------//
// Set Clock: Oscillator needs to initialized once: First
pcl_switch_to_osc(PCL_OSC0, FOSC0, OSC0_STARTUP);
// -------------- USART INIT -----------------------------------------------
static const gpio_map_t USART_GPIO_MAP =
{
{AVR32_USART0_RXD_0_0_PIN, AVR32_USART0_RXD_0_0_FUNCTION},
{AVR32_USART0_TXD_0_0_PIN, AVR32_USART0_TXD_0_0_FUNCTION}
};
// USART options.
static const usart_options_t USART_OPTIONS =
{
.baudrate = USART_BAUDRATE,
.charlength = 8,
.paritytype = USART_NO_PARITY,
.stopbits = USART_1_STOPBIT,
.channelmode = USART_NORMAL_CHMODE
};
// Assign GPIO to USART
gpio_enable_module(USART_GPIO_MAP, sizeof(USART_GPIO_MAP) / sizeof(USART_GPIO_MAP[0]));
// Init USART
usart_init_rs232(USART_0, &USART_OPTIONS, FOSC0);
Disable_global_interrupt();
INTC_init_interrupts(); // Init Interrupt Table: Once at first
// Register USART Interrupt (hinzufügen)
INTC_register_interrupt(&usart_int_handler, AVR32_USART0_IRQ, AVR32_INTC_INT0);
USART_0->ier = AVR32_USART_IER_RXRDY_MASK; // Activate ISR on RX Line
Enable_global_interrupt();
// -----------------------------------------------------------------------------------
// -------------------------- Display INIT ----------------------------------
// Map SPI Pins
static const gpio_map_t DIP204_SPI_GPIO_MAP =
{
{DIP204_SPI_SCK_PIN, DIP204_SPI_SCK_FUNCTION }, // SPI Clock.
{DIP204_SPI_MISO_PIN, DIP204_SPI_MISO_FUNCTION}, // MISO.
{DIP204_SPI_MOSI_PIN, DIP204_SPI_MOSI_FUNCTION}, // MOSI.
{DIP204_SPI_NPCS_PIN, DIP204_SPI_NPCS_FUNCTION} // Chip Select NPCS.
};
// add the spi options driver structure for the LCD DIP204
spi_options_t spiOptions =
{
.reg = DIP204_SPI_NPCS,
.baudrate = 1000000,
.bits = 8,
.spck_delay = 0,
.trans_delay = 0,
.stay_act = 1,
.spi_mode = 0,
.modfdis = 1
};
// SPI Inits: Assign I/Os to SPI
gpio_enable_module(DIP204_SPI_GPIO_MAP,
sizeof(DIP204_SPI_GPIO_MAP) / sizeof(DIP204_SPI_GPIO_MAP[0]));
// Initialize as master
spi_initMaster(DIP204_SPI, &spiOptions);
// Set selection mode: variable_ps, pcs_decode, delay
spi_selectionMode(DIP204_SPI, 0, 0, 0);
// Enable SPI
spi_enable(DIP204_SPI);
// setup chip registers
spi_setupChipReg(DIP204_SPI, &spiOptions, FOSC0);
// initialize delay driver: Muss vor dip204_init() ausgeführt werden
delay_init( FOSC0 );
// initialize LCD
dip204_init(backlight_PWM, TRUE);
// ---------------------------------------------------------------------------------------
// ----------------- Timer Counter Init ---------------------------------
// Timer Configs: Options for waveform generation.
static const tc_waveform_opt_t WAVEFORM_OPT =
{
.channel = TC_CHANNEL, // Channel selection.
.bswtrg = TC_EVT_EFFECT_NOOP, // Software trigger effect on TIOB.
.beevt = TC_EVT_EFFECT_NOOP, // External event effect on TIOB.
.bcpc = TC_EVT_EFFECT_NOOP, // RC compare effect on TIOB.
.bcpb = TC_EVT_EFFECT_NOOP, // RB compare effect on TIOB.
.aswtrg = TC_EVT_EFFECT_NOOP, // Software trigger effect on TIOA.
.aeevt = TC_EVT_EFFECT_NOOP, // External event effect on TIOA.
.acpc = TC_EVT_EFFECT_NOOP, // RC compare effect on TIOA: toggle.
.acpa = TC_EVT_EFFECT_NOOP, // RA compare effect on TIOA: toggle
.wavsel = TC_WAVEFORM_SEL_UP_MODE_RC_TRIGGER,// Count till RC and reset (S. 649): Waveform selection
.enetrg = FALSE, // External event trigger enable.
.eevt = 0, // External event selection.
.eevtedg = TC_SEL_NO_EDGE, // External event edge selection.
.cpcdis = FALSE, // Counter disable when RC compare.
.cpcstop = FALSE, // Counter clock stopped with RC compare.
.burst = FALSE, // Burst signal selection.
.clki = FALSE, // Clock inversion.
.tcclks = TC_CLOCK_SOURCE_TC3 // Internal source clock 3, connected to fPBA / 8.
};
// TC Interrupt Enable Register
static const tc_interrupt_t TC_INTERRUPT =
{ .etrgs = 0, .ldrbs = 0, .ldras = 0, .cpcs = 1, .cpbs = 0, .cpas = 0, .lovrs = 0, .covfs = 0
};
// 0 = No Effect | 1 = Enable ( CPCS = 1 enables the RC Compare Interrupt )
// ***************** Timer Setup ***********************************************
// Initialize the timer/counter.
tc_init_waveform(tc, &WAVEFORM_OPT); // Initialize the timer/counter waveform.
// Set the compare triggers.
tc_write_rc(tc, TC_CHANNEL, RC); // Set RC value.
tc_configure_interrupts(tc, TC_CHANNEL, &TC_INTERRUPT);
// Start the timer/counter.
tc_start(tc, TC_CHANNEL); // And start the timer/counter.
// *******************************************************************************
Disable_global_interrupt();
// Register TC Interrupt
INTC_register_interrupt(&tc_irq, AVR32_TC_IRQ0, AVR32_INTC_INT3);
Enable_global_interrupt();
// ---------------------------------------------------------------------------------------
imu_init();
//-------------------------------TWI R/W ---------------------------------------------------
sensorDaten imu_data = {0};
char disp1[30], disp2[30], disp3[30], disp4[30];
short GX,GY,GZ, AX, AY, AZ; //shifted comlete Data
RPY currMoveRPY;
Quaternion currQuat;
currQuat.q0 = 1.0;
currQuat.q1 = 0;
currQuat.q2 = 0;
currQuat.q3 = 0;
Quaternion deltaQuat;
RotMatrix rot = {0};
RPY reconverted;
calibrate_all(&imu_data);
while(1){
if(exe){
exe = false;
read_sensor(&imu_data);
AX = imu_data.acc_x + imu_data.acc_x_bias;
AY = imu_data.acc_y + imu_data.acc_y_bias;
AZ = imu_data.acc_z + imu_data.acc_z_bias;
GX = imu_data.gyro_x + imu_data.gyro_x_bias;
GY = imu_data.gyro_y + imu_data.gyro_y_bias;
GZ = imu_data.gyro_z + imu_data.gyro_z_bias;
//convert to 1G
float ax = (float)AX * (-4.0);
float ay = (float)AY * (-4.0); //wegen 2^11= 2048, /2 = 1024 entspricht 4G -> 1G = (1024/4)
float az = (float)AZ * (-4.0);
//convert to 1°/s
gx = ((float)GX/ 14.375); // in °/s
gy = ((float)GY/ 14.375);
gz = ((float)GZ/ 14.375);
//Integration over time
dGx = (gx*0.03);
dGy = (gy*0.03);
dGz = (gz*0.03);
currMoveRPY.pitch = -dGx;
currMoveRPY.roll = dGy;
currMoveRPY.yaw = dGz;
//aufaddieren auf den aktuellen Winkel IN GRAD
gxDeg += dGx;
gyDeg += dGy;
gzDeg += dGz;
//RPY in Quaternion umwandeln
RPYtoQuat(&deltaQuat, &currMoveRPY);
//normieren
normQuat(&deltaQuat);
//aufmultiplizeiren
quatMultiplication(&deltaQuat, &currQuat, &currQuat);
//nochmal normieren
normQuat(&currQuat);
//rücktransformation nicht nötig!!
char send[80];
sprintf(send,"$,%f,%f,%f,%f,#", currQuat.q0, currQuat.q1, currQuat.q2, currQuat.q3);
usart_write_line(USART_0,send);
sprintf(disp1,"q0:%.3f, GX:%3.0f",currQuat.q0,gxDeg);
sprintf(disp2,"q1:%.3f, GY:%3.0f",currQuat.q1, gyDeg);
sprintf(disp3,"q2:%.3f, GZ:%3.0f",currQuat.q2, gzDeg);
sprintf(disp4,"q3:%.3f",currQuat.q3);
dip204_clear_display();
dip204_set_cursor_position(1,1);
dip204_write_string(disp1);
dip204_set_cursor_position(1,2);
dip204_write_string(disp2);
dip204_set_cursor_position(1,3);
dip204_write_string(disp3);
dip204_set_cursor_position(1,4);
dip204_write_string(disp4);
//sprintf(data,"TEST:%s",high);
//print_dbg(data);
}
}
}
void gui_draw(int force_draw) {
int i;
if (! mod) {
return;
}
mod = 0;
#if BOARD != EVK1100
// Draw title box
et024006_DrawFilledRect(TITLE_X,
TITLE_Y,
TITLE_W,
TITLE_H,
TITLE_BG_COLOR);
if (title_contents.title[0][0]) {
et024006_PrintString(title_contents.title[0],
(const unsigned char*)&FONT8x8,
TITLE_X + 10,
TITLE_Y + 5,
TITLE_FG_COLOR,
TITLE_BG_COLOR);
et024006_PrintString(title_contents.title[1],
(const unsigned char*)&FONT8x8,
TITLE_X + 10,
TITLE_Y + 5 + 12,
TITLE_FG_COLOR,
TITLE_BG_COLOR);
et024006_PrintString(title_contents.title[2],
(const unsigned char*)&FONT8x8,
TITLE_X + 10,
TITLE_Y + 5 + 12 + 12,
TITLE_FG_COLOR,
TITLE_BG_COLOR);
}
// Draw scroll box
et024006_DrawFilledRect(SCROLL_X,
SCROLL_Y,
SCROLL_W,
SCROLL_H,
scroll_box_contents.bg_color);
#endif
switch (display_mode)
{
case GUI_INFOBOX:
gui_display_infobox();
break;
case GUI_GETSTRING:
gui_display_getstring();
break;
case GUI_LIST:
{
#if BOARD == EVK1100
dip204_clear_display();
#endif
for (i = 0; i <= SCROLL_DISP_LINES; i++)
{
#if BOARD == EVK1100
dip204_set_cursor_position(1,i+1); /* col,line */
dip204_write_string(scroll_box_contents.lines[i+scroll_box_contents.dispstart]);
#else
if ((scroll_box_contents.cursor == i + scroll_box_contents.dispstart) &&
scroll_box_contents.cursor != 0)
{
/* Print cursor line. */
et024006_PrintString(scroll_box_contents.lines[i+scroll_box_contents.dispstart],
(const unsigned char*)&FONT8x8,
SCROLL_X + 10,
(i+1)*12+SCROLL_Y,
scroll_box_contents.bg_color,
CURSOR_BG_COLOR);
}
else
{
et024006_PrintString(scroll_box_contents.lines[i+scroll_box_contents.dispstart],
(const unsigned char*)&FONT8x8,
SCROLL_X + 10,
(i+1)*12+SCROLL_Y,
SCROLL_FG_COLOR,
scroll_box_contents.bg_color);
}
#endif
}
#if BOARD == EVK1100
dip204_set_cursor_position(1, scroll_box_contents.cursor - scroll_box_contents.dispstart+1);
dip204_show_cursor();
#endif
}
} /* switch */
// Draw buttons
#if BOARD != EVK1100
et024006_DrawFilledRect(BUTTON_X,
BUTTON_Y,
BUTTON_W,
BUTTON_H,
BUTTON_BG_COLOR);
for (i = 0; i < NUM_BUTTONS-1; i++) {
et024006_DrawVertLine(i*BUTTON_W/NUM_BUTTONS,
BUTTON_Y,
BUTTON_H,
BUTTON_FG_COLOR);
// Display button labels
if (button_contents.labels[i]) {
et024006_PrintString(button_contents.labels[i],
(const unsigned char*)&FONT8x8,
i*BUTTON_W/NUM_BUTTONS + 5,
BUTTON_Y + 10,
BUTTON_FG_COLOR,
BUTTON_BG_COLOR);
}
}
#endif
}
void gui_display_getstring(void)
{
int j;
int i;
#if BOARD != EVK1100
int fg_color, bg_color;
#endif
char str[22];
#if BOARD == EVK1100
if (redisplay) {
dip204_clear_display();
for (j = 0; j <= SCROLL_DISP_LINES; j++) {
strncpy(str, &(char_array[get_string_data.rowstart+j][get_string_data.colstart]), MAX_LINE_LEN);
str[MAX_LINE_LEN] = '\0';
dip204_set_cursor_position(1,j+2); /* col,line */
dip204_write_string(str);
}
}
#else
for (j = 0; j < GS_MAX_ROWS; j++) {
for (i = 0; i < strlen(char_array[j]); i++) {
if (get_string_data.row == j && get_string_data.col == i) {
fg_color = CURSOR_FG_COLOR;
bg_color = CURSOR_BG_COLOR;
} else {
fg_color = SCROLL_FG_COLOR;
bg_color = SCROLL_BG_COLOR;
}
str[0] = char_array[j][i];
str[1] = 0;
et024006_PrintString(str,
(const unsigned char*)&FONT8x8,
(i+1)*10+SCROLL_X + 10,
(j+1)*12+SCROLL_Y,
fg_color,
bg_color);
}
}
#endif
#if BOARD == EVK1100
if (redisplay){
if (get_string_data.rowstart == GS_MAX_ROWS - SCROLL_DISP_LINES) {
dip204_set_cursor_position(1,1); /* col,line */
dip204_write_string(" ");
j = 1;
for (i = 0; i < (sizeof func_row/sizeof func_row[0]); i++) {
dip204_set_cursor_position(j,get_string_data.rowstart + SCROLL_DISP_LINES); /* col,line */
dip204_write_string(func_row[i]);
j += strlen(func_row[i]);
}
}
redisplay = false;
}
dip204_set_cursor_position(1,1); /* col,line */
dip204_write_string(" ");
dip204_set_cursor_position(1,1); /* col,line */
dip204_write_string(getstring);
if (get_string_data.row == GS_MAX_ROWS) {
dip204_set_cursor_position(get_string_data.col * strlen(func_row[0]) + 2, GS_MAX_ROWS); /* col,line */
} else {
dip204_set_cursor_position(get_string_data.col + 1 - get_string_data.colstart,
get_string_data.row + 2 - get_string_data.rowstart); /* col,line */
}
dip204_show_cursor();
#else
j = 1;
for (i = 0; i < (sizeof func_row/sizeof func_row[0]); i++) {
if (get_string_data.row == GS_MAX_ROWS && get_string_data.col == i) {
fg_color = CURSOR_FG_COLOR;
bg_color = CURSOR_BG_COLOR;
} else {
fg_color = SCROLL_FG_COLOR;
bg_color = SCROLL_BG_COLOR;
}
et024006_PrintString(func_row[i],
(const unsigned char*)&FONT8x8,
j*10 + SCROLL_X + 10,
5*12+SCROLL_Y,
fg_color,
bg_color);
j += strlen(func_row[i])-1;
}
#endif
}
void gui_getstring(getstring_cb cb, void *ctx) {
static enum { IDLE, INIT, POLLING, FINISH } state = IDLE;
static getstring_cb saved_cb;
static void *cb_ctx;
switch (state)
{
case IDLE:
if (cb) {
saved_cb = cb;
cb_ctx = ctx;
state = INIT;
}
else {
return;
}
// Fallthrough
case INIT: {
gui_save_buttons();
#if BOARD == EVK1100
dip204_clear_display();
redisplay = true;
#endif
gui_set_title("Enter preshared key", 0);
gui_set_title(getstring, 1);
gui_set_button(0, "Left", sizeof "Left",gs_button_0);
gui_set_button(1, "Right", sizeof "Right", gs_button_1);
gui_set_button(2, "Up", sizeof "Up", gs_button_2);
gui_set_button(3, "Down", sizeof "Down", gs_button_3);
gui_set_button(4, "Enter", sizeof "Enter", gs_button_4);
get_string_data.col = 0;
get_string_data.row = 0;
get_string_data.colstart = 0;
get_string_data.rowstart = 0;
get_string_data.ready = false;
get_string_data.escape = false;
gui_getstring_onoff(true);
state = POLLING;
break;
}
case POLLING:
if (get_string_data.ready) {
state = FINISH;
}
break;
case FINISH:
gui_getstring_onoff(false);
gui_restore_buttons();
if (get_string_data.escape)
saved_cb(NULL, 0, cb_ctx);
else
saved_cb(getstring, strlen(getstring), cb_ctx);
saved_cb = NULL;
cb_ctx = NULL;
state = IDLE;
break;
}
return;
}
