The puzzle: https://adventofcode.com/2023/day/10
My Ada solution: here.
In a picture (generated by the program linked above)...
 |
| Click to enlarge |
It is always a pleasure to display the data created by Eric Wastl.
Here, an improved representation with the five cases (outside tile, inside tile, inside pixel on a path tile, outside pixel on a path tile, path pixel) in shown different colors:
 |
| Click to enlarge |
Note for subscribers: if you are interested in my Ada programming articles only, you can use this RSS feed link.
LEA, the Lightweight Editor for Ada, is based on the Scintilla text editor widget, which excels at colouring syntactic elements and letting the user rework his or her programs very swiftly, including manipulating rectangular selections and adding text on multiple points (usually vertically aligned).
But until recently, the cool features were limited to automatic indentation, adding comment delimiters (--) at the right column, or highlighting portions of text that match a selection.
Users were frustrated by not finding in LEA programming helpers (commonly grouped under the term "smart editor" or "intellisense") that they enjoy in their programming "studios".
An excuse would have been to dismiss such features as out of the scope of a "lightweight" editor.
But we know we can make of LEA a powerful mini-studio, with the ease of use of a simple editor, thanks to its "projectless" mode and the integrated HAC compiler.
So now, it happened.
From revision 385 of LEA (and revision 886 of HAC), you have now a good sense of intellisense:
Some screenshots will help illustrate the above points. Let's start with the sudoku_sample.adb example shipped with the HAC project. What's that "Sudo_Strings" type, for instance?
Just let the mouse pointer hang out around an occurrence of that keyword.
 |
| Mouse hover tip - Click image to enlarge it |
 |
| Go to declaration - Click image to enlarge it |
 |
| Declaration in the Sudoku package - Click image to enlarge it |
 |
| Call tip - Click image to enlarge it |
 |
| Auto-complete - Click image to enlarge it |
In order to develop the last point, here are a few examples on how LEA understands your program "on the fly", while you are typing it:
 |
| Smart editor on an incomplete piece of code - Click image to enlarge it |
 |
| Smart editor on an incomplete piece of code, sample 2 - Click image to enlarge it |
 |
| Smart editor on an incomplete piece of code, sample 3 - Click image to enlarge it |
Some Web links:
LEA
Web site: http://l-e-a.sf.net/
Sources, site #1: https://sf.net/p/l-e-a/code/HEAD/tree/
Sources, site #2: https://github.com/zertovitch/lea
Alire Crate: Alire - LEA
Web site: https://hacadacompiler.sourceforge.io/
Sources, site #1: https://sf.net/p/hacadacompiler/code/HEAD/tree/
Sources, site #2: https://github.com/zertovitch/hac
Alire Crate: Alire - HAC
Enjoy!
Note for subscribers: if you are interested in my Ada programming articles only, you can use this RSS feed link.
Spot the "tool tip" on the following screenshot...
 |
