Add files via upload

Initial ipload

Author: HughMaingauche

VGA/VGA_800x600.py

@@ -0,0 +1,69 @@
+# Font library reused from the xglcd font library by rdagger
+# https://github.com/rdagger/micropython-ili9341/tree/master
+
+class Font:
+    """Font data in X-GLCD format.
+
+    Attributes:
+        letters: A bytearray of letters (columns consist of bytes)
+        font_width: Maximum pixel width of font
+        font_height: Pixel height of font
+        start_letter: ASCII number of first letter
+        bytes_per_letter: How many bytes in one letter
+
+    Note:
+        Font files can be generated with the free version of MikroElektronika
+        GLCD Font Creator:  www.mikroe.com/glcd-font-creator
+        The font file must be in X-GLCD 'C' format.
+        To save text files from this font creator program in Win7 or higher
+        you must use XP compatibility mode or you can just use the clipboard.
+    """
+
+    def __init__(self, path, width, height, start_letter=32, letter_count=96, char_spacing=1, line_spacing=2):
+        """Constructor for X-GLCD Font object.
+
+        Args:
+            path (string): Full path of font file
+            width (int): Maximum width in pixels of each letter
+            height (int): Height in pixels of each letter
+            start_letter (int): First ASCII letter.  Default is 32.
+            letter_count (int): Total number of letters.  Default is 96.
+            char_spacing (int) pixels between char when pronting multiple chars
+            line_spacing (int) pixels between lines when line feed
+        """
+        self.width = width
+        self.height = max(height, 8)
+        self.start_letter = start_letter
+        self.letter_count = letter_count
+        self.bytes_per_letter = (int(
+            (self.height - 1) / 8) + 1) * self.width + 1
+        self.load_xglcd_font(path)
+        self.char_spacing = char_spacing
+        self.line_spacing = line_spacing
+
+    def load_xglcd_font(self,font_filename):
+        print(font_filename)
+        self.letters = bytearray(self.bytes_per_letter * self.letter_count)
+        offset=0
+        with open(font_filename, 'r') as f:
+                for line in f:
+                    # Skip lines that do not start with hex values
+                    line = line.strip()
+                    if len(line) == 0 or line[0:2] != '0x':
+                        continue
+                    # Remove comments
+                    comment = line.find('//')
+                    if comment != -1:
+                        line = line[0:comment].strip()
+                    # Remove trailing commas
+                    if line.endswith(','):
+                        line = line[0:len(line) - 1]
+                    # Convert hex strings to bytearray and insert in to letters
+                    self.letters[offset: offset + self.bytes_per_letter] = bytearray(
+                        int(b, 16) for b in line.split(','))
+                    offset += self.bytes_per_letter
+    
+    def Get_letter(self,char):
+        init_index=(ord(char)-self.start_letter)*self.bytes_per_letter
+        letter=self.letters[init_index:init_index+self.bytes_per_letter]
+        return(letter)

VGA/VGA_fonts.py

