change wave & adsr redraw

diff --git a/gui.c b/gui.c
index 59f3c94bcfb0343e5716465d162354b20baedc54..5b9f228881ba1e92f88c952b392d49a1953220ab 100644 (file)
--- a/gui.c
+++ b/gui.c
@@ -42,7 +42,7 @@ volatile uint8_t  gui_event_w = 0;
 
          uint8_t  redraw_adsr = 0;
          uint8_t  redraw_wave = 0;
-         uint8_t  wave_shape[N_SAMPLE];
+//       uint8_t  wave_shape[N_SAMPLE];
          uint8_t  adsr_shape[N_SAMPLE];
 
          uint8_t  gui_state = GUI_INIT;
@@ -1212,7 +1212,7 @@ inline void gui_gotostate_total_reset (void)
 // Handle the actual GUI state machine
 void handle_gui(void)
 {
-               uint16_t event;
+       uint16_t event;
        
        if (NOT_EMPTY_BP(gui_event_w, gui_event_r, N_GUI_EVENT)) // event received
        {
@@ -1328,19 +1328,18 @@ void handle_gui(void)
 
 /* drawing of some screens */
 
-void draw_wave (void) // waveform display
+inline uint8_t convert_wave(int8_t x)
 {
-       uint16_t i;
-       uint16_t x;
-       
-       // convert sample to drawable shape
-       for(i = 0; i< N_SAMPLE; ++i)
-       {
-               x = (uint16_t)(sample[i]+128) * 229;
-               wave_shape[i] = x>>9;
-       }
+       uint16_t y;
        
-       lcd_draw_wave(wave_shape);
+       y = (uint16_t)(x+128) * 229;
+       return (uint8_t)(y >>= 9);
+}
+
+void draw_wave (void) // waveform display
+{
+       // conversion moved to LCD handler
+       lcd_draw_wave(sample);
 }
 
 void draw_adsr (void) // envelope display

diff --git a/gui.h b/gui.h
index 4982789c3dc6487fa3489f511d78ac66e5e5ffac..89c376b1ddfc95310fff253576d37d56fef1b38c 100644 (file)
--- a/gui.h
+++ b/gui.h
@@ -227,10 +227,11 @@ inline void gui_exec_name (void);
 
 // drawing of some screens
 
-       void draw_wave (void);
-       void draw_adsr (void);
-       void draw_select (void);
-       void draw_select_save (void);
+inline uint8_t convert_wave(int8_t x);
+       void    draw_wave (void);
+       void    draw_adsr (void);
+       void    draw_select (void);
+       void    draw_select_save (void);
 
 // dynamic menu texts
 

diff --git a/lcd.c b/lcd.c
index 8a9f84132c2cbc7b1bbbfadd450bb7e7a6ec2973..634ccbe61a08dc112a23beb8904cd0eb87f74942 100644 (file)
--- a/lcd.c
+++ b/lcd.c
@@ -16,6 +16,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 #include "lcd.h"
 #include "main.h"
 #include "debug.h"
+#include "gui.h"
 #include "font.h"
 
 volatile uint16_t lcdpwm_high;
@@ -40,6 +41,14 @@ const uint16_t button_chars  [N_BUTTONTYPES] = BUTTON_CHARS;
 const uint16_t button_lmargin[N_BUTTONTYPES] = BUTTON_LMARGIN;
 const uint16_t button_rmargin[N_BUTTONTYPES] = BUTTON_RMARGIN;
 
+uint8_t  draw_buffer[FULLSCREEN_PIXELS * 2];
+uint8_t  draw_buffer_high = 0;
+uint8_t  draw_adsr_low = 0;
+uint8_t  draw_adsr_high = 0;
+uint8_t  draw_wave_low = 0;
+uint8_t  draw_wave_high = 0;
+uint16_t draw_x = 0;
+
 
 inline void lcd_brightness (const uint16_t value)
 {
@@ -293,7 +302,6 @@ inline void init_lcd (void)
 }
 
 
-
 // interrupt to generate brightness PWM.
 // FOR SOME REASON IT IS ON A PIN WITH TIMER OUTPUT BUT WITHOUT PWM :< 
 inline void int_lcd_pwm (void)
@@ -365,7 +373,7 @@ inline void lcd_set_mode ( // setup drawing area and color depth for single chip
                lcd_write(chip, LCD_COMMAND, LCD_DisplayMode);
                lcd_write(chip, LCD_DATA, mode);
        }
-       if ((lcd_x0[chip] != x0)||(lcd_x1[chip] != x1))
+       if ((lcd_x0[chip] != x0) || (lcd_x1[chip] != x1))
        {
                lcd_x0[chip] = x0;
                lcd_x1[chip] = x1;
@@ -373,7 +381,7 @@ inline void lcd_set_mode ( // setup drawing area and color depth for single chip
                lcd_write(chip, LCD_DATA, x0);
                lcd_write(chip, LCD_DATA, x1);
        }
-       if ((lcd_y0[chip] != y0)||(lcd_y1[chip] != y1))
+       if ((lcd_y0[chip] != y0) || (lcd_y1[chip] != y1))
        {
                lcd_y0[chip] = y0;
                lcd_y1[chip] = y1;
@@ -392,6 +400,16 @@ void lcd_setup_drawing ( // setup drawing area and color depth
 )
 {
        uint16_t x;
+       
+       if (mode != LCD_GRAY)
+       {
+               draw_adsr_low = 0;
+               draw_adsr_high = 0;
+               draw_wave_low = 0;
+               draw_wave_high = 0;
+               draw_x = 0;
+       }
+       
        if(x0 < 256)
        {
                x = (x1>255) ? 255 : x1;
@@ -407,7 +425,6 @@ void lcd_setup_drawing ( // setup drawing area and color depth
 }
 
 
-
 void lcd_clear_screen (const uint8_t mode)
 {
        uint8_t  y;
@@ -428,168 +445,30 @@ void lcd_clear_screen (const uint8_t mode)
 
 void lcd_draw_wave (const uint8_t * const data)
 {
-       uint16_t i;
-       uint8_t  col[10];
-       uint8_t  x;
-       
-       lcd_setup_drawing(LCD_GRAY, 0, 255, 0, 9);
-       
-       // convert shape to bit patterns & then draw
-       for (i=0; i<256; ++i)
+       if (draw_buffer_high)
        {
-               memset(col, 0, 10);
-               x = data[i];
-               
-               if (x < WAVE_LOWER_0)
-               {
-                       col[4] = WAVE_LOWER_START;
-                       if (x < WAVE_LOWER_1)
-                       {
-                               col[5] = 0xff;
-                               if (x < WAVE_LOWER_2)
-                               {
-                                       col[6] = 0xff;
-                                       if (x < WAVE_LOWER_3)
-                                       {
-                                               col[7] = 0xff;
-                                               if (x < WAVE_LOWER_4)
-                                               {
-                                                       col[8] = 0xff;
-                                                       col[9] = wave_lower[x-WAVE_LOWER_5];
-                                               }
-                                               else
-                                                       col[8] = wave_lower[x-WAVE_LOWER_4];
-                                       }
-                                       else
-                                               col[7] = wave_lower[x-WAVE_LOWER_3];
-                               }
-                               else
-                                       col[6] = wave_lower[x-WAVE_LOWER_2];
-                       }
-                       else
-                               col[5] = wave_lower[x-WAVE_LOWER_1];
-               }
-               else if (x >= WAVE_UPPER_0)
-               {
-                       col[4] = WAVE_UPPER_START;
-                       if (x >= WAVE_UPPER_1)
-                       {
-                               col[3] = 0xff;
-                               if (x >= WAVE_UPPER_2)
-                               {
-                                       col[2] = 0xff;
-                                       if (x >= WAVE_UPPER_3)
-                                       {
-                                               col[1] = 0xff;
-                                               col[0] = wave_upper[x-WAVE_UPPER_3];
-                                       }
-                                       else
-                                               col[1] = wave_upper[x-WAVE_UPPER_2];
-                               }
-                               else
-                                       col[2] = wave_upper[x-WAVE_UPPER_1];
-                       }
-                       else
-                               col[3] = wave_upper[x-WAVE_UPPER_0];
-               }
-               else
-               {
-                       col[4] = wave_middle[x-WAVE_LOWER_0];
-               }
-               
-               lcd_write(LCD_SLAVE, LCD_DATA, col[0]);
-               lcd_write(LCD_SLAVE, LCD_DATA, col[1]);
-               lcd_write(LCD_SLAVE, LCD_DATA, col[2]);
-               lcd_write(LCD_SLAVE, LCD_DATA, col[3]);
-               lcd_write(LCD_SLAVE, LCD_DATA, col[4]);
-               lcd_write(LCD_SLAVE, LCD_DATA, col[5]);
-               lcd_write(LCD_SLAVE, LCD_DATA, col[6]);
-               lcd_write(LCD_SLAVE, LCD_DATA, col[7]);
-               lcd_write(LCD_SLAVE, LCD_DATA, col[8]);
-               lcd_write(LCD_SLAVE, LCD_DATA, col[9]);
+               memcpy(draw_buffer, data, HALFSCREEN_PIXELS);
+               draw_wave_low = 1;
+       }
+       else
+       {
+               memcpy(draw_buffer + FULLSCREEN_PIXELS, data, HALFSCREEN_PIXELS);
+               draw_wave_high = 1;
        }
 }
 
 void lcd_draw_adsr (const uint8_t * const data)
 {
-       uint16_t i;
-       uint8_t  col[10];
-       uint8_t  x;
-       
-       lcd_setup_drawing(LCD_GRAY, 256, 511, 0, 9);
        
-       // convert shape to bit patterns & then draw
-       for (i=0; i<256; ++i)
+       if (draw_buffer_high)
        {
-               memset(col, 0, 10);
-               x = data[i];
-               
-               if (x >= ADSR_UPPER_1)
-               {
-                       col[9] = 0xff;
-                       if (x >= ADSR_UPPER_2)
-                       {
-                               col[8] = 0xff;
-                               if (x >= ADSR_UPPER_3)
-                               {
-                                       col[7] = 0xff;
-                                       if (x >= ADSR_UPPER_4)
-                                       {
-                                               col[6] = 0xff;
-                                               if (x >= ADSR_UPPER_5)
-                                               {
-                                                       col[5] = 0xff;
-                                                       if (x >= ADSR_UPPER_6)
-                                                       {
-                                                               col[4] = 0xff;
-                                                               if (x >= ADSR_UPPER_7)
-                                                               {
-                                                                       col[3] = 0xff;
-                                                                       if (x >= ADSR_UPPER_8)
-                                                                       {
-                                                                               col[2] = 0xff;
-                                                                               if (x >= ADSR_UPPER_9)
-                                                                               {
-                                                                                       col[1] = 0xff;
-                                                                                       col[0] = wave_upper[x-ADSR_UPPER_9];
-                                                                               }
-                                                                               else
-                                                                                       col[1] = wave_upper[x-ADSR_UPPER_8];
-                                                                       }
-                                                                       else
-                                                                               col[2] = wave_upper[x-ADSR_UPPER_7];
-                                                               }
-                                                               else
-                                                                       col[3] = wave_upper[x-ADSR_UPPER_6];
-                                                       }
-                                                       else
-                                                               col[4] = wave_upper[x-ADSR_UPPER_5];
-                                               }
-                                               else
-                                                       col[5] = wave_upper[x-ADSR_UPPER_4];
-                                       }
-                                       else
-                                               col[6] = wave_upper[x-ADSR_UPPER_3];
-                               }
-                               else
-                                       col[7] = wave_upper[x-ADSR_UPPER_2];
-                       }
-                       else
-                               col[8] = wave_upper[x-ADSR_UPPER_1];
-               }
-               else
-                       col[9] = wave_upper[x-ADSR_UPPER_0];
-               
-               lcd_write(LCD_MASTER, LCD_DATA, col[0]);
-               lcd_write(LCD_MASTER, LCD_DATA, col[1]);
-               lcd_write(LCD_MASTER, LCD_DATA, col[2]);
-               lcd_write(LCD_MASTER, LCD_DATA, col[3]);
-               lcd_write(LCD_MASTER, LCD_DATA, col[4]);
-               lcd_write(LCD_MASTER, LCD_DATA, col[5]);
-               lcd_write(LCD_MASTER, LCD_DATA, col[6]);
-               lcd_write(LCD_MASTER, LCD_DATA, col[7]);
-               lcd_write(LCD_MASTER, LCD_DATA, col[8]);
-               lcd_write(LCD_MASTER, LCD_DATA, col[9]);
+               memcpy(draw_buffer + HALFSCREEN_PIXELS, data, HALFSCREEN_PIXELS);
+               draw_adsr_low = 1;
+       }
+       else
+       {
+               memcpy(draw_buffer + FULLSCREEN_PIXELS + HALFSCREEN_PIXELS, data, HALFSCREEN_PIXELS);
+               draw_adsr_high = 1;
        }
 }
 
@@ -1113,3 +992,227 @@ void lcd_draw_name_menu (
        
        lcd_draw_name_cursor(cursor);
 }
+
+
+void handle_lcd (void)
+{
+       uint8_t *buffer;
+       uint8_t *draw_adsr;
+       uint8_t *draw_wave;
+       
+       uint8_t  col[10];
+       uint8_t  x;
+       
+       if (draw_buffer_high)
+       {
+               if (
+                       !draw_adsr_high && !draw_wave_high &&
+                       (draw_adsr_low  ||  draw_wave_low)
+               )
+                       draw_buffer_high = 0;
+       }
+       else
+       {
+               if (
+                       !draw_adsr_low  && !draw_wave_low &&
+                       (draw_adsr_high ||  draw_wave_high)
+               )
+                       draw_buffer_high = 1;
+       }
+       
+       if (draw_buffer_high)
+       {
+               buffer = draw_buffer + FULLSCREEN_PIXELS;
+               draw_adsr = &draw_adsr_high;
+               draw_wave = &draw_wave_high;
+       }
+       else
+       {
+               buffer = draw_buffer;
+               draw_adsr = &draw_adsr_low;
+               draw_wave = &draw_wave_low;
+       }
+       
+       if (draw_x < HALFSCREEN_PIXELS)
+       {
+               if (*draw_wave)
+                       lcd_setup_drawing(LCD_GRAY, draw_x, HALFSCREEN_PIXELS-1, 0, 9);
+               while (*draw_wave)
+               {
+                       memset(col, 0, 10);
+                       x = convert_wave((int8_t)buffer[draw_x]);
+                       
+                       if (x < WAVE_LOWER_0)
+                       {
+                               col[4] = WAVE_LOWER_START;
+                               if (x < WAVE_LOWER_1)
+                               {
+                                       col[5] = 0xff;
+                                       if (x < WAVE_LOWER_2)
+                                       {
+                                               col[6] = 0xff;
+                                               if (x < WAVE_LOWER_3)
+                                               {
+                                                       col[7] = 0xff;
+                                                       if (x < WAVE_LOWER_4)
+                                                       {
+                                                               col[8] = 0xff;
+                                                               col[9] = wave_lower[x-WAVE_LOWER_5];
+                                                       }
+                                                       else
+                                                               col[8] = wave_lower[x-WAVE_LOWER_4];
+                                               }
+                                               else
+                                                       col[7] = wave_lower[x-WAVE_LOWER_3];
+                                       }
+                                       else
+                                               col[6] = wave_lower[x-WAVE_LOWER_2];
+                               }
+                               else
+                                       col[5] = wave_lower[x-WAVE_LOWER_1];
+                       }
+                       else if (x >= WAVE_UPPER_0)
+                       {
+                               col[4] = WAVE_UPPER_START;
+                               if (x >= WAVE_UPPER_1)
+                               {
+                                       col[3] = 0xff;
+                                       if (x >= WAVE_UPPER_2)
+                                       {
+                                               col[2] = 0xff;
+                                               if (x >= WAVE_UPPER_3)
+                                               {
+                                                       col[1] = 0xff;
+                                                       col[0] = wave_upper[x-WAVE_UPPER_3];
+                                               }
+                                               else
+                                                       col[1] = wave_upper[x-WAVE_UPPER_2];
+                                       }
+                                       else
+                                               col[2] = wave_upper[x-WAVE_UPPER_1];
+                               }
+                               else
+                                       col[3] = wave_upper[x-WAVE_UPPER_0];
+                       }
+                       else
+                       {
+                               col[4] = wave_middle[x-WAVE_LOWER_0];
+                       }
+                       
+                       lcd_write(LCD_SLAVE, LCD_DATA, col[0]);
+                       lcd_write(LCD_SLAVE, LCD_DATA, col[1]);
+                       lcd_write(LCD_SLAVE, LCD_DATA, col[2]);
+                       lcd_write(LCD_SLAVE, LCD_DATA, col[3]);
+                       lcd_write(LCD_SLAVE, LCD_DATA, col[4]);
+                       lcd_write(LCD_SLAVE, LCD_DATA, col[5]);
+                       lcd_write(LCD_SLAVE, LCD_DATA, col[6]);
+                       lcd_write(LCD_SLAVE, LCD_DATA, col[7]);
+                       lcd_write(LCD_SLAVE, LCD_DATA, col[8]);
+                       lcd_write(LCD_SLAVE, LCD_DATA, col[9]);
+                       
+                       ++draw_x;
+                       // finished
+                       if (draw_x >= HALFSCREEN_PIXELS)
+                       {
+                               *draw_wave = 0;
+                               draw_x = HALFSCREEN_PIXELS;
+                               return;
+                       }
+                       // interrupt drawing to handle communication every 8 pixels
+                       if (!(draw_x & 0x07))
+                               return;
+               }
+               draw_x = HALFSCREEN_PIXELS;
+       }
+       
+       if (draw_x >= HALFSCREEN_PIXELS)
+       {
+               if (*draw_adsr)
+                       lcd_setup_drawing(LCD_GRAY, draw_x, FULLSCREEN_PIXELS-1, 0, 9);
+               while (*draw_adsr)
+               {
+                       memset(col, 0, 10);
+                       x = buffer[draw_x];
+                       
+                       if (x >= ADSR_UPPER_1)
+                       {
+                               col[9] = 0xff;
+                               if (x >= ADSR_UPPER_2)
+                               {
+                                       col[8] = 0xff;
+                                       if (x >= ADSR_UPPER_3)
+                                       {
+                                               col[7] = 0xff;
+                                               if (x >= ADSR_UPPER_4)
+                                               {
+                                                       col[6] = 0xff;
+                                                       if (x >= ADSR_UPPER_5)
+                                                       {
+                                                               col[5] = 0xff;
+                                                               if (x >= ADSR_UPPER_6)
+                                                               {
+                                                                       col[4] = 0xff;
+                                                                       if (x >= ADSR_UPPER_7)
+                                                                       {
+                                                                               col[3] = 0xff;
+                                                                               if (x >= ADSR_UPPER_8)
+                                                                               {
+                                                                                       col[2] = 0xff;
+                                                                                       if (x >= ADSR_UPPER_9)
+                                                                                       {
+                                                                                               col[1] = 0xff;
+                                                                                               col[0] = wave_upper[x-ADSR_UPPER_9];
+                                                                                       }
+                                                                                       else
+                                                                                               col[1] = wave_upper[x-ADSR_UPPER_8];
+                                                                               }
+                                                                               else
+                                                                                       col[2] = wave_upper[x-ADSR_UPPER_7];
+                                                                       }
+                                                                       else
+                                                                               col[3] = wave_upper[x-ADSR_UPPER_6];
+                                                               }
+                                                               else
+                                                                       col[4] = wave_upper[x-ADSR_UPPER_5];
+                                                       }
+                                                       else
+                                                               col[5] = wave_upper[x-ADSR_UPPER_4];
+                                               }
+                                               else
+                                                       col[6] = wave_upper[x-ADSR_UPPER_3];
+                                       }
+                                       else
+                                               col[7] = wave_upper[x-ADSR_UPPER_2];
+                               }
+                               else
+                                       col[8] = wave_upper[x-ADSR_UPPER_1];
+                       }
+                       else
+                               col[9] = wave_upper[x-ADSR_UPPER_0];
+                       
+                       lcd_write(LCD_MASTER, LCD_DATA, col[0]);
+                       lcd_write(LCD_MASTER, LCD_DATA, col[1]);
+                       lcd_write(LCD_MASTER, LCD_DATA, col[2]);
+                       lcd_write(LCD_MASTER, LCD_DATA, col[3]);
+                       lcd_write(LCD_MASTER, LCD_DATA, col[4]);
+                       lcd_write(LCD_MASTER, LCD_DATA, col[5]);
+                       lcd_write(LCD_MASTER, LCD_DATA, col[6]);
+                       lcd_write(LCD_MASTER, LCD_DATA, col[7]);
+                       lcd_write(LCD_MASTER, LCD_DATA, col[8]);
+                       lcd_write(LCD_MASTER, LCD_DATA, col[9]);
+                       
+                       ++draw_x;
+                       // finished
+                       if (draw_x >= FULLSCREEN_PIXELS)
+                       {
+                               *draw_adsr = 0;
+                               draw_x = 0;
+                               return;
+                       }
+                       // interrupt drawing to handle communication every 16 pixels
+                       if (!(draw_x & 0x0F))
+                               return;
+               }
+               draw_x = 0;
+       }
+}
\ No newline at end of file

diff --git a/lcd.h b/lcd.h
index a62c36147a66cc1903a17a3f099d397c4610f3fd..c82b70e071f30a5dfb5a9469ea4e0bfc2867e91e 100644 (file)
--- a/lcd.h
+++ b/lcd.h
@@ -37,6 +37,9 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
 */
 
+#define HALFSCREEN_PIXELS 256
+#define FULLSCREEN_PIXELS 512
+
 #define N_FONT8  (256 * 1 * 8)
 #define N_FONT16 (256 * 2 * 8)
 
@@ -481,3 +484,5 @@ void lcd_draw_name_menu (
        const uint8_t * const button_F,
        const int8_t          selected
 );
+
+void handle_lcd (void);

diff --git a/main.c b/main.c
index ef8838ca8f7744d537a601d3b8423c801aadbe4e..658e5b4e7cc76614b1f4d85968275db66b578de7 100644 (file)
--- a/main.c
+++ b/main.c
@@ -1,5 +1,5 @@
 /*
-Copyright 2021, 2022 Balthasar Szczepański
+Copyright 2021, 2022, 2025 Balthasar Szczepański
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 
@@ -81,6 +81,7 @@ void main (void)
                handle_wave();
                handle_gui();
                handle_ctrl();
+               handle_lcd();
                handle_debug();
        }
 }