Tero's blog

Ahven 2.9 released

2025-09-01T20:30:00+03:00

Ahven 2.9 is now released.

This is a long overdue maintenance release with three changes worth the release notes item:

Alire configuration support
SPDX license identifiers to all source code files
Support for custom Set_Up and Tear_Down procedures for test suites

You can get Ahven 2.9 sources from https://www.ahven-framework.com/releases/ahven-2.9.tar.gz or https://www.ahven-framework.com/releases/ahven-2.9.zip.

The detailed list of changes is at https://hg.sr.ht/~tkoskine/ahven/raw/NEWS.txt?rev=ahven-2.9

Ahven 2.7 released

2018-07-30T22:30:00+03:00

I released Ahven 2.7 last week, but only now I had time to create a blog post about it.

Version 2.7 is pretty normal maintenance release. Probably the most interesting this is fix for Tear_Down procedure, which was not called if a test raised exception.

The bug has been there since the beginning of Ahven (11 years) and only now it was noticed by Jacob Sparre Andersen.

You can get Ahven 2.7 sources from https://www.ahven-framework.com/releases/ahven-2.7.tar.gz

The detailed list of changes is at https://bitbucket.org/tkoskine/ahven/raw/ahven-2.7/NEWS.txt

Ahven 2.5 and 2.6 released

2015-08-30T16:30:00+03:00

It has been about 1.5 years since previous Ahven release. To fix the situation, I released Ahven 2.5 and Ahven 2.6 today.

Ahven 2.6 is almost identical to 2.5, but its documentation contains fixed release dates.

Hosting and other changes

There aren't many code changes. Instead, the build mechanism for GNAT is changed and the hosting of Ahven is also moved to a dedicated site. New release do not appear at SourceForge, since it has been injecting adware to many release packages.

New download location is http://www.ahven-framework.com/releases/

As before, the development version is available from Bitbucket https://bitbucket.org/tkoskine/ahven and mirror site is at http://hg.stronglytyped.org/ahven/ .

The building on Linux using GNAT now happens with comfignat.mk Makefile template. Normal users should not see much changes, but distribution packagers should have better configuration options. The change was a wish from Fedora packagers. One of them, Bjorn Persson, contributed the comfignat scripts for Ahven.

Another change related change is that the documentation needs to be build using Sphinx. Previously, Ahven's release tarballs have included the prebuilt documentation, but this caused some problems for Debian developers because their packaging policy warns about prebuilt things.

Running Ada 2012 on Olimex STM32-E407 (ARM Cortex-M4 / STM32F4)

2014-11-19T20:30:00+02:00

Almost two years after I got my first ARM Cortex-Mx device, I finally found time to build Ada ARM Cortex-M cross-compiler using FSF GCC/GNAT. But, instead of Atmel SAM3, I used STM32F4 processor found from Olimex STM32-E407 board.

Relevant code pieces are sprinkled into three repositories at Bitbucket:

First repository, embedded-arm-gnat-build, contains the build scripts for GNAT (arm-none-eabi target; the script for binutils is missing, you need to install it manually).

The second repository (embedded-arm-gnat-rts) has simple runtime for GNAT. It is almost direct copy of Lucretia's TAMP RTS. The runtime does not have install script, so after building it you need to install the runtime manually.

The third one (gnat-arm-app-skeleton) contains the actual application. I loaned the startup files from mbed project, in case you wonder why there are so many C and assembler files. They could be optimized to two simple assembler files, but I haven't got that far.

The most interesting parts of the app are here:

-- blink.adb, Ada 2012 code
with Interfaces;
with STM32F4;

procedure Blink is
   use type Interfaces.Unsigned_32;

   procedure My_Delay is

      -- Mark X volatile so that GNAT does not optimize
      -- the loop. Notice the new Ada 2012 aspect syntax.
      X : Interfaces.Unsigned_32 := 0 with Volatile;
   begin
      loop
         exit when X = 1000_000;
         X := X + 1;
      end loop;
   end My_Delay;