@@ -0,0 +1,198 @@
+# VGA simple plotter by Hugh - May 2025
+from VGA.VGA_fonts import Font
+
+# 3 bit color names
+RED     = 0b001
+GREEN   = 0b010
+BLUE    = 0b100
+YELLOW  = 0b011
+BLACK   = 0
+WHITE   = 0b111
+CYAN    = 0b110
+MAGENTA = 0b101
+
+
+class Plot:
+    """A two dimensionnal plot object for the VGA 800x600 display.
+
+    Note:  All coordinates are zero based.
+    """
+
+    def __init__(self, display, ul_x=1, ul_y=1, br_x=400, br_y=300,ax_color=WHITE, min_x=0,\
+                 max_x=100, min_y=0, max_y=100, x_ticks_num=10,y_ticks_num=10):
+        """Initialize plot.
+
+        Args:
+            display : the VGA screen object
+            ul_x,y :  upper left coordinates of the rectangle plotting area (including ticks)
+            br_x,y :  bottom righy coordinates of the rectangle plotting area (including ticks)
+            ax_color : color of the axes and ticks
+            plot_color : color of the plot
+            min_max_x_y : min/max values of the x and y axes
+        """
+        #set parameters
+        self.display=display
+        self.ul_x=ul_x
+        self.ul_y=ul_y
+        self.br_x=br_x
+        self.br_y=br_y
+        self.ax_color=ax_color
+        self.min_x=min_x
+        self.max_x=max_x
+        self.min_y=min_y
+        self.max_y=max_y
+        self.x_ticks_num=x_ticks_num
+        self.y_ticks_num=y_ticks_num
+        # Load a small font
+        self.x_font_size=8
+        self.y_font_size=10
+        self.display.font=Font('fonts/Small_Fonts8x10.c', self.x_font_size, self.y_font_size,char_spacing=0, line_spacing=1)
+        # Define and draw plotting area (taking out space for the ticks and labels)
+        self.tick_size=3
+        self.top_margin=int(self.y_font_size/2)+1
+        self.bottom_margin=12
+        self.left_margin=20
+        self.x_origin=self.ul_x+self.left_margin
+        self.x_range=self.br_x-self.x_origin
+        self.y_origin=self.br_y-self.bottom_margin
+        self.y_range=self.y_origin-self.top_margin-self.ul_y
+        self.display.draw_rect(self.ul_x+self.left_margin, self.ul_y+self.top_margin, self.br_x, self.br_y-self.bottom_margin,self.ax_color)
+        self.display.settextcolor(self.ax_color)
+        # prepare for legend
+        self.line_labels=[]
+        self.line_colors=[]
+        #draw axes
+        self.draw_axes_x()
+        self.draw_axes_y()
+        
+    def draw_axes_x(self):
+        # draw ticks
+        for i in range(self.x_ticks_num+1):
+            x_tick=self.ul_x+self.left_margin+int(i*self.x_range/self.x_ticks_num)
+            self.display.draw_fastVline(x_tick,self.br_y-self.bottom_margin-self.tick_size,self.br_y-self.bottom_margin,self.ax_color)
+            x_tick_val=str(round(self.min_x+(i*(self.max_x-self.min_x)/self.x_ticks_num),2))
+            self.display.settextcursor(x_tick-int(self.display.strlen(x_tick_val)/2), self.br_y-self.bottom_margin+1)
+            self.display.printh(x_tick_val)
+            
+    def draw_axes_y(self):
+        # draw ticks
+        for i in range(self.y_ticks_num+1):
+            y_tick=self.br_y-self.bottom_margin-int(i*self.y_range/self.y_ticks_num)
+            self.display.draw_fastHline(self.ul_x+self.left_margin,self.ul_x+self.left_margin+self.tick_size,y_tick,self.ax_color)
+            self.display.settextcursor(self.ul_x, y_tick-int(self.y_font_size/2))
+            y_tick_val=round(self.min_y+(i*(self.max_y-self.min_y)/self.y_ticks_num),2)
+            self.display.printh(str(y_tick_val))
+
+    def draw_labels(self):
+        x1_line=self.x_origin+10
+        for i in range(len(self.line_labels)):
+            y1_line=self.top_margin+self.ul_y+int(self.y_font_size/2)+i*self.y_font_size+1
+            self.display.draw_fastHline(x1_line,x1_line+10,y1_line,self.line_colors[i])
+            self.display.settextcursor(x1_line+10+2, y1_line-int(self.y_font_size/2))
+            self.display.settextcolor(self.line_colors[i])
+            self.display.printh(self.line_labels[i])
+
+
+class Line:
+    """An x.y graph object (line) for the VGA 800x600 display.
+
+    Note:  All coordinates are zero based.
+    """
+
+    def __init__(self, plot, x_data, y_data, line_color=GREEN,label="unknown"):
+        """Initialize line.
+
+        Args:
+            plot : the VGA 800x600 plot object
+            x_data :  list of x values
+            y_data :  list of y value
+            plot_color : color of the line
+        """
+        #set parameters
+        self.plot=plot
+        self.x_data=x_data
+        self.y_data=y_data
+        self.x_pixdata=[]
+        self.y_pixdata=[]
+        self.color=line_color
+        self.plot.line_labels.append(label)
+        self.plot.line_colors.append(self.color)
+        self.plot.draw_labels()
+        self.is_first_point=True
+        #draw line
+        if len(self.x_data):
+            self.draw()
+        
+    def draw(self):
+        for i in range(len(self.x_data)):
+            plotx=self.plot.x_origin+int((self.x_data[i]*self.plot.x_range/(self.plot.max_x-self.plot.min_x)))
+            ploty=self.plot.y_origin-int((self.y_data[i]*self.plot.y_range/(self.plot.max_y-self.plot.min_y)))
+            if i>0:
+                self.plot.display.draw_line(self.x_pixdata[-1],self.y_pixdata[-1],plotx,ploty,self.color)
+            else :
+                self.plot.display.draw_pix(plotx,ploty,self.color)
+            self.x_pixdata.append(plotx)
+            self.y_pixdata.append(ploty)
+
+    def add_data(self,x,y):
+        if not len(self.x_data):
+            plotx=self.plot.x_origin+int((x*self.plot.x_range/(self.plot.max_x-self.plot.min_x)))
+            ploty=self.plot.y_origin-int((y*self.plot.y_range/(self.plot.max_y-self.plot.min_y)))
+            self.plot.display.draw_pix(plotx,ploty,self.color)
+            self.x_data.append(x)
+            self.y_data.append(y)
+            self.x_pixdata.append(plotx)
+            self.y_pixdata.append(ploty)
+        else:
+            plotx=self.plot.x_origin+int((x*self.plot.x_range/(self.plot.max_x-self.plot.min_x)))
+            ploty=self.plot.y_origin-int((y*self.plot.y_range/(self.plot.max_y-self.plot.min_y)))
+            self.plot.display.draw_line(self.x_pixdata[-1],self.y_pixdata[-1],plotx,ploty,self.color)
+            self.x_pixdata.append(plotx)
+            self.y_pixdata.append(ploty)
+            self.x_data.append(x)
+            self.y_data.append(y)
+ 
+    def add_data_ns(self,x,y,draw_line=True):
+        # add_dat without storage (saves memory) 
+        if self.is_first_point:
+            self.plotx0=self.plot.x_origin+int((x*self.plot.x_range/(self.plot.max_x-self.plot.min_x)))
+            self.ploty0=self.plot.y_origin-int((y*self.plot.y_range/(self.plot.max_y-self.plot.min_y)))
+            self.plot.display.draw_pix(self.plotx0,self.ploty0,self.color)
+            self.is_first_point=False
+        else:
+            plotx=self.plot.x_origin+int((x*self.plot.x_range/(self.plot.max_x-self.plot.min_x)))
+            ploty=self.plot.y_origin-int((y*self.plot.y_range/(self.plot.max_y-self.plot.min_y)))
+            if draw_line:
+                self.plot.display.draw_line(self.plotx0,self.ploty0,plotx,ploty,self.color)
+                self.plotx0=plotx
+                self.ploty0=ploty
+            else :
+                self.plot.display.draw_pix(plotx,ploty,self.color)
+
+    def add_data_moy(self,x,y,num_samples=5):
+        # add_dat with mean calc over the last num_samples values
+        # we only store the last num_samples value
+        if not len(self.y_data):
+            plotx=self.plot.x_origin+int((x*self.plot.x_range/(self.plot.max_x-self.plot.min_x)))
+            ploty=self.plot.y_origin-int((y*self.plot.y_range/(self.plot.max_y-self.plot.min_y)))
+            self.plot.display.draw_pix(plotx,ploty,self.color)
+            for i in range(num_samples):
+                self.y_data.append(y)
+                self.x_pixdata.append(plotx)
+                self.y_pixdata.append(ploty)
+        else:
+            y_last_sum=0
+            for val in self.y_data:
+                y_last_sum+=val
+            y_mean=(y+y_last_sum)/(num_samples+1)
+            y=y_mean
+            plotx=self.plot.x_origin+int((x*self.plot.x_range/(self.plot.max_x-self.plot.min_x)))
+            ploty=self.plot.y_origin-int((y*self.plot.y_range/(self.plot.max_y-self.plot.min_y)))
+            self.plot.display.draw_line(self.x_pixdata[-1],self.y_pixdata[-1],plotx,ploty,self.color)
+            self.x_pixdata.pop(0)
+            self.x_pixdata.append(plotx)
+            self.y_pixdata.pop(0)
+            self.y_pixdata.append(ploty)
+            self.y_data.pop(0)
+            self.y_data.append(y)
+ 

