nathan_lusk = software_engineer;

ether32_hal

REMOTE REPOSITORY: https://github.com/nlcodes/ether32_hal

ABOUT:

(from project readme)

Update_14: Complete stm32_hal project: MARCH 2025

commit a7d6e2f60487f86aa0565fd0fbe636a98edeb9a4
Date: Sat Mar 15 23:44:17 2025 -0700
Create function for scaling binary bitmaps 2x

LOG: This update cover the whole of March 2025. Similar to the last update, I have been very busy and making progress on the hal project whenever possible. All of the logs, as usual are available on github. I accomplished a decent amount of work inlcuding, implementing interrupt driven delays across the entire library. I did a lot of general design refactoring, added various functions to the hal, updated and added essential documentation, and tested all capabilities of the hal. Everything works as intended with my hardware so far. There may be more updates improve the functionality, refactoring the codebase, etc. But, the first working version is officially released! Before release, I also changed the name of the project from stm32_hal to ether32_hal. Reasons for the name change are included in the project readme. I was able to create several small videogames and simulations with the hal using my oled and button boards attatched to my breadboard with jumper wires. After completing this, I have already began working on implementing it in my next project. This will be an action puzzle game written for my peripherals and microcontoller, which I will be making a finished hardware build for to run the game. I also started writing a different game using my library for the hardware that I may very well complete when time allows. Writing this Library was a challenge, and I learned a huge amount about close to metal programming. It feels amazing to write my own init code and hal library from the ground up, rather than following the common path of using gui software, or prewritten libraries for a hardware abstraction layer. Now I can re use this in other programs I write needing these peripherals. The modular nature of the library will allow me to easily update it as needed.

Update_13: Create basic first version of stm32_hal project: FEB 2025

commit ec94605fa8614eb34af152e892c947487e60cd15
Date: Tue Feb 25 01:39:12 2025 -0800

LOG: This update covers the whole of Feb 2025, as I accomplished a solid amount of programming and made significant progress on my goals during this month. So, I did not have time to update my website. The commit history is also available on github for further review. To summarize the main things I accomplished for stm32_hal: I had already created the essential code for most of the drivers used in the hal, so this month included building the base for the hal, linking all the drivers to the central file and creating the base version of the library. This version included init code and abstracted hal code calling upon it, for all peripherals the library will initially support. These include an Adafruit 128x64 oled display, a 4x4 button board, and the built in test led on the pcb. So, this version supported basic functions for all of them, and all tests were passed. I had a working version but! next I wanted to implement timer interrupts. This was a design choice made to improve startup, program functioning, and add a cohesive system of timer delays. This also makes the library more modular and gives the user precise control of timing, compared to using busy loops in the first version. So, I also began implementing this system near the end of the month. Lastly, while the hal project remains 100% c code, I did implement a make script using gambit scheme lisp which one can call to build their c project using the library with supported peripherals. I also got a new keyboard which I'm really enjoying, and went camping this month! The keyboard has less keys than usual and speeds up my workflow a lot. My camping trip was amazing and a much needed break from daily life. I came back feeling refreshed and ready to complete my project. :)

Update_12: Scheme lisp c utils

commit bbe7e4e3e2cd85bd53de21220f74ec7c90afa0cc
Date: Sun Feb 2 23:58:58 2025 -0800
Create c utils for for scheme program; rewrite gambit include syntax for c libraries

LOG: I have recently taken a great interest in the lisp programming language. I'm specifically interested in scheme lisp, more specifically gambit scheme. I love the clean straightfowrard syntax lisp provides, as well as its "free" nature. The language is extremely flexible and recursive which is unique, and I very much appreciate it. It seems like a powerful tool for scripting, as well as extending c's functionality beyond its scope; Which justifies its value to me. While I'm not typically a fan of higher level abstraction, lisp appears as something rather special. That being said I am happy to add it to my toolkit for a higher level option when needed regarding scripting, prototyping, etc. In this update I have written a lisp utility for gambit programming. For those not aware, gambit takes lisp code and can compile directly to c. One may also write inline lisp in c using an interpreter. That being said, I have metaprogrammed gambit scheme here in this program to change its own include syntax. This simplifies the syntax in a way I enjoy. While this is a small program, I intend to dive deeper and write more utilities in lisp, which will benefit my workflow. The possibilities are endless!