begin
   STM32F4.RCC_ENABLE := STM32F4.RCC_ENABLE
     or STM32F4.GPIOC_ENABLE_BIT or STM32F4.GPIOD_ENABLE_BIT;

   --                            13 c  b a  9 8  7         3
   STM32F4.GPIOC_MODE  := 2#0000_0101_0101_0000_0000_0000_0000_0000#;
   STM32F4.GPIOC_TYPE  := 2#0000_0000_0000_0000_0000_0000_0000_0000#; -- push-pull
   STM32F4.GPIOC_SPEED := 2#0000_1100_0000_0000_0000_0000_0000_0000#; -- fast
   STM32F4.GPIOC_PUPD  := 2#0000_0000_0000_0000_0000_0000_0000_0000#; -- no pull

   STM32F4.GPIOD_MODE  := 2#0000_0101_0101_0000_0000_0000_0000_0000#;
   STM32F4.GPIOD_TYPE  := 2#0000_0000_0000_0000_0000_0000_0000_0000#; -- push-pull
   STM32F4.GPIOD_SPEED := 2#0000_1100_0000_0000_0000_0000_0000_0000#; -- fast
   STM32F4.GPIOD_PUPD  := 2#0000_0000_0000_0000_0000_0000_0000_0000#; -- no pull

   STM32F4.GPIOC_BSRR  := 2#0111_1000_0000_0000_0000_0000_0000_0000#;
   STM32F4.GPIOD_BSRR  := 2#0000_0000_0000_0000_0011_1100_0000_0000#;
   loop
      STM32F4.GPIOC_BSRR := 2#0111_1000_0000_0000_0000_0000_0000_0000#;
      STM32F4.GPIOD_BSRR := 2#0111_1000_0000_0000_0000_0000_0000_0000#;
      My_Delay;
      STM32F4.GPIOC_BSRR := 2#0000_0000_0000_0000_0111_1000_0000_0000#;
      STM32F4.GPIOD_BSRR := 2#0000_0000_0000_0000_0111_1000_0000_0000#;
      My_Delay;
   end loop;
end Blink;

The program blinks various leds at port C and port D.

On Olimex STM32-E407, which I used for testing, the status led is at port C13. If you use the same board, you should see the led blinking.

Note: My build scripts, GNAT runtime for ARM Cortex-Mx, and other Ada code are still very rough. I just wanted to try is it possible to use FSF GNAT for ARM Cortex-Mx development. As my time permits, I will continue to improve things, but it will take some time.

Building the development version of Ahven

2014-06-04T23:00:00+03:00

The next version of Ahven (2.5) will use comfignat.mk based Makefile system by default. This is done to make the life of Linux, especially Fedora Linux, package managers easier.

comfignat.mk will take care of all the details how to build suitable shared libraries, install the documentation where it belongs, etc. As a downside, the complexity of the building process increases exponentially. Therefore, I decided to explain how one can build parts or all of Ahven using the upcoming Makefile system.

Also, I should note that the layout of the source code files has not changed. You still can use the source code from src and src/unix (or src/windows) directories directly and ignore the Makefile system, which is nicely confined inside gnat directory.

Like-wise, Janus/Ada users are not affected by this change. Scripts in the janusada directory are mostly untouched.

Installing prerequisites

You of course need Ada compiler. FSF GNAT 4.6 or GNAT GPL 20xx is good enough. For the documentation you need Python and packages called sphinx and sphinxcontrib-adadomain. To build the system using comfignat.mk, you need GNU Make. Other Make tools, for example from BSD systems, do not work.

If your Linux distribution does not provide python-sphinx and sphinxcontrib-adadomain packages, it is best to install python-virtualenv package and create virtual environment where to install the other packages.

mkdir -p $HOME/python-virtual/ahven
virtualenv $HOME/python-virtual/ahven
. $HOME/python-virtual/ahven/bin/activate
pip install sphinx
pip install sphinxcontrib-adadomain

Build steps

The top level Makefile contains multiple targets: base, check, check_xml, html, install.

From these, base and check are the most useful ones when developing Ahven itself. Target base will compile the library and check will compile the tests and run them also. Variation of this is check_xml, which will run the tests and output the results in XML format. Various continuous integration systems, like Jenkins, know how to interpret this XML format and produce nice statistics and graphs.

