//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);
}
}
}
static void qt60168_resources_init(const pm_freq_param_t *pm_freq_param)
{
static const gpio_map_t QT60168_SPI_GPIO_MAP =
{
{QT60168_SPI_SCK_PIN, QT60168_SPI_SCK_FUNCTION }, // SPI Clock.
{QT60168_SPI_MISO_PIN, QT60168_SPI_MISO_FUNCTION }, // MISO.
{QT60168_SPI_MOSI_PIN, QT60168_SPI_MOSI_FUNCTION }, // MOSI.
{QT60168_SPI_NPCS0_PIN, QT60168_SPI_NPCS0_FUNCTION} // Chip Select NPCS.
};
// SPI options.
spi_options_t spiOptions =
{
.reg = QT60168_SPI_NCPS,
.baudrate = QT60168_SPI_MASTER_SPEED, // Defined in conf_qt60168.h.
.bits = QT60168_SPI_BITS, // Defined in conf_qt60168.h.
.spck_delay = 0,
.trans_delay = 0,
.stay_act = 0,
.spi_mode = 3,
.modfdis = 1
};
// Assign I/Os to SPI.
gpio_enable_module(QT60168_SPI_GPIO_MAP,
sizeof(QT60168_SPI_GPIO_MAP) / sizeof(QT60168_SPI_GPIO_MAP[0]));
#if EXT_BOARD != SPB105
// Initialize as master.
spi_initMaster(QT60168_SPI, &spiOptions);
// Set selection mode: variable_ps, pcs_decode, delay.
spi_selectionMode(QT60168_SPI, 0, 0, 0);
// Enable SPI.
spi_enable(QT60168_SPI);
#endif
// Initialize QT60168 with SPI clock Osc0.
spi_setupChipReg(QT60168_SPI, &spiOptions, pm_freq_param->cpu_f);
}
#endif
void gui_init(const pm_freq_param_t *pm_freq_param) {
#if BOARD == EVK1100
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.
};
spi_options_t spiOptions =
{
.reg = DIP204_SPI_NPCS,
.baudrate = 1000000,
.bits = 8,
.spck_delay = 0,
.trans_delay = 0,
.stay_act = 1,
.spi_mode = 3,
.modfdis = 1
};
#endif
memset(&scroll_box_contents, 0, sizeof scroll_box_contents);
memset(&title_contents, 0, sizeof title_contents);
memset(&button_contents, 0, sizeof button_contents);
memset(&infobox_contents, 0, sizeof infobox_contents);
memset(&info_bitmap, 0, sizeof info_bitmap);
#if BOARD == EVK1104
// Init touch sensor resources: GPIO, SPI and QT60168.
qt60168_resources_init(pm_freq_param);
// Initialize QT60168 component.
qt60168_init(pm_freq_param->cpu_f);
#endif
#if BOARD == EVK1100
// Assign I/Os to SPI
gpio_enable_module(DIP204_SPI_GPIO_MAP,
sizeof(DIP204_SPI_GPIO_MAP) / sizeof(DIP204_SPI_GPIO_MAP[0]));
#if 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);
#endif
// setup chip registers
spi_setupChipReg(DIP204_SPI, &spiOptions, FOSC0);
// initialize LCD
dip204_init(backlight_PWM, true);
dip204_set_cursor_position(1,1);
dip204_write_string("http server demo!");
#else
// Init display
et024006_Init( pm_freq_param->cpu_f, pm_freq_param->cpu_f /*HSB*/);
// Turn on the display backlight
gpio_set_gpio_pin(ET024006DHU_BL_PIN);
#endif
mod = 1;
}
void gui_set_title(const char *str, unsigned char line)
{
int len;
Assert(line < 3);
memset(&title_contents.title[line], 0, sizeof title_contents.title[0]);
len = strlen(str);
if (len >= sizeof title_contents.title[0]) {
len = sizeof title_contents.title[0] - 1;
}
strncpy(title_contents.title[line], str, len);
mod = 1;
}
int gui_set_button(short id, const char *label, size_t len, button_cb_t cb)
{
if (id >= NUM_BUTTONS) {
return 0;
}
if (len >= sizeof button_contents.labels[id]) {
len = sizeof button_contents.labels[id] - 1;
}
button_contents.cbs[id] = cb;
strncpy(button_contents.labels[id], label, len);
mod = 1;
return 1;
}
void gui_clear_scroll_box(void)
{
memset(&scroll_box_contents, 0, sizeof scroll_box_contents);
scroll_box_contents.dispstart = 0;
}
void init_LCD(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.
};
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
};
gpio_enable_module(DIP204_SPI_GPIO_MAP,
sizeof(DIP204_SPI_GPIO_MAP) / sizeof(DIP204_SPI_GPIO_MAP[0]));
spi_initMaster(DIP204_SPI, &spiOptions);
spi_selectionMode(DIP204_SPI, 0, 0, 0);
spi_enable(DIP204_SPI);
spi_setupChipReg(DIP204_SPI, &spiOptions, FOSC0);
dip204_init(backlight_PWM, true);
clear_Display();
dip204_hide_cursor();
}
void init_Potentiometer(void){
const gpio_map_t ADC_GPIO_MAP = {
{EXAMPLE_ADC_POTENTIOMETER_PIN, EXAMPLE_ADC_POTENTIOMETER_FUNCTION}
};
gpio_enable_module(ADC_GPIO_MAP, sizeof(ADC_GPIO_MAP) /
sizeof(ADC_GPIO_MAP[0]));
AVR32_ADC.mr |= 0x1 << AVR32_ADC_MR_PRESCAL_OFFSET;
adc_configure(&AVR32_ADC);
adc_enable(&AVR32_ADC, EXAMPLE_ADC_POTENTIOMETER_CHANNEL);
adc_start(&AVR32_ADC);
}
void init_CurrentSensor(void){
#define AVR32_ADC_AD_1_PIN 22
const gpio_map_t ADC_GPIO_MAP = {
{AVR32_ADC_AD_3_PIN, AVR32_ADC_AD_3_FUNCTION}
};
gpio_enable_module(ADC_GPIO_MAP, sizeof(ADC_GPIO_MAP) /
sizeof(ADC_GPIO_MAP[0]));
AVR32_ADC.mr |= 0x1 << AVR32_ADC_MR_PRESCAL_OFFSET;
adc_configure(&AVR32_ADC);
adc_enable(&AVR32_ADC, 3);
adc_start(&AVR32_ADC);
}
void clear_Line(int line){
for(int i = 0; i<21;i++){
dip204_set_cursor_position(i,line);
dip204_write_string(" ");
}
}
void set_Direccion(int direccion){
if(direccion == 1){
clear_Line(2);
dip204_set_cursor_position(1,2);
dip204_write_string("Direccion:");
dip204_set_cursor_position(12,2);
dip204_write_string("Forward");
}
if(direccion == 0){
clear_Line(2);
dip204_set_cursor_position(1,2);
dip204_write_string("Direccion:");
dip204_set_cursor_position(12,2);
dip204_write_string("Reverse");
}
}
void set_Velocidad(int velocidad){
clear_Line(3);
dip204_set_cursor_position(1,3);
dip204_write_string("Velocidad:");
dip204_set_cursor_position(12,3);
switch (velocidad){
case 1:
dip204_write_string("1");
break;
case 2:
dip204_write_string("2");
break;
case 3:
dip204_write_string("3");
break;
case 4:
dip204_write_string("4");
break;
case 5:
dip204_write_string("5");
break;
case 6:
dip204_write_string("6");
break;
case 7:
dip204_write_string("7");
break;
case 8:
dip204_write_string("8");
break;
case 9:
dip204_write_string("9");
break;
case 10:
dip204_write_string("10");
break;
}//SWITCH
}
/*!
* \brief main function : do init and loop (poll if configured so)
*/
int main(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.
};
// Switch the CPU main clock to oscillator 0
pm_switch_to_osc0(&AVR32_PM, FOSC0, OSC0_STARTUP);
// Disable all interrupts.
Disable_global_interrupt();
// init the interrupts
INTC_init_interrupts();
// Enable all interrupts.
Enable_global_interrupt();
// 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);
// configure local push buttons
dip204_example_configure_push_buttons_IT();
// configure local joystick
dip204_example_configure_joystick_IT();
// initialize LCD
dip204_init(backlight_PWM, true);
// reset marker
current_char = 0x10;
// Display default message.
dip204_set_cursor_position(8,1);
dip204_write_string("ATMEL");
dip204_set_cursor_position(7,2);
dip204_write_string("EVK1100");
dip204_set_cursor_position(6,3);
dip204_write_string("AVR32 UC3");
dip204_set_cursor_position(3,4);
dip204_write_string("AT32UC3A Series");
dip204_hide_cursor();
/* do a loop */
while (1)
{
if (display)
{
delay_ms(400); // A delay so that it is humanly possible to see the
// character(s) before they are cleared.
// Clear line 1 column 19
dip204_set_cursor_position(19,1);
dip204_write_string(" ");
// Clear line 2 from column 18 to column 20.
dip204_set_cursor_position(18,2);
dip204_write_string(" "); // 3 spaces
// Clear line 3 column 19
dip204_set_cursor_position(19,3);
dip204_write_string(" ");
display = 0;
}
}
}