VGA/VGA_plot.py

@@ -0,0 +1,83 @@
+# Hugmaingauche 2025
+# test file for use with the micropython VGA library
+# https://github.com/HughMaingauche/PICO2-VGA-Micropython
+
+from VGA.VGA_fonts import Font
+from VGA.VGA_800x600 import screen_800x600
+
+display = screen_800x600()
+display.VGA_init()
+
+# 3 bit color names
+RED     = 0b001
+GREEN   = 0b010
+BLUE    = 0b100
+YELLOW  = 0b011
+BLACK   = 0
+WHITE   = 0b111
+CYAN    = 0b110
+MAGENTA = 0b101
+
+text1="L\'est s\'empourpra d\'une teinte de vieux sang et bientot \
+le soleil apparut, tremblant comme un vieillard frileux. Le sol etait voile de brume ; Cugel pouvait a peine se rendre compte \
+qu\'ils passaient au-dessus d\'une contree de noires montagnes et de gouffres tenebreux.\n"
+
+display.draw_rect(1,1,display.H_res,display.V_res,GREEN)
+
+print('Loading fonts...')
+
+print('Loading Arial')
+display.font=Font('fonts/Arial13x13.c', 13, 13)
+display.settextcolor(CYAN)
+display.printh("Arial13x13: ")
+display.settextcolor(WHITE)
+display.printh(text1+"\n")
+
+
+print('Loading Calibri')
+display.font=Font('fonts/Calibri12x11.c', 12, 11)
+display.settextcolor(MAGENTA)
+display.printh("\nCalibri12x11: ")
+display.settextcolor(WHITE)
+display.printh(text1+"\n")
+
+# 
+print('Loading Cascadia')
+display.font=Font('fonts/Cascadia_Code7x14.c', 7, 14)
+display.settextcolor(BLUE)
+display.printh("\nCascadia_Code7x14: ")
+display.settextcolor(WHITE)
+display.printh(text1+"\n")
+# 
+print('Loading robotronsmall')
+display.font=Font('fonts/Robotron7x11.c', 7, 11, start_letter=32, letter_count=96)
+display.settextcolor(GREEN)
+display.printh("ROBOTRON7X11: ")
+display.settextcolor(WHITE)
+display.printh(text1+"\n")
+# 
+print('Loading Small_Fonts7x8.c')
+display.font=Font('fonts/Small_Fonts7x8.c', 7, 8, start_letter=32, letter_count=96,char_spacing=1, line_spacing=2)
+display.settextcolor(RED)
+display.printh("Small_Fonts7x8: ")
+display.settextcolor(WHITE)
+display.printh(text1+"\n")
+# 
+print('Loading Small_Fonts9x11.c')
+display.font=Font('fonts/Small_Fonts9x11.c', 9, 11, start_letter=32, letter_count=96,char_spacing=1, line_spacing=2)
+display.settextcolor(YELLOW)
+display.printh("Small_Fonts9x11: ")
+display.settextcolor(WHITE)
+display.printh(text1+"\n")
+
+
+
+print('Fonts loaded.')
+# 
+# Drawing a simple 8 color checker
+for h in range(6,10):
+    for i in range(0,60):
+        for k in range(10):
+            col=(h+k)%8
+            display.draw_fastHline(k*80,k*80+80,h*60+i,col)
+#