Target html will generate the documentation using sphinx. For this, you need to have sphinx and sphinxcontrib-adadomain packages installed and necessary sphinx binaries available in PATH.

Finally, install will install the library and GNAT project files to the system so all users can use them. Usually, only distribution packagers want to use this.

The default action for the main Makefile is to compile the library and the documentation (default = base + html).

Known issues

comfignat.mk supports gprbuild and gnatmake build tools. gprbuild is more recent and I think that is what Adacore recommends. However, for example, on Ubuntu 14.04 gprbuild does not produce working executables (when used for Ahven). This is why gnatmake is the default.

If you want to use gprbuild, you can change GNAT_BUILDER variable in Makefile to gprbuild. Another word of caution: if you plan to use gprbuild on Fedora, make sure that you have locale settings configured to value "C". Otherwise, gprbuild might fail to build the library.

Example command could be something like this:

LANG=C make OPTS="GNAT_BUILDER=gprbuild"

or:

cd gnat && LANG=C make GNAT_BUILDER=gprbuild

The second command will enter gnat directory first and then run make from there. The main level Makefile will do that automatically, so you don't need to do that usually.

Windows

So far, all of above has applied to Linux and BSD systems with GNAT installed. comfignat.mk should work on Windows also, but you need to have GNU Make, and probably some other Linux tools installed also. These usually can be found via mingw or cygwin projects.

However, I also provide "old style" project file which can be used directly:

gnatmake -p -P gnat/ahven_lib

It only builds the library itself, but usually that should be enough.

I do not get it!

If this still sounds too complicated, you can also compile all of the source code as-is with plain gnatmake and run the resulting tester executable:

gnatmake -aIsrc -aIsrc/unix -aItest tester
./tester

Other compilers

Currently, I provide build scripts only for GNAT and Janus/Ada. In addition to those two compilers, I also regularly test the code with ICCAda, but ICCAda build tools are so easy to use that I haven't bothered to create separate build scripts for it.

For Janus/Ada the compilation process is following:

janusada\prepare.bat
janusada\update.bat
janusada\compile.bat

The first command prepares the Janus/Ada project files and you need to run it only once. The second command scans the source code for changes and determines which source files need to be compiled again. First time you of course need to compile all of the code. The third command then actually compiles the code.

You can combine the second and the third command using build.bat:

janusada\build.bat

Later, when you change some source file and want to recompile the project, you need to run only update.bat and compile.bat or build.bat only. Of course, if you want to do full clean build, then you can run prepare.bat first.

ICCAda users will find the build process very similar:

icm new
icm scan src\*.ad? src\windows\*.ad? test\*.ad?
icm make tester

The first command creates the necessary project files. The second command scans the source code for changes and finally the third command compiles the source code.

Documentation

The documentation is written in reStructuredText format. It is basically plain text with some simple formatting instruction sprinkled here and there. It originates from Python project.

A tool which which converts reStructuredText to HTML is called sphinx. To make sphinx work better with Ada documentation, I have written separate adadomain plugin.

The documentation lives in doc/manual/en/source directory. If you make changes to it, you can run make html which rebuilds the changed parts and places the output to gnat/obj/sphinx/html directory. for sphinx.

Final words

The new comfignat.mk based build system is still somewhat experimental. If you find bugs, please report them to me, so I can fix them before next release (which happens at some point later this year).

If you want to see what a full build of Ahven using some of my compilers looks, you can check it from build.ada-language.com.

The comfignat.mk build system is contributed by Björn Persson. Big thanks to him!

New Ada tips blog

2014-03-14T22:30:00+02:00

Some weeks ago I took an advantage of new domain .tlds and registered ada.tips domain for myself.

My plan is to publish there small tips related to Ada programming language.

In theory, I could publish those tips in this blog also, but I could not resist getting such a short domain for myself.

In addition, I registered a few other Ada related domains, like ada-language.guru, but since I don't feel like guru yet, the web page there is just a place holder for my future plans.

build.ada-language.com fixed

2014-02-18T09:30:00+02:00