| Click to enlarge |
Translation: cross-references and source code navigation in LEA are becoming a reality since this evening!
Some Web links:
LEA
Web site: http://l-e-a.sf.net/
Sources, site #1: https://sf.net/p/l-e-a/code/HEAD/tree/
Sources, site #2: https://github.com/zertovitch/lea
Alire Crate: Alire - LEA
Since LEA embeds the HAC compiler, here are a few links about HAC as well:
HAC
Web site: https://hacadacompiler.sourceforge.io/
Sources, site #1: https://sf.net/p/hacadacompiler/code/HEAD/tree/
Sources, site #2: https://github.com/zertovitch/hac
Alire Crate: Alire - HAC
HAC (the HAC Ada Compiler) was since the first of its previous lives, from Pascal-S, in 1973, to recent commits, translating high-level language exclusively to the machine code of a fictitious machine (a Virtual Machine, abbreviated VM).
For writing a tiny compiler, a VM is very convenient:
The HAC VM and its users are enjoying all these advantages.
However, there is a flip side:
Well, so far, the latter blame was objectively correct regarding HAC until a few weeks ago.
Now it is changing!
We have begun an abstract framework for emitting machine code.
With that framework, HAC can, on demand, emit code for its captive VM or for any implemented machine.
So you read well, it is not a just-in-time compiler translating VM instructions to native ones.
We are implementing a direct Ada-to-native compiler - and cross-compiler, since HAC doesn't know on which machine it is running!
The framework looks like this:
with HAC_Sys.Defs;
package HAC_Sys.Targets is
type Machine is limited interface;
type Abstract_Machine_Reference is access Machine'Class;
--------------------
-- Informations --
--------------------
function Name (m : Machine) return String is abstract;
function CPU (m : Machine) return String is abstract;
function OS (m : Machine) return String is abstract;
function Null_Terminated_String_Literals (m : Machine) return Boolean is abstract;
----------------------------
-- Machine Instructions --
----------------------------
procedure Emit_Arithmetic_Binary_Instruction
(m : in out Machine;
operator : Defs.Arithmetic_Binary_Operator;
base_typ : Defs.Numeric_Typ) is abstract;
...
The code emission in the compiler is being changed (very slowly, be patient!) for going through this new abstract machine mechanism.
So far we have two implementations:
The development for multiple targets is embryonic so far.
However, we can already compile a "hello world"-style program:
with HAT;
procedure Native is
use HAT;
a : Integer;
begin
-- a := 1; -- Variables: TBD.
Put_Line ("Hello ...");
Put_Line ("... world!");
Put_Line (12340 + 5);
Put_Line (12350 - 5);
Put_Line (2469 * 5);
Put_Line (61725 / 5);
end Native;
With the command:
hac -tamd64_windows_console_fasm native.adb
HAC produces this:
; Assembler file for the Flat Assembler - https://flatassembler.net/
format PE64 console
entry _start
include 'include\win64a.inc'
section '.code' code readable executable
_start:
push 9
push 1
push -1
push -1
pop r14
pop r13
pop r12
pop r11
add r12, _hac_strings_pool
ccall [printf], r12
ccall [printf], _hac_end_of_line
push 10
push 11
push -1
push -1
pop r14
pop r13
pop r12
pop r11
add r12, _hac_strings_pool
ccall [printf], r12
ccall [printf], _hac_end_of_line
push 12340
push 5
pop r11
pop rax
add rax, r11
push rax
push 20
push 10
push -1
pop r14
pop r13
pop r12
pop r11
ccall [printf], _hac_decimal_format, r11
ccall [printf], _hac_end_of_line
push 12350
push 5
pop r11
pop rax
sub rax, r11
push rax
push 20
push 10
push -1
pop r14
pop r13
pop r12
pop r11
ccall [printf], _hac_decimal_format, r11
ccall [printf], _hac_end_of_line
push 2469
push 5
pop r11
pop rax
imul rax, r11
push rax
push 20
push 10
push -1
pop r14
pop r13
pop r12
pop r11
ccall [printf], _hac_decimal_format, r11
ccall [printf], _hac_end_of_line
push 61725
push 5
pop r11
pop rax
xor rdx, rdx
idiv r11
push rax
push 20
push 10
push -1
pop r14
pop r13
pop r12
pop r11
ccall [printf], _hac_decimal_format, r11
ccall [printf], _hac_end_of_line
stdcall [ExitProcess],0
section '.data' data readable writeable
_hac_end_of_line db 10, 0
_hac_decimal_format db "%d", 0
_hac_strings_pool db "XHello ...", \
0, "... world!", 0
section '.idata' import data readable
library kernel,'kernel32.dll',\
msvcrt,'msvcrt.dll'
import kernel,\
ExitProcess,'ExitProcess'
import msvcrt,\
printf,'printf'
As you can see, the assembler code needs badly some simplification, but, anyway: it works.
FASM produces from it a relatively small 2048-byte executable which writes
Hello ...
... world!
12345
12345
12345
12345
The executable is full of zeroes, due to alignments. The non-zero bytes (more or less, the actual machine code and data) take 605 bytes.
Some Web links for HAC:
Main URL: https://hacadacompiler.sourceforge.io/
Sources, site #1: HAC Ada Compiler download | SourceForge.net
Sources, site #2: GitHub - zertovitch/hac: HAC Ada Compiler - a small, quick Ada compiler fully in Ada
Alire Crate: Alire - Hac
Main URL: https://hacadacompiler.sourceforge.io/
Sources, site #1: HAC Ada Compiler download | SourceForge.net
Sources, site #2: GitHub - zertovitch/hac: HAC Ada Compiler - a small, quick Ada compiler fully in Ada
Alire Crate: Alire - Hac
What’s new:
Login
exit statement: exit Loop_Name.exit Loop_Name.(i)(j) (array of array) and (i, j) (multi-dimensional array) are no more treated as equivalent (this feature was a remnant of the Pascal syntax).+, -, & for strings) are visible without prefix only in the scope of a use HAT clause.Note that correct Ada programs, in relation to the above points, were already accepted and parsed correctly by HAC before that change.
Finally, a bit of cosmetics in the build messages:
C:\Ada\hac\exm>..\hac -v2 -c pkg_demo.adb
*******[ HAC ]******* HAC is free and open-source. Type "hac" for license.
[ HAC ] HAC Ada Compiler version 0.26, 08-Jul-2023
[ HAC ] Compiling main: pkg_demo.adb
[ HAC ] | Compiling x_pkg_demo_s.ads (specification)
[ HAC ] \ Compiling x_pkg_demo_s1.ads (specification)
[ HAC ] \ Compiling x_pkg_demo_s11.ads (specification)
[ HAC ] / x_pkg_demo_s11.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s12.ads (specification)
[ HAC ] / x_pkg_demo_s12.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s13.ads (specification)
[ HAC ] / x_pkg_demo_s13.ads: done.
[ HAC ] / x_pkg_demo_s1.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s2.ads (specification)
[ HAC ] \ Compiling x_pkg_demo_s21.ads (specification)
[ HAC ] / x_pkg_demo_s21.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s22.ads (specification)
[ HAC ] / x_pkg_demo_s22.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s23.ads (specification)
[ HAC ] / x_pkg_demo_s23.ads: done.
[ HAC ] / x_pkg_demo_s2.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s3.ads (specification)
[ HAC ] \ Compiling x_pkg_demo_s31.ads (specification)
[ HAC ] / x_pkg_demo_s31.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s32.ads (specification)
[ HAC ] / x_pkg_demo_s32.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s33.ads (specification)
[ HAC ] / x_pkg_demo_s33.ads: done.
[ HAC ] / x_pkg_demo_s3.ads: done.
[ HAC ] | x_pkg_demo_s.ads: done.
[ HAC ] | Compiling x_pkg_demo_m.ads (specification)
[ HAC ] | x_pkg_demo_m.ads: done.
[ HAC ] | Compiling x_pkg_demo_b.ads (specification)
[ HAC ] | x_pkg_demo_b.ads: done.
[ HAC ] Compilation of pkg_demo.adb (main) completed
[ HAC ] ------ Compilation of eventual with'ed unit's bodies
[ HAC ] | Compiling x_pkg_demo_s.adb (body)
[ HAC ] | x_pkg_demo_s.adb: done.
[ HAC ] | Compiling x_pkg_demo_s1.adb (body)
This note covers some of the considerations that’ll apply when running Alire on macOS.
Read more »- Support the flex options `%option output`, `%option nooutput`, `%option yywrap`, `%option noinput`,
`%option noyywrap`, `%option unput`, `%option nounput`, `%option bufsize=NNN` to better control the
generated `_IO` package.
they are embedded with [Advanced Resource Embedder](https://gitlab.com/stcarrez/resource-embedder)
or change the default function name
Example of `%option` directives to tell Aflex(https://github.com/Ada-France/aflex) to avoid generating several function or procedures and customize the buffer size.
```Ada %option nounput %option noinput %option nooutput %option noyywrap %option bufsize=1024 ```
The tool supports some code block injection at various places in the generated scanner. The code block has the following syntax where `<block-name>` is the name of the code block:
```Ada %<block-name> {
-- Put Ada code here
} ```
The `%yytype` code block can contain type declaration, function and procedure declarations. It is injected within the `YYLex` function in the declaration part. The `%yyinit` code block can contain statements that are executed at beginning of the `YYLex` function. The `%yyaction` code block can contain statements that are executed before running any action. The `%yywrap` code block can contain statements which are executed when the end of current file is reached to start parsing a next input.
- Support the Bison `%define variable value` option to configure the parser generator - Support the Bison `%code name { ... }` directive to insert code verbatim into the output parser - Recognize some Bison variables `api.pure`, `api.private`, `parse.error`, `parse.stacksize`,
`parse.name`, `parse.params`, `parse.yyclearin`, `parse.yyerrok`, `parse.error`
they are embedded with [Advanced Resource Embedder](https://gitlab.com/stcarrez/resource-embedder)
The generator supports two code block injections, the first one `decl` is injected in the `YYParse` procedure declaration and the `init` is injected as first statements to be executed only once when the procedure is called. The syntax is borrowed from the Bison parser:
```Ada %code decl {
-- Put Ada declarations
} %code init {
-- Put Ada statements
} ```
Some other Bison like improvements have been introduced to control the generation of the parser code.
``` %define parse.error true %define parse.stacksize 256 %define parse.yyclearin false %define parse.yyerrok false %define parse.name MyParser ```
The easiest way to use Ayacc(https://github.com/Ada-France/ayacc) and Aflex(https://github.com/Ada-France/aflex) is to use Alire(https://github.com/alire-project/alire), get the sources, build them and install them. You can do this as follows:
``` alr get aflex cd aflex_1.6.0_b3c21d99 alr build alr install alr get ayacc cd ayacc_1.4.0_c06f997f alr build alr install ```
Using these tools is done in two steps:
1. a first step to call `aflex` or `ayacc` command with the scanner file or grammar file, 2. a second step to call `gnatchop` to split the generated file in separate Ada files
For example, with a `calc_lex.l` scanner file, you would use:
``` aflex calc_lex.l gnatchop -w calc_lex.ada ```
And with a `calc.y` grammar file:
``` ayacc calc.y gnatchop -w calc.ada ```
To know more about how to write a scanner file or grammar file, have a look at Aflex 1.5 and Ayacc 1.3.0(https://blog.vacs.fr/vacs/blogs/post.html?post=2021/12/18/Aflex-1.5-and-Ayacc-1.3.0) which explains more into details some of these aspects.
By default Aflex(https://github.com/Ada-France/aflex) and Ayacc(https://github.com/Ada-France/ayacc) generate a scanner and a parser which use global variables declared in a generated Ada package. These global variables contain some state about the scanner such as the current file being scanned. The Ayacc(https://github.com/Ada-France/ayacc) parser generates on its side two global variables `YYLVal` and `YYVal`.
Using global variables creates some strong restrictions when using the generated scanner and parser: we can scan and parse only one file at a time. It cannot be used in a multi-thread environment unless the scan and parse is protected from concurrent access. We cannot use easily some grammars that need to recurse and parse another file such as an included file.
The reentrant scanner is created by using the `-R` option or the `%option reentrant` directive. The scanner will then need a specific declaration with a context parameter that will hold the scanner state and variables. The context parameter has its type generated in the `Lexer_IO` package. The `%yydecl` directive in the scanner file must be used to declare the `YYLex` function with its parameters. By default the name of the context variable is `Context` but you can decide to customize and change it to another name by using the `%yyvar` directive.
``` %option reentrant %yyvar Context %yydecl function YYLex (Context : in out Lexer_IO.Context_Type) return Token ```
When the `reentrant` option is activated, Aflex(https://github.com/Ada-France/aflex) will generate a first `Context_Type` limited type in the `Lexer_DFA` package and another one in the `Lexer_IO` package. The generator can probably be improved in the future to provide a single package with a single type declaration. The `Lexer_DFA` package contains the internal data structures for the scanner to maintain its state and the `Lexer_IO` package holds the input file as well as the `YYLVal` and `YYVal` values.
On its side, Ayacc(https://github.com/Ada-France/ayacc) uses the `YYLVal` and `YYVal` variables. By default, it generates them in the `_tokens` package that contains the list of parser symbols. It must not generate them and it must now use the scanner `Context_Type` to hold them as well as the scanner internal state. The setup requires several steps:
1. The reentrant parser is activated by using the `%define api.pure`
directive similar to the [bison %define](https://www.gnu.org/software/bison/manual/html_node/_0025define-Summary.html).
2. The `%lex` directive must be used to define how the `YYLex` function must be called since it now has some
context parameter.
3. The scanner context variable must be declared somewhere, either as parameter to the `YYParse`
procedure or as a local variable to `YYParse`. This is done using the new `%code decl` directive
and allows to customize the local declaration part of the `YYParse` generated procedure.
4. We must give visibility of the `YYLVal` and `YYVal` values defined in the scanner context variable.
Again, we can do this within the `%code decl` directive.
A simple reentrant parser could be defined by using:
```Ada %define api.pure true %lex YYLex (Scanner) %code decl {
Scanner : Lexer_IO.Context_Type;
YYLVal : YYSType renames Scanner.YYLVal;
YYVal : YYSType renames Scanner.YYVal;
} ```
However, this simple form is not really useful as you may need to open the file and setup the scanner to read from it. It is probably better to pass the scanner context as parameter to the `YYParse` procedure. For this, we can use the `%define parse.params` directive to control the procedure parameters. The reentrant parser is declared as follows:
```Ada %lex YYLex (Scanner) %define api.pure true %define parse.params "Scanner : in out Lexer_IO.Context_Type" %code decl {
YYLVal : YYSType renames Scanner.YYLVal;
YYVal : YYSType renames Scanner.YYVal;
} ```
To use the reentrant parser and scanner, we only need to declare the scanner context, open the file by using the `Lexer_IO.Open_Input` procedure and call the `YYParse` procedure as follows:
```Ada
Scanner : Lexer_IO.Context_Type;
...
Lexer_IO.Open_Input (Scanner, "file-to-scan");
YYParse (Scanner);
```
To have a more complete example of a reentrant parser, you may have a look at the following files:
This exercise was prompted by the need for Scripted Testing to be supported by – as far as possible – code generation. The need is for the public or interfacing view of a supporting part (domain) of a system to be able to log calls made to it and to provide values on calls to it, using a scripting mechanism.
Read more »Once you’ve downloaded Alire and begun the Getting Started tutorial, how do you go about actually writing Ada?
Read more »Note for subscribers: if you are interested in my Ada programming articles only, you can use this RSS feed link.
Just as a teaser for the next Advent of Code in 10 1/2 months, we would like to show a few pictures related to last edition. The 25 puzzles, data and solutions can be found here and here. They are programmed with HAC (the HAC Ada Compiler), thus in a small subset of the Ada language. The HAC compiler is very fast, so you run your program without noticing it was ever compiled, which is perfect for completing a programming puzzle.
 |
| Day 22 run with HAC (here, embedded in the LEA environment) |
However, the program will run substantially slower than compiled with a native, optimizing compiler like GNAT.
This is not an issue for most Advent of Code puzzles, but for some, it is, especially on the later days. Fortunately, changing from HAC to GNAT is trivial (just switch compilers), unlike the traditional reprogramming of Python prototypes in C++, for instance.
Day 8's data is a map representing the height of trees. Once the puzzle was solved, I was curious how the forest looked like. Note that different users get different data, so you are unlikely to find a visualisation of exactly your data on the internet.
Day 12's puzzle is a shortest path problem with specific rules and a nice data - a terrain with a hill - which seems designed to trap depth-first-search algorithms into an almost infinite search. The yellowish path is the shortest from the green dot, elevation 'a', to blue dot, elevation 'z'.
The pinkish path is the shortest from the blue dot to any dot with elevation 'a'. Fortunately Dijkstra's algorithm (and perhaps others) allows for such a special criterion regarding the end point.
 |
| Click to enlarge |
For day 22’s puzzle, a walk on a cube’s surface is involved, so it is helpful to sketch it on a piece of paper, cut it and glue the faces. A banana skin of that puzzle is that the example’s layout may be different from the data’s layout. We slipped on that one and ended up gluing and programming the face-to-face transitions for two layouts…
 |
| Click to enlarge |
Other Adaists’ solutions, discussions and pictures can be found here and in the "2022 Day x" threads in the same forum.
The 0.85 version of LEA (the Lightweight Editor for Ada) is available!
Web site: http://l-e-a.sf.net/
Source repository #1: https://sf.net/p/l-e-a/code/HEAD/tree/
Source repository #2: https://github.com/zertovitch/lea
The new version has two main new features:
- Tabs (screenshot below)
- LEA doesn't write scilexer.dll as a file; thus, it runs as a portable application (in the sense: you can run it from a read-only drive directly, without installation)
 |
| Click to enlarge |
Enjoy!
These are notes on building GCC 12.2.0 and GNAT tools for Apple silicon.
There were two main problems:
Note for subscribers: if you are interested in my Ada programming articles only, you can use this RSS feed link.
The 0.84 version of LEA (the Lightweight Editor for Ada) is available!
Web site: http://l-e-a.sf.net/
Source repository #1: https://sf.net/p/l-e-a/code/HEAD/tree/
Source repository #2: https://github.com/zertovitch/lea
This version is essentialy a rework of LEA's ergonomy - we had recently the chance of having a group of young first-time programmers and first-time LEA users to test it!
The main addition is the green Build & Run button, which matches a (less intuitive) menu entry and the F9 key.
 |
| Click screenshot to enlarge |
Another addition is a dedicated box for the "User_Abort" internal Virtual Machine exception, so that the LEA user doesn't take the exception message for an actual error (which would be the case for any other exception).
Before:
Now:
A few weeks ago, Raspberry Pi released the Pico W, an update to the Pico development board with the addition of a wifi chip and trace antenna. As I’ve been using the Pico for many of my projects, I’m excited by the possibility of adding wireless connectivity.
I program in Ada, so I want to add support for the Pico’s wireless controller, CYW43439 to my driver library.
First, a reality check; Raspberry Pi is going to continue producing new microcontrollers and development boards with new features. They’ve put an immense amount of effort into their C/C++ SDK and MicroPython libraries. Do I really want to continue reimplementing their drivers in Ada? Would I be better off just generating a wrapper around their SDK? The Pico SDK is pretty heavily dependent on the CMake build infrastructure right now, so I’d have to figure out how to make that work with Ada. The generated Ada bindings from C code are usually pretty awkward to work with, so I’d have to write a fair bit of code either way. For now I’m going to keep going with my native Ada libraries, but I’m going to keep asking myself if this is a worthwhile effort when good vendor libraries exist.
The wireless chip they’ve chosen, CYW43439, is a beast. Infineon (formerly Cypress, formerly Broadcom) have a public datasheet, which contains information useful to PCB designers and test engineers as well as some rather confusing timing diagrams that contain no actual timing information. The Pico W has an RP2040 connected to the CYW43439 with the "gSPI" interface with both the transmit and receive signals multiplexed onto a single microcontroller pin.
The RP2040’s PIO should be perfect for implementing this sort of odd serial protocol, but I found it to be quite frustrating in this case. The CS, CLK, and DAT signals are not accessible from any test pad or trace that I can find on the Pico W, so I can’t get a logic analyzer connected while the RP2040 is communicating with the CYW43439. I considered buying a standalone module that uses this chip so that I could connect it to some pins I can probe, but I figured I’d try working blind first. I configured the PIO to use some of the Pico’s exposed pins and connected a logic analyzer. At the very least, I can get the CS, CLK and DAT transmit timing to look correct before trying to talk to the wireless controller.
The datasheet says that the device needs up to 50ms after pulling REG_ON high before it’ll respond to gSPI commands. The host should poll the registers beginning at address 0x14 for the value 0xFEEDBEAD. Once that value is read correctly, a test write/readback at address 0x18 verifies that the gSPI bus is working and the CYW43439 is powered up and ready to accept commands.
That 0xFEEDBEAD value led to some interesting search results; this protocol has been used in Broadcom wireless chipsets as far back as the venerable WRT54G router. There are many open source drivers of varying quality for this family of chips and it seems that Broadcom/Cypress/Infineon kept the host interface mostly the same over the years, only adding new commands when necessary. I found a very detailed writeup about reverse engineering the firmware for these chips, which was quite interesting, if not immediately useful.
The Pico SDK has a PIO driver for gSPI, so I spent a lot of time reading that code and trying to understand it. They use a single PIO SM to control the DAT signal, with CLK configured as a side-set. To begin a transfer, the host CPU resets the SM and executes set pindirs, 1 to configure DAT as an output, then sets the x register to the number of bits to write and y to the number of bits to read. These instructions are not included in the main PIO program as they’re not timing critical and executing them from the CPU saves on PIO memory, which is only 32 instructions. The PIO program shifts one bit out on the DAT pin, toggles the CLK sideset, then decrements the x register. Once x reaches zero, DAT is reconfigured as an input and the SM starts shifting in bits, decrementing y as it goes.
This seems fairly reasonable. We can control the number of bits per word by changing the x and y registers before beginning a transaction. The host CPU needs to get involved after each TX/RX cycle to reset the pindirs, x, and y registers and pull CS high if the transaction has completed. The driver code uses DMA to send data to the PIO, which doesn’t seem like a huge benefit when the CPU is going to intervene after every word transferred. The DMA controller can do byte swapping, which may be useful for big endian network data, but I’m not sure if it’s worth the trouble in this case.
I decided that I’d rather use up a bit more PIO memory and have separate programs for read and write that do their own setting of pindirs and the x register. The CPU still needs to control CS though, which is inconvenient. I really wish the PIO had just a few more Delay/Side-Set bits so that we could have longer delays in PIO programs for timing the CS "back porch."
The CYW43439 datasheet also illustrates a "Read-Write" transaction, where CS stays low between the Write and Read commands. The datasheet says there should be a "fixed delay" in between read and write in this mode. The diagram shows four clock edges during this delay time and there is a bus configuration register for delay timing, but I wasn’t able to get this working. As far as I know, this is just an optimization, not a required bus mode.
Speaking of optimizations, the CYW43439 defaults to 16-bit words on the gSPI interface, but the command to switch to 32-bit mode is 2 16-bit words long, so we can send that as the first command and never have to deal with changing word sizes. As far as I can tell, this is what every driver does.
After spending far too long trying to make my program block until the SM finished clocking bits and wondering if the idle polarity of the clock really matters, I got a logic analyzer trace that looked reasonably close to what the datasheet specifies. I changed my pin config to connect the PIO to the wireless controller and got some signs of life! Polling the 0x14 register returned 0xED 0xFE, which was half of my expected 0xFEEDBEAD with swapped bytes. I played with the PIO SHIFTCTRL register a bit and got a successful read of 0xFEEDBEAD. Surprisingly, the test write/readback worked too! I guess that means I have a working gSPI implementation on PIO! I noticed that the Pico SDK runs the PIO at 33 MHz for this interface, but my test program fails at anything faster than 20 MHz. I guess I still need to get a probe on those DAT, CLK, and CS traces to get the timing right. The datasheet says this interface can run at 50 MHz, but we can worry about that later.
Now that I can communicate with the CYW43439, I started looking at cyw43-driver more seriously. The datasheet makes no mention of most of the CYW43439’s internal registers and this is not a trivial driver, so I’m going to try to interoperate with this C driver from Ada, rather than trying to rewrite it. It looks like this driver calls a bunch of symbols like cyw43_hal_pin_config that we need to provide. Luckily, exporting Ada procedures as symbols that conform to the C ABI is easy.
procedure HAL_Pin_Config (Pin, Mode, Pull, Alt : Interfaces.C.int) with Export, Convention => C, External_Name => "cyw43_hal_pin_config";
On the more complex side of things, we need a TCP/IP stack. cyw43 only contains bindings for LwIP and that’s what Pico SDK uses, so I went searching for Ada bindings for LwIP. Surely someone else has tried to do embedded networking in Ada before, right?
Right! I found a directory called ipstack buried in the SPARK unit tests. If the README is to be believed, this is a formally verified rewrite of a large chunk of LwIP in SPARK. Excellent! This code predates the Alire package manager by many years, so I spent some time understanding the existing Makefiles and hierarchy of GPRbuild projects and got the whole mess built as an Alire crate I can use as a dependency. There’s a lot of room for improvement here, but I want to get some packets flowing before I start trying to improve the IP implementation. If this works at all, I’ll be impressed.
The ipstack library only has two hardware drivers: a minimal TUN/TAP implementation for testing on a Linux host and a driver for the ancient NE2000 ISA card. I spent many hours learning about firewalls with OpenBSD on a 486 with a couple of NE2K cards in my formative years, so this brings back fond memories. Back in the day, the NE2000 was not the fastest network card you could buy, but it was cheap, reliable, and rock solid under Linux, which was far from a guarantee for any peripheral back then.
So now I have three bits of code to string together: my Ada/PIO gSPI implementation, the SPARK ipstack, and cyw43-driver.
Stay tuned for my next post, where I might actually get something working.
Here is an example to illustrate how the HAC compiler is embedded in an Ada application.
The user of the application has typically only an executable (built with a "full Ada" system like GNAT) and an "Ada-pplet" (can be a few lines) that is run from that executable.
Normally, applications have different languages for building the application and for the embedded script system: Excel is written in C/C++ but embeds VBA (Visual Basic for Applications). 3D Studio Max has MaxScript. GIMP uses Script-fu, a variant of Scheme. Others use Lua or Python. Of course nobody would think about shipping a software with a scripting language where you have to fight with pointers and conditional compilation (C/C++).
But... how about an application that is written in a compiled language, but is using the same language for its scripting purposes? Since a few days, it is possible with HAC (the HAC Ada Compiler).
If you build the demo exchange_hac_side.adb (e.g. from GNAT Studio, or via the command "gprbuild hac"), you get an executable, exchange_hac_side on Linux or exchange_hac_side.exe on Windows. If you run it, you get:
Messages as "Native" are from the main application.
Messages as "HAC" are from the small HAC program that is run from the application.
A little disadvantage of having the same language on both sides... is that it is the same language! It could be confusing at first glance. Plus, it is not in the tradition. That may be disturbing for a number of people.
A big advantage of having the same language is that you can share some pieces of code. For instance the following package is used for building the demo application, and compiled by HAC when the application is running!
HAC (HAC Ada Compiler) is a quick, small, open-source Ada
compiler, covering a subset of the Ada language.
HAC is itself fully programmed in Ada.
Web site: http://hacadacompiler.sf.net/
Source repositories:
#1 svn: https://sf.net/p/hacadacompiler/code/HEAD/tree/trunk/
HAC (HAC Ada Compiler) is a quick, small, open-source Ada
compiler, covering a subset of the Ada language.
HAC is itself fully programmed in Ada.
Web site: http://hacadacompiler.sf.net/
From there, links to sources, and an executable for Windows.
Source repositories:
#1 svn: https://sf.net/p/hacadacompiler/code/HEAD/tree/trunk/
#2 git: https://github.com/zertovitch/hac
* Main improvements since v.0.1:
- a program run by HAC can exchange data with the
programm running HAC, through dynamically registered call-backs
- see package HAC_Sys.Interfacing and demos:
src/apps/exchange_native_side.adb
src/apps/exchange_hac_side.adb
- the compiler checks that all choices in a CASE statement
are covered
- the compiler performs more compile-time range checks and
optimizes away useless run-time checks when it's safe to do so.
Enjoy!
Gautier
This exploration came about because of trying to add GNAT Math Extensions to Alire.
Read more »HAC (HAC Ada Compiler) is a quick, small, open-source Ada
compiler, covering a subset of the Ada language.
HAC is itself fully programmed in Ada.
Web site: http://hacadacompiler.sf.net/
From there, links to sources and an executable for Windows.
Source repositories:
#1 svn: https://sf.net/p/hacadacompiler/code/HEAD/tree/trunk/
#2 git: https://github.com/zertovitch/hac
* Main improvements since v.0.0996:
- packages and subpackages are now supported
- modularity: packages and subprograms can be standalone
library units, stored in individual files with
GNAT's naming convention, and accessed from other units
via the WITH clause
- validity checks were added for a better detection of
uninitialized variables.
Package examples and modularity tests have been added.
Particularly, a new PDF producer package with a few demos
is located in the ./exm/pdf directory.
Enjoy!
Gautier
__
PS: for Windows, there is an integrated editor that embeds HAC:
LEA: http://l-e-a.sf.net
PPS: HAC will be shown at the Ada-Europe conference (presentation + tutorial)
http://www.ada-europe.org/conference2022/