Update_11: Oscilloscope sda/3v3 readings

commit unavailable
Date: Wed Jan 28 2025

LOG: I got my rigol dho804 oscilloscope! This device has been very fun to work with. After setting up the scope, I was able to obtain readings on sda data and 3v3 power. Just look at those beautiful waveforms! Now that I know the essentials of operating this machine, I was able to validate i2c protocol data transfer, and steady power flow to components. Even though I already knew i2c was working on my drivers, it's good to see it visualized on the waveform to reinforce there aren't any major issues. Setting up the scope also included compensating each of the probes. I have included screenshots pulled from my scope of the sda waves, 3v3 waves, and conpensation waves (clean squares) below. I'm sure this tool will come in handy with future projects/protocols.

Update_10: Workflow improvements; Install/make st, dwm, and tmux

commit 0ab70047468dd4f0761cd05584644dd857f017a6
Date: Wed Jan 26 2025
Add scrollback reflow patch and resolve conflicts

LOG: Updated workflow to tools which fit my style and needs better. Switched from using i3 window manager and alacritty terminal emulator, to dwm for window manager and st for terminal emulator. After learning about these tools, they seemed like the perfect fit for me. They are written with c, and use minimal lines of code. They come out of the box with minimal features, and expect you to apply patches as needed, add or modify the source code in any way you like, and compile each on your own after you are done with config. This is perfect for my needs and aligns directly with my philosophy. My builds for these can be found at the bottom of my projects page on my site under "Utilities", or on my github. The original versions can be found on suckless.org. Please check them out if you have a minimal design philosophy, like fast efficient software, and don't mind coding and compiling your own tools. I included this as an update because I am very happy with how well they run after the initial setup and would like more people to try it. They have been amazing for my workflow. I also started using tmux to manage windows within my window manager. This has been a game changer as well because it allows me to save sessions of window groups in between reboots; it is a very nice tool as well. Pictures of dwm and st, as well as their configs are included below.

Update_9: stm32_hal

commit b670cb869d204f70be8f0a5ebe2a7f4fa6d413e1
Date: Wed Jan 22 03:08:03 2025 -0800
Create main hal file hal.h; write and include hal files for oled in hal.h; write oled driver files and include in oled hal files

LOG: Organized driver code into hal code (hardware abstraction layer). Forked bare_metal_c into a new repository, which split the project in two. The original bare_metal_c now only includes programs intended to be flashed by themselves directly to mcu, and used to accomplish a small bare metal interaction. I then moved the drivers library to a repository "stm32_hal", and re wrote them to integrate into a larger hal system. The purpose of hal is to make it easy to include, and call upon, drivers through an abstraction layer. This allows for one include "hal.h", instead of targeted driver includes. It makes my driver code easy to use again in future projects, easy to call, and more modular. While I am not generally a fan of abstraction, this abstraction layer is useful to me for modularity, portability, and organization purpose; It is not overly complex, and provides a cohesive framework to manage my drivers.

Update_8: Adafruit oled init/draw success; button board success!

commit 406ab01565cd479e91c0c28b88840768f91605b6
Date: Sun Jan 19 16:27:31 2025 -0800
Create screen_init program; add program to programs dir

LOG: Finished work on screen_init program (handles both init and writing pixels to adafruit oled). This took a little while to complete, and is a big win. This is especially true because just before completing this program, I also finished implementing a button board reading program "button_board_init". This program takes input from my 4x4 button matrix, reads it and flashes test led on my blackpill. Both of these programs have been added to my bare_metal_c programs collection. With both of these driver programs working well, I am well prepared to begin work on the mcu game logic for matrix_break. All required peripherals are now successfully initialized!