I managed to fix build.ada-language.com synchronization problems. Now builds on Windows (and other) systems are updated again.

Ahven 2.4 released

2014-02-09T23:10:00+02:00

Today, I released Ahven 2.4. It is mostly a maintenance release, since despite my plans, I didn't get much done last year. The biggest changes are a compile fix for Apex Ada, documentation improvements, and a comfignat-based build system in contrib/comfignat directory.

I will be making this comfignat-based build system to be default build system for GNAT in Ahven 2.5, but I am already including it to Ahven, so people can get used to it and possibly report bugs.

As usual, you can get the source code from SourceForge.

Build script for NetBSD on Olinuxino-imx233

2014-02-07T22:15:00+02:00

I created a simple build script, which can build NetBSD/evbarm for Olinuxino-imx233 from scratch on Linux system.

Basically, you need to do following:

hg clone https://bitbucket.org/tkoskine/build-netbsd-imx233
cd build-netbsd-imx233
sh -x ./build-imx233.sh

After a while, you have kernel, base system sets, boot partition image (containing the kernel), and rootfs image (containing the sets) built.

However, at the moment, rootfs image is not ready to use. File owners are wrong and the system in general is unconfigured (no /etc/fstab, no /etc/rc.conf settings, ...).

Also, you need to figure out how to create correct partitions to the sd card. While in theory, it is doable from Linux, this is easiest to do from an existing NetBSD system.

Example binaries are available at files.tkoskine.me.

build.ada-language.com status

2013-12-01T11:30:00+02:00

Jenkins update broke the distributed builds, so other than Debian 7 builds at http://build.ada-language.com/ are not updating at the moment.

I am waiting for Jenkins fix and also looking for alternative build systems, but that might take a while.

sphinxcontrib-adadomain 0.1 released

2013-06-12T21:45:00+03:00

After sitting on this 2 years, I finally released version 0.1 of sphinxcontrib-adadomain to Python Package Index (pypi).

See https://pypi.python.org/pypi/sphinxcontrib-adadomain for details.

New web site mirror (domain) for Ahven

2013-06-05T21:45:00+03:00

As a small promotional move, I setup Ahven a dedicated domain/website, www.ahven-framework.com, and also subdomain docs.ahven-framework.com for Ahven documentation. This way Ahven does not need to "live" just at ahven.stronglytyped.org subdomain.

In addition, I put all release tar balls and zip files under releases directory. Now you can skip all the Sourceforge advertisements. The Sourceforge downloads will continue to work, if the /releases/ directory is not accessible for some reason.

Old address (ahven.stronglytyped.org) will also continue to work normally. I don't have any plans to deprecate it. For a while, some links were not working correctly, but I think I have fixed everything now.

Technical details

Originally, I planned to host most of my web sites from a shared web host. But, thanks to someone who submitted my Arduino blog to reddit/r/programming, my shared hosting plan proved to be too small for all the traffic, and I had to find a bigger host. So, now most of the things are hosted on a dedicated OpenBSD server from EDIS.

The web server software is nginx, as it comes with OpenBSD by default these days. In theory, I could also try running Ada Web Server, but making it run on OpenBSD requires some work and I want to concentrate my free time efforts on developing Ahven (and AVR-Ada) instead of it.

OpenBSD 5.3

2013-05-15T21:30:00+03:00

OpenBSD 5.3 cd set, mug, poster, and t-shirt ordered and received - OK
OpenBSD 5.3 hosting most of my web sites - OK
Absolute OpenBSD/2nd (describing OpenBSD 5.3) bought - OK
GNAT 4.7 usable on OpenBSD 5.3, after some patching [1] - OK

After a long hiatus in a Fedora land, I am again starting to ramp up my OpenBSD activities.

This is mostly because I found a cheap OpenBSD server provider, edis.at and because VMWare + OpenBSD combination works reliably on my main development machine (which still runs Fedora Linux).

[1]	patch at openbsd-ports mailing list

Web host changed

2013-01-29T22:00:00+02:00

I changed hosting of arduino.ada-language.com, tero.stronglytyped.org, and ahven.stronglytyped.org (plus a few others) to another web host. You shouldn't notice anything, but in case you see some errors, please be patient and try again tomorrow.

