avr-vala

KO | EN

gitlite — search

#python #java #python3 #arduino #golang #machine-learning #rust #html #flask #javascript #seismology #nodejs

★ 15 Open GitHub ↗

A modified Vala compiler to support AVR microcontrollers

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

avr-vala
========

A modified Vala compiler to support AVR microcontrollers. Using `avr-valac`, you can compile Vala code to target AVR processors using the AVR GCC compiler.

The compiler has three important features compared with regular Vala:

1. A binding of the AVR libc, including all the special purpose functions.
2. Bindings of MCU-specific registers and the good sense to define a preprocessor flag in Vala and pass the `-mmcu` flag to GCC.
3. A new attribute, `[Interrupt(vector = "foo", block = true]` that can be attached to methods to turn them into interrupt handlers (ISRs).
4. Support for asynchronous methods using the AsyncAvr library, provided. More information below.

Much of the libc binding has not been tested, so expect bugs. In particular, to deal with program memory, a collection of new types have been introduced, `prog_uint8` and friends.

Please report bugs, or, especially if the change is simple, request a pull.

AsyncAvr
--------

Vala's asynchronous routines are extremely convenient in the context of a microcontroller because they allow writing straight line code that can avoid blocking while waiting for I/O. Unfortunately, writing coroutines in C by hand is not fun. Vala is rather adept at doing this.

To work properly, there needs to be a small library that provides the main loop. This is provided in `aavr.h` and `aavr.c`. The Vala binding is in `gio-2.0.vapi`, the name being an unfortunate by-product of how the Vala compiler is written. To enable asynchronous methods, use `--allow-async`. This will pass all the needed flags, including the extra `aavr.c` file to the C compiler.

The general flow is, from the main line, set up a timer to interrupt and overflow at a desired tick rate, invoking `AsyncAvr.tick()` in the interrupt. Invoke the `begin` method of an asynchronous method. Finally, invoke `AsyncAvr.run()` to start the main loop.

In each asynchronous method, calling `AsyncAvr.wait` will appear to block until the provided polling delegate meets some criteria. Essentially, this polling function should wait for hardware to be in the expected state. An optional timeout is provided such that `wait` can return even if the hardware does not respond.

async void blinky () {
        bool light = true;
        Port.d[6] = light;
    
        AsyncAvr.Status status;
        while (!(AsyncAvr.Status.QUIT in (status = yield AsyncAvr.wait(() => Pin.b[4], 8000)))) {
            light = !light;
            Port.d[6] = light;
        }
    }
    void main() {
        disable_interrupts();
	      Direction.d[6] = true;
    
	      Timer.zero.set_mode (false, true, Timer.CounterMode.NORMAL, Timer.CounterMode.NORMAL);
	      Timer.zero.control = Timer.zero.Control.SOURCE_IO_DIV_8;

Timer.zero.interrupt_enable = Timer.zero.Interrupt.COMPARE_A;
        enable_interrupts();

blinky.begin((f) => blinky.end((owned)f));
        AsyncAvr.run();
    }
    [Interrupt(vector = "TIMER0_COMPA_vect")]
    public void timer0_compa() {
        AsyncAvr.tick();
    }

Missing Features
----------------

The following features of the Vala language don't work (but could be added):

- Exceptions
 - Classes, and therefore inheritance (structs work)
 - Signals (it would be ideal to build this in a way that interfaces with `errno`)
 - Locking

avr-vala

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README