Update_7: Begin prototyping for embedded project; create and develop bare_metal_c collection

commit be8897f98e3a948d977df118deb9a78e9a2068eb
Date: Sun Jan 12 22:13:36 2025 -0800
Create program to handle button board inputs which toggle on board led

LOG: Started prototyping with components including a breadboard, jumper wires, an swd programmer, my newly soldered STM32F411 blackpill board, and a button board. The goal of this session was to test my understanding of breadboard wiring and register level programming by writing a program which turns the led on board the blackpill ON while holding a button down and OFF when the button is released. This program was added to a collection of bare metal programs and drivers I have been working on within the directory "bare_metal_c". In my program "button_board_init" which I spoke of earlier, I included one of my drivers called "led_on_off" which allows me to manipulate the state of the blackpill's led depending on inputs with the button board. While writing this low level firmware I have also been learning some basic arm assembly code in the form of my startup.s files for my programs. After making programs which achieve some effect, I have been transposing many of them to driver code which I may then use later in my work.

Update_6: Soldering stm32

commit unavailable
Date: Sun Jan 12 2025

LOG: Finally acquired all my soldering supplies including a hakko iron, stand, cleaner, desoldering wick, and lead free silver solder. While there is room for improvement, I am happy with the results of my session. After a bit of practice, I was able to get some pretty nice looking joints on my board. After testing my peripherals, all solder joints function as expected with their peripheral devices.

Update_5: Begin work on toy_compiler

commit 91eecd47768fbfcef6e013498c9365c415cadc23
Date: Thu Jan 9 23:44:57 2025 -0800
Create initial program logic

LOG: Set up the skeleton and introductory logic for a simple toy compiler program. This project aims to cover all the fundamentals of compiler development while keeping the scope of data it can compile minimal.

Update_4: Second progress update for matrix_break

commit 84495178d4e21cf2e86b87330bc45d56c8e9a4c0
Date: Mon Dec 30 02:30:28 2024 -0800
Add shape placement and rendering into matrix after floor collision

LOG: Made some advancements on the matrix_break pc prototype. Added multiple shape templates, drop logic, and collision detection with the floor of the matrix. Shapes lock in place when colliding with the floor, which triggers new shapes to spawn. Getting close to starting the STM32 version of the game.

Update_3: Begin work on matrix_break program

commit faa3c2b800ccc98a32bee3aaf7e589c275212990
Date: Mon Dec 23 01:19:58 2024 -0800
Create SDL window; add game matrix border and block

LOG: Started work on matrix_break. This program will be a block breaking/matching action puzzle game. It is an embedded systems project written largely in C, with minimal reliance on libraries, apis, etc. The end goal is to have it running on an STM32F microcontroller which is connected to various peripherals. I am currently starting work on this by prototyping the game in SDL2 on my desktop. After that I will port the logic to STM32 firmware. After prototyping the hardware, I intend create a final build of the project using a printed circuit board and enclosure. So far I have rendered an SDL window, game matrix border, and a test block.

Update_2: Second progress update for shell

commit 72e70e29af6decede0b6ccd360bf7b327707a247
Date: Mon Dec 23 01:08:55 2024 -0800
Add clear command functionality

LOG: Progress continues on the shell. I have added exit logic to the program so one is able to leave the shell. I have added tokenizing and processing for command line arguments. The shell now runs basic unix system commands e.g. "ls", with the inclusion of process forking. The prompt display has been updated and the "clear" command has been implemented. Development is going smoothly.

Update_1: Begin work on shell program

commit 24ddc05aa1d3911f0a12978549608bf06af53a8c
Date: Wed Dec 18 00:35:39 2024 -0800
Create input loop; add shell prompt

LOG: Started work on my unix shell program. The goal of this project is to create a shell with similar functionality to bash, while adding some of my own unique features and ideas which will be useful to my personal workflow.