Ahven 2.3 released

2013-01-23T22:45:00+02:00

As promised earlier, Ahven 2.3 is now released. The official release date mentioned in the package is 2013-01-24, while currently it is still 2013-01-23 in Finland, but that mostly because I managed to get everything ready a few hours earlier than I estimated. If that bothers you, ignore this message until tomorrow. ;)

Anyway, the biggest new feature is the exception backtrace reporting. It should work with all compilers, but output is different for each compiler. This is because compilers do not report backtraces in identical format. Other changes include documentation improvements and few minor bug fixes.

As usual, you can get the source code from SourceForge.

Upcoming Ahven Roadmap

2012-12-31T17:31:00+02:00

Here is a small status update about Ahven, my unit testing framework for Ada 95.

In 2012, Ahven got only one release. this is mostly because it was put in the maintenance mode while I concentraceted on other projects, like AVR-Ada.

I do have plans to put more effort to Ahven development in 2013. For example, a new release is planned for January.

In addition, I am looking for ways to reduce costs related to Ahven's web site maintenance, and also simplify it a little more.

Currently, Ahven's infrastructure is scattered to three different places:

Downloadable files at Sourceforge
Source code repository, bug tracker, and wiki at Bitbucket
Actual website on one Linode instance

Most likely I'll move downloads to Bitbucket and change the web site to a cheaper shared web hosting service.

What comes to actual new features, Ahven 2.3 will include support for exception backtraces when an unknown exception is raised. Support for the backtraces is compiler dependant and at the moment Janus/Ada offers the "prettiest" backtraces. You also get something with GNAT and Irvine ICCAda, but usefulness might vary.

Other feature, which I have under work, is parallel execution of the tests. The idea is to run the tests concurrently in N tasks, where N is something between 1 and the maximum number of the tests. However, the feature adds quite lot of code to Ahven and makes some not so simple changes into the internals of Ahven, so I am not sure yet, should I integrate the feature at all.

I have also considered adding system tests for Ahven. Now, Ahven is tested only by unit tests ran by the framework itself. While it gives you some amount of test coverage, even a small suite of system tests would be nice. Only problem is finding an easy to use framework for the tests. So far, I have tried Test::Simple (Perl), py-test (Python) and cram (framework in Python, tests as shell scripts). cram looks the most promising, but py-test is not bad either.

And as always, if you have a patch or idea to submit, please contact me (tero.koskinen@iki.fi). The source code can be found from Bitbucket.

Year 2012 summary

2012-12-31T17:30:00+02:00

Like last year, here is a summary of my Ada-related activities in 2012:

Only one Ahven release (2.2). In 2012, Ahven was a bit on the maintenance mode while I concentrated on other things.
Improvements to AVR-Ada, mostly for attiny(2313,4313) models.
New Arduino blog showing how to play with AVR-Ada and Arduino. Nine articles in 2012, about one per month. Writing articles to the Arduino blog ate my time from this blog, which is why you haven't seen many updates here.
I was invited to ACAA Advisory Board, which is a group of people who discuss about ACATS maintenance.
Ported GNAT to Debian/armhf so it can be then run on systems like Gumstix Overo. I think Ubuntu people independently ported GNAT to Ubuntu/armhf at the same time and I am not sure what is the origin of the current gnat on Debian/armhf. But anyway, if you have an ARM board running Debian armhf (or armel), you can simply do apt-get install gnat to get GNAT on your system.
Co-authored one new paper related to ACATS with Dan Eilers (presented at HILT 2012).

Ada Lovelace Stickers!

2012-10-18T08:00:00+03:00

While ago I ordered some Ada Lovelace stickers (black and white also available) and now finally managed to place them on my laptops:

So next time, if you local Ada organization isn't giving any goodies and you are making an order from Adafruit, remember to order some stickers also.

PS. Happy Ada Lovelace Day! (little late, but better than never).

Two new Arduino blog entries

2012-07-08T20:00:00+03:00

My Arduino blog contains two new blog entries:

