Where I describe the process of developing code for the Arduino Uno(AVR ATmega328P), specifically, the build process.

Introduction (from Edit)#

The middle three steps compile/link/locate are typically called the build process, which can simplify the five steps to three:

1. Edit
2. Build
3. Upload

For a detailed and very worthwhile description of the three steps in Build, I highly recommend this page, Compiling, Link and Locating: Barr Group.

2. Build (compile/link/locate)#

The image is a typical start-up build sequence, I need to cd three times, to get into the specific folder. Once there, I use make clean to ensure I have a clean start (source code and makefile only) then I execute a make flash.

Where I describe the process of developing code for the Arduino Uno(AVR ATmega328P), specifically, editing the code.

Keyboard Commands Cheatsheet (in all applications)#

VS Code Keyboard Commands Cheatsheet#

Terminal Commands Cheatsheet#

Setup Raspberry Pi Development Screen#

This is a a very simple configuration. The left-half of your window is VS Code and the right half of your window is your CLI (terminal application.) Use tabs on both to view multiple files or instances.

Where I describe the process of developing code for the Arduino Uno(AVR ATmega328P), specifically, uploading code to the Uno.

Introduction (from Edit)#

The middle three steps compile/link/locate are typically called the build process, which can simplify the five steps to three:

1. Edit
2. Build
3. Upload

Upload#

Determine the port#

The most important step in uploading to the Uno is to ensure your env.make file is using the correct serial port. The easiest method for this is to plug-in your Uno and use the Arduino IDE and Tools -> Port to identify the port used by the Uno. Here is a screenshot of this process on the Mac:

Where I discuss how to implement and use git to develop code in C for the Arduino Uno.

Sources#

• Beginner’s Guide to Git and GitHub

Introduction#

In this post, I’ll describe how to use git to add the Lab content. I’ll also offer some guidance as to how to use git in your own projects. I am not a git expert and I’ll try not to stray too far from status->add->commit-push…

Where I describe a new error caused by a bug in GCC 12 as it relates to the AVR microcontrollers.

Sources:#

• GCC Bug report
• Another bread crumb

Description#

While debugging a setup script, I ran across this error on my Linux system, however, it didn’t show up on my macOS or Windows computers.

$ make flash
avr-gcc -Os -mcall-prologues -g3 -std=gnu99 -Wall -Werror -Wundef -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums  -ffunction-sections -fdata-sections  -DF_CPU=16000000UL   -DBAUD=9600UL -DSOFT_RESET=0 -I.  -I../../Library -mmcu=atmega328p -c -o main.o main.c
main.c: In function 'main':
main.c:33:9: error: array subscript 0 is outside array bounds of 'volatile uint8_t[0]' {aka 'volatile unsigned char[]'} [-Werror=array-bounds]
   33 |   PORTB &= ~_BV(PORTB5);
      |         ^~
cc1: all warnings being treated as errors
make: *** [<builtin>: main.o] Error 1
$

It does seem rather odd as 0 is certainly not “outside array bounds”, therefor I had no idea as to how to remediate it.

Where I demonstrate the three values of Forth; speed, extensibility and interactive, to develop a better understanding of the ATmega328P.

Sources#

• Flashforth Example on Github

Introduction#

In describing Forth to others, I typically use what I call the “Three Values of Forth”. They are speed, both in execution and development, extensibility, the capability to easily add to the language and interactive, the ability to easily interact with Forth using the serial terminal. It is these three values which make Forth, a great language to use for programming microcontroller boards.

Where I demonstrate how to use make and makefiles to automate your build process.

Update#

While this entry accurately describes how to use a Makefile, the approach has changed significantly. See Developing in C for the ATmega328P: Make, Makefile and env.make for the latest information.

Automate using a Makefile#

We’ll use the Makefile from Elliot William’s book, he has in the folder setupProject. This Makefile is comprehensive and delivers an Arduino IDE type of simplicity with significantly increased speed. I’ve made some changes to it to make it easier to switch between different types of systems. Here is the file:

Where I compare the execution speeds of different combinations of boards and languages. I will continue to update this post with other languages and processor combinations.

Table for the impatient#

Introduction#

While writing about CircuitPython and the FIDI board, I was curious as to the execution speed of CircuitPython on a extremely powerful (relative to the AVR ATmega328) ARM M0+ microcontroller. The M0+ is a modern RISC 32-bit processor with a considerable amount of memory, while the ATmega is 20 year old RISC 8-bit processor with a limited amount of memory. That said, one can’t run CircuitPython on ATmega processors, one must use C or Forth.

Where I discuss what to do once you’ve downloaded a repository from Github.

Introduction#

I’ve advocated using the AVR_C (among others) repository to learn how to use C instead of the Arduino “C++” language. (I write C++ in quotes as while the language used is C++, there are some extensions which some people assume are part of the language, causing more confusion.) In this post, I want to start a short series on using Git as it is extremely helpful, once you begin to develop code. And it becomes mandatory, once you begin using someone’s git repository.

Where I discuss psuedo-random number generators (PRNG), finite state machines (FSM) and other software topics.

Sources#

Mersenne Twister#

• TinyMT - Tiny Mersenne Twister
• TinyMT on GitHub
• Mersenne Twister Readings

Introduction#

This entry covers several topics, random number generation, finite state machines and native programming. All of the code discussed is in AVR_C on GitHub. The objective is to continue to expand on the development of a standard C library for the Arduino Uno and other ATmega328-based microcontroller boards.