Wiederauferstehung des RP6? -- Erste Erfahrungen und Aufruf zum Austausch!

[Dirk]

Ja, Leute,
da lese ich doch auch mal interessiert mit!
inka, fabq: euch kenne ich ja noch aus unserer grauen Vergangenheit hier im Forum ...
Toll, was du Roland da auf die Beine stellst. Hut ab!

[Pr0gm4n]

Na Dirk, ich erinnere mich durchaus an deine vielen hilfreichen Beiträge. Aber ich scheine wohl (noch?) nicht genug vernünftiges beigetragen zu haben, um in Erinnerung zu bleiben. Nun ja, bitte keine vorschnellen Lorbeeren – ich versuche dran zu bleiben aber es ist noch ein weiter Weg.

PS: Bei einem "Dirk" aus NRW muss ich nun fragen... du bist nicht zufällig begeistertes Mitglied eines Modellfliegerclubs in der Eifel? Dann kenne ich dich nämlich inzwischen persönlich...

Grüsse aus Zürich,
Roland

[Dirk]

Hi Roland,
sorry, die Aufzählung von RP6-Aktivisten war nicht diskriminierend gemeint: du bist js auch schon ein "Oldie" hier, aber in meiner morschen Erinnerung von immerhin schon fast 19 Jahren früher eher allgemein so mit AVR und GCC unterwegs, und nicht speziell RP6, ... ???
Nein, zum Modellfliegerclub in der Eifel gehöre ich nicht, obwohl auch sehr reizvoll! Immerhin habe ich mal Schiffsmodellbau (z.B. den Hamburger Bugsier 3) gemacht.
Thema Rust: ist das eigentlich eine noch "erfolgreiche" Programmiersprache? Ich habe gelesen, dass sie in Form von Stiftungen finanziell am Leben gehalten wird. In welchen ausserakademischen Bereichen wird die denn angewendet?

[Pr0gm4n]

Hab sie auch nicht als diskriminierend aufgenommen. Schade dass du keine Modellfliegerei in der Eifel betreibst, aber dann kenne ich halt jetzt 2 Dirks in NRW.

Rust wird meines Wissens kommerziell bei Dropbox, Microsoft, Cloudflare, Facebook, ... produktiv eingesetzt. Ursprünglich getrieben und entwickelt von der Mozilla Foundation, also sogesehen von einer "Stiftung" wie du sagst. Empfinde ich hier aber eher von Vorteil, als wenn das jetzt eine einzige Firma prägend in der Hand hätte. Wie oben beschrieben, das prominenteste Open-Source Projekt ist meines Wissens der Linux Kernel, der nun nach und nach mehr Rust bekommen soll. Da Rust noch sehr jung ist, sehe ich die Sprache aber eher noch auf dem aufsteigenden Ast. Ein Beispiel von Features die ich so toll finde habe ich erst heute morgen wieder entdeckt: Eine Funktion kann als Rückgabetyp "endet nie" haben, dargestellt mit einem Ausrufezeichen "!".

Immerhin hab ich Neuigkeiten: ich hab die ersten Interrupts zum Laufen bekommen!

Der Code beim Anwender sieht dann etwa so aus:

#[interrupt]
fn INT0() {
    // do some stuff on hardware interrupt INT0
}

Natürlich muss man den Interrupt trotzdem erst mal aktivieren. Und ich muss noch ein bisschen rausbekommen wie man dann ordentlich zurückspringt und so... aber das kommt schon noch zusammen


LG Roland

[Pr0gm4n]

So Ihr Lieben, da bin ich wieder!

Inzwischen hab ich mich mit allen möglichen Arten von atomischen Operationen, Mutexen, und anderen Ideen, wie man möglichst statisch (= zur Compilezeit) absichern kann dass nichts schief geht, herumgeschlagen. Ich denke ich bin soweit ganz happy, aber was meint Ihr denn so?

Hier mal ein kleines Beispiel, das nun einen Ringbuffer für USART_RXC implementiert:

use rp6::{interrupt::mutex::Mutex, *};

// Shared data: While constants can be accessed safely (since they are never modified, it is
// recommended to wrap your mutable data in an `rp6::interrupt::Mutex`. Note that a `Mutex` can
// only be used inside a `CriticalSection`, e.g., by calling `interrupt::without_interrupts`.
const USART_BUFFER_SIZE: usize = 32;
static USART_BUFFER: Mutex<[u8; USART_BUFFER_SIZE]> = Mutex::new([' ' as u8; USART_BUFFER_SIZE]);
static USART_WRITE_PTR: Mutex<usize> = Mutex::new(0);

#[interrupt]
fn USART_RXC() {
    interrupt::without_interrupts(|cs| {
        let buffer = USART_BUFFER.lock(cs);
        let write_ptr = USART_WRITE_PTR.lock(cs);

        // save newly received byte to the ringbuffer
        buffer.update(|mut b| {
            b[write_ptr.get()] = Serial::read_raw();
            b
        });

        // increment USART write pointer and wrap around if necessary
        write_ptr.update(|x| if x + 1 < USART_BUFFER_SIZE { x + 1 } else { 0 });
    });
}

Eventuell besser zu lesen mit Code-Highlighting auf Github!

In Anlehnung an das RP6Example gibt das Programm (weiter unten in der main) dann einfach regelmässig einen hochzählenden Counter aus, sowie den aktuellen Inhalt des Ringbuffers.

Na, wie sieht das für Euch (noch-)nicht-Rustaceans aus?


LG und gute Nacht,
Roland

[Pr0gm4n]

Und heute morgen hat's mich direkt nochmal kurz gepackt: Es gibt jetzt automatisch generierte API Docs auf GitHub!

LG Roland