a blinking LED example, for those who are just starting with Ada and Arduino
and IBM Thinkpad T42 BIOS password recovery for people who own Thinkpad, have some soldering skills, and are already familiar with Arduino and Ada.

Status update, June 2012

2012-06-12T12:30:00+03:00

I have been quiet a while. This is mostly because I have been busy IRL (like always).

However, there are some things which I have done lately:

Most notably I ported GNAT to Debian armhf. It is available from Debian armhf repositories already, but you can still fetch my original versions from my homepage. Story and porting details are available on debian-ada mailing list.
I also prepared instructions how to install AVR-Ada on Fedora. They are available from my new Arduino blog.
After some discussion with Mr. Dewar, I managed to push Adacore to fix GCC bug 49346. It is interesting to note, that the code is from ACATS and those tests are written in 1985 and 1986. And when I tested, GNAT 3.15p, GPL 2010, and GPL 2011 all had the same bug. I suspect that the bug has been in GNAT since the first version and no one has noticed it before. (=Very old code and very old bug.)

Ahven 2.2 released

2012-03-05T10:52:00+02:00

This (2.2) is long overdue bug fix release for Ahven. Ahven.XML_Runner had same bug as Ahven.Text_Runner and this release fixes it. Now your XML test result files should have skipped tests correctly reported. Another bigger change is API documentation generator change from Adabrowse to Sphinx.

As usual, you can get the source from Sourceforge.

Building custom Arduino LCD shield to be used with AVR-Ada

2012-02-28T00:30:00+02:00

Using 16x2 LCD display for text output purposes is sometimes more convenient than serial communication via UART/USB.

But if you do the wiring on the breadboard you get quite a mess:

So, I wanted to create a shield for Arduino to make the LCD usage easier.

AVR-Ada includes library for HD44780-compatible LCD using 4 bits for data.

That means we need to use 4 pins for data, one pin for Enable signal, and one pin for Register select. Wiring on the shield therefore is something like this:

We also want a trimpot on the shield:

The middle pin of the trimpot is connected to the LCD pin 3 (Contrast adjust), other two pins are connected to GND and VCC.

After placing the wires and the trimpot, we put the display there:

Finally, using code from my Bitbucket repository, we get some visible text:

Some notes:

I used here Arduino UNO r3 with Arduino Protoshield r3.
The Ada code requires AVR-Ada 1.2 (the latest development version from AVR-Ada git repository at the moment).
If you fear that the LCD display might get damaged, you probably don't want to solder it directly to the proto shield but place female header between instead.
My LCD display did not have working backlight, so I left those pins (15,16) disconnected.

Year 2011 summary

2012-01-09T20:00:00+02:00

When it comes to Ada and its community, last year (2011) was pretty interesting to me. Here is a small summary what I managed to do:

I did three Ahven releases (1.9, 2.0, and 2.1). I had hoped to do yet another (2.2), but didn't find time for that.
I became AVR-Ada contributor. I started playing with Arduino and AVRs some years ago (2009, I think) and AVR-Ada is quite pleasant to use on them, after you overcome the installation issues.
Ada Connection 2011 conference in June was the real highlight of the year. I saw a lot of Adaists face to face and they are no longer only random email addresses on newsgroups and mailing lists.
Dan Eilers kindly accepted me as second writer for his papers about ACATS (and Ahven). The first paper was presented at Ada Connection 2011 and the second at SigAda 2011.
I registered domain http://www.ada-language.com/ (.net, .info, .org also). For now, the content there is pretty light, but I do have some plans for it.
My Twitter and Identi.ca client Beautiful Ladybird is progressing nicely (although somewhat slowly). Homeline and status update functionality works from the command line, I just need to do UI with Claw and GtkAda.
Jdaughter library for reading and writing JSON data was a by-product of Ladybird. It is still missing some features, but I can parse Twitter and Identi.ca feeds with it.

Finally, here some pictures from AdaConnection 2011 in Edinburgh:

The John McIntyre conference centre (rainy day, like most days that week):

Jacob Sparre Andersen giving a presentation:

I also visited Holyrood Park, which was nearby:

PS. Notice, that Ada Information Clearinghouse is showing videos from the conference. Be sure to check them out!

New year coming, new blogging engine also

2011-12-27T21:01:00+02:00

Like others, I am slowly converting all my documentation into reStructuredText. I did it earlier for documentation of Ahven and now I changed my blog to it also.

For blogging, I decided to use Pelican, which generates static blog pages from a set of reStructuredText files.

Nice Christmas Present from Paeae

2011-12-13T23:40:00+02:00

I recently ordered some Arduino and electronics stuff from Finnish Arduino store called Paeae. The delivery was smooth and fast as usual, but in addition they had put there a nice little Christmas present for me, a small green breadboard (resistor was not included):

Thanks!

Oops, I really messed up skipped tests in Ahven 2.0

2011-10-11T15:06:00+03:00

I managed to mess up skipped test reporting also in the XML test result reporter. I filed an issue about it.

Since the bug appears only if you skip some tests and use the XML result format, it isn't really fatal and therefore I won't immediately fix it. However, I do plan to create a bug fix release within a month or two.

Version numbers are cheap - Ahven 2.1 released

2011-09-24T15:06:00+03:00

A small but unfortunate and annoying bug slipped into Ahven 2.0 release: Ahven.Text_Runner silently ignored all skipped tests and did not report them. This is now fixed in Ahven 2.1.

Again, you can get the source from Sourceforge.

Ahven 2.0 released

2011-09-23T16:07:00+03:00

I just released Ahven 2.0. You can grab the source code from SourceForge.

This release includes two new features:

Test timeouts
Test skipping programmatically

When running tests, you can specify a timeout value for the tests. If test runs longer than the timeout value, the test is stopped. This is implemented by running each test in a separate task and aborting the task if the test runs too long.

The feature of course depends on code being abortable, which might not be the case always. For example, many Ada compilers do not abort task which runs in a tight loop and does some calculations, like "loop Counter := Counter + 1;end loop;".

The another feature is simple procedure called "Skip". Calling this inside a test allows you to skip the test and move to the next one. The skipped test is considered as passed, but some test runners might add extra "SKIP" info for them.

Adadomain merged to sphinx-contrib

2011-08-04T15:07:00+03:00

I merged my Adadomain to sphinx-contrib. This way it is one step more official extension.

For those who do not know: Sphinx is a documentation tool and it is used in Ahven. In release 1.9 of Ahven, I included the generated HTML documentation to the tarball, but I might emit the generated content from 2.0 since the Adadomain extension is now merged.

Reading I2C EEPROM with Arduino and AVR-Ada

2011-05-21T16:43:00+03:00

Recently, I wanted to access I2C EEPROM with Arduino. However, AVR-Ada (1.1.0) provides no support for I2C interface which many AVR processors and Arduinos have. So, I had to write a package ("Two_Wire") for it.

Example code is available at arduino-eeprom repository and below is the used circuit:

The package is far from perfect, but it should provide a place to start if someone needs to use I2C with AVR-Ada.

IPv6 support for stronglytyped.org

2011-05-09T14:18:00+03:00

My AWS-powered sites stronglytyped.org and Ahven's homepage ahven.stronglytyped.org now support IPv6 connections also.

This was possible after Linode started supporting native IPv6 in some of its datacenters.

Again, only Ada Web Server and iptables were used. There is no separate frontend http server written in another language. Just plain Ada all the way.

Small attiny13 development board

2011-05-07T15:25:00+03:00

To test AVR-Ada with small attiny13 processors, I made a little "development board" for me:

It can run hello example out of the box and blink the green led. The red led indicates power.

Ahven 1.9 released

2011-04-14T16:03:00+03:00

I finally managed to release Ahven 1.9 (download zip).

This is a small bug fix release only to allow Ahven compile with GNAT GPL 2010 also.

If everything goes as planned, the next 2.0 will include new features, like timeouts, improved documentation, and possibly an ability to skip some tests.

Blog engine changed to blogsum

2011-03-24T01:10:00+02:00

I changed the blog engine running my blog from bloxsom to blogsum.

This might cause some extra spam in the planet aggregators, I am sorry about that. I try not to do this too often. :)

The reason for the change was that I wanted to use software which works well with OpenBSD, in case I some day migrate this web server from Linux to OpenBSD.

RSS feed URLs now follow form http://tero.stronglytyped.org/rss2.xml?search=TAG where TAG can be for example ada or monotone.

Arduino Mega 2560 and Attiny13a/Attiny2313 support to AVR-Ada

2011-02-14T22:04:00+02:00

I recently got write access to the AVR-Ada repository and now I have pushed my changes there.

These changes improve support for Atmega2560, Attiny13a, and Attiny2313 processors. Attiny13a and Attiny2313 are pretty uninteresting, although common, AVR processors. I happen to use them in my projects because they are cheap and that is why I also wanted better support for them.

On the other hand, Atmega2560 processor is used in the new Arduino Mega 2560 board. This means that next release of AVR-Ada will support the new Mega board out of the box. Some bits, like support for timers 3..5 and extra UARTS, are missing, but at the moment Atmega2560 should have about same features as Atmega328p supported.

OpenBSD port for Monotone 0.99.1

2010-11-09T22:30:00+02:00

I updated my OpenBSD port for Monotone to version 0.99.1.

It is tested on 4.8/amd64, but should work with -current also

Ada bindings for cURL

2010-10-13T22:23:00+03:00

I put my Ada bindings to libcurl available at http://hg.stronglytyped.org/curl-ada/. At the moment, they are pretty simple and contain only a small subset of libcurl, but they allow me to fetch data over http/https and that is good enough for my current purposes.

The bindings should work with GNAT and Janus/Ada on 32-bit and 64-bit systems. The build scripts are less than optimal, but with some effort you should figure out how to build the bindings

Arduino Ethernet Shield support for AVR-Ada

2010-09-20T20:53:00+03:00

I finally got my code working with Arduino Ethernet Shield and put it available at http://bitbucket.org/tkoskine/arduino-ethernet/.

Only receiving data via TCP client connections is supported, but I plan to improve the library as my time permits.

AVR-Ada 1.1.0 port with AVR-GCC 4.3.2 for OpenBSD

2010-09-01T07:00:00+03:00

I updated my AVR-Ada port to version 1.1.0. It consists of three parts:

AVR-GCC 4.3.2 with Ada support - http://bitbucket.org/tkoskine/avr-gcc

AVR-Ada 1.1.0 runtime files - http://bitbucket.org/tkoskine/avr-ada-rts

AVR-Ada 1.1.0 library files (AVR.* packages) - http://bitbucket.org/tkoskine/avr-ada-lib

For now, only Arduino (atmega328p) is supported in avr-ada-lib package.

Documentation using Sphinx

2010-08-06T21:04:00+03:00

I recently converted Ahven's DocBook documentation to use Sphinx and reStructuredText.

I did this to make it simpler to write documentation. reStructuredText is almost like plain text, so in theory it should be easier than XML-based DocBook.

As an unfortunate side-effect, this change introduces Python dependency to the project, while on the other hand, I get rid of Java-based XSLT tool dependencies.

New blog location!

2010-07-17T21:01:00+03:00

Hello, I transferred my blog from Microsoft's live.com to here.

The blog uses Blosxom blogging engine with a few plugins.

mtn disapprove PARENT-REV CHILD-REV

2010-07-15T22:07:00+03:00

Starting from version 0.99 Monotone's disapprove command understands a revision range in addition to a single revision.

This means that you can disapprove bigger group of changes at once.

Of course, there are some limitations on the group of revisions. For example, there cannot be merge revisions inside the range.

This was my first bigger change to Monotone's code and along with that I gained commit access to monotone.ca, yay!.

Ahven 1.8 released

2010-06-02T20:22:00+03:00

Today I released Ahven 1.8. You can find release notes from here.

New Computer

2010-03-03T21:30:00+02:00

No new blog posts for a while. That is because I got a new computer some time ago this year and have been playing with it. It has 3.4GHz AMD Phenom II X4 965 processor, 4GB RAM, 1x 64GB SSD disk, and 2x 150GB 10krpm Velociraptors. And the graphics adapter is ATI Radeon HD 4890. In other words, it should have enough computing power for a while. :)