Doorgaan met MECRISP-STELLARIS en Embello

In de laatste aflevering pleitte ik een beetje voor FORME op microcontrollers als een nog levensvatbaar ontwikkelingsplatform, niet alleen voor de industrie waar het tegenwoordig normaal wordt gezien, maar ook voor hackers . Ik mis je misschien zelfs om een ​​paar stukjes goedkope hardware te krijgen. Deze keer laten we het Forth-systeem op die hardware opzetten en de verplichte “Hallo World” uitvoeren en Led Blinky. Maar dan nemen we ook een duik in een van de functies die zeer netjes maken op microcontrollers: eenvoudig multitasking.

Werken!

Hardware

Mecrisp-Stellaris-FORTE loopt op een groot aantal armmicrocontrollers, maar ik zal hier focussen op de STM32F103-chips die beschikbaar zijn voor uitzonderlijk weinig geld in de vorm van een generieke kopie van de MAPLE MINI, vaak een “STM32F103 Minimum System Board genoemd “Of” blauwe pil “vanwege de vormfactor, en het feit dat er te koop was. De microcontroller aan boord kan worden uitgevoerd bij 72 MHz, heeft 20 KB RAM en 64 of 128 KB van Flash. Het heeft veel pinnen, de digitale alleen zijn 5 V-tolerant, en het heeft alle normale microcontroller-randapparatuur. Het is niet het meest krachtige, en het heeft geen drijvende eenheid of een dac, maar het is een ruig oud ontwerp dat voor veel minder geld beschikbaar is dan het moet zijn.

Programmeur aangesloten, vermogen via USB
Vergelijkbare wonderen van massaproductiewerk voor de programmeur die u in eerste instantie de chip moet laten knipperen. Elk van de klonen van de St-Link V2 zal prima werken. (Ironisch genoeg is de hardware in de programmeur bijna identiek aan het doelwit.) Ten slotte, aangezien u aan het feit dat het in interactieve schaal loopt, moet u een seriële verbinding nodig hebben met het STM32-bord. Dat geeft waarschijnlijk een USB / seriële adapter aan.

Deze hele setup kost niet veel meer dan een fastfoodmaaltijd, en de programmeur en de USB / seriële adapter zijn dingen die je hoe dan ook in je set wilt hebben, als je dat nog niet hebt gedaan.

U kunt het bord rechtstreeks door de verschillende 3.3 en GND-pennen verspreid over het bestuur, of via de Micro USB-poort of de 5V-pinnen op de doelbord. De laatste twee opties passeren door een 3.3 V-regelaar voordat u deelneemt aan de 3,3 pinnen. Alle pinnen zijn onderling verbonden, dus het is het beste als u slechts één voeding tegelijk gebruikt.

Firmware: het Forth-systeem

Ga de Super-Special Hackaday-Edition Mecrisp Forth Package van Github. Inbegrepen in de directory “ROMS” is een Forth-systeem dat hier voor de demo’s zal werken. Ik heb ook geladen in een respectabele basis van [JCW] ‘s uitzonderlijk EmbleLo Forth-bibliotheken en levert dingen zoals Easy GPIO-configuratie, vertragingsfuncties, enzovoort. Er zijn veel veel meer bibliotheken beschikbaar, en we zullen er de volgende keer in kijken wanneer we ze nodig hebben.

Het coolste ding over het gebruik van een Forth-systeem is dat zeer kleine ondersteuningssoftware op enigerlei wijze nodig is – de weergave van de weergave compileert zijn eigen code, en u interageert ermee over de seriële terminal. Alles gebeurt in de microcontroller. De ene hindernis, komt dan naar de chip. In de oude dagen werd dit gebruikt om handmatig in de bytes te schakelen, en weer is eigenlijk klein genoeg dat het letterlijk bootstrapping het op deze manier mogelijk is. Maar je hebt die chipprogrammeur al gekregen, toch?

[Texaan] Sint-hulpprogramma’s zijn de gemakkelijkste manier om uit te komen op je chip. Download ze uit Github en bouw het zelf op of probeer je geluk met je Distro’s Package Manager. (Windows-mensen, je bent ook niet weggelaten. Hoewel dat binair updates in een tijdje niet heeft gezien, zal het doen.)

Sluit de programmeerdraden op de duidelijke manier aan en geeft de Magic Commands St-Flash ERASE en ST-flash schrijven Mecrisp-Stellaris-Hackaday-Edition.bin 0x8000000. In vijf seconden ben je klaar om te rommelen.

GND – GND

SWCLK – CLK

SWSIO – DIO

Een programmeur halen is een gedoe als je er geen hebt, maar het zal de rest van je leven eenvoudiger maken en er een krijgen is zo eenvoudig als het klikken op “Pay” en wachten. Onze eigen [AL WILLIAMS] (geen relatie) heeft een recent bericht op het gebruik van dezelfde software voor het debuggen C of Arduino-code met GDB, dus het is de moeite waard om dit op te zetten.

Software

Seriële hookup, aangedreven door laptop
Zet de programmeur voorlopig weg en maak verbinding met de STM32 over seriële; De standaard baudrate moet 115.200 zijn. Als u nog geen uitgeschakeld hebt, moet u mogelijk op de RESET-knop op het STM32-bord raken. Als alles goed is gegaan, wordt u begroet door een bekende schedel-en-cross-sleutels. MecreK verwacht een linefeed aan het einde van de lijnen, dus als u LF + CR verzendt, rent u met succes twee keer terug.

A9 TX – Seriële RX

A10 RX – Serial TX

GND – GND

[jcw]’s folie is a nice, multi-platform serial terminal emulator for this application. What it does that your normal terminal program doesn’t is allow you to re-enter a command line with the up-arrow, which makes taking care of mistakes much, much much easier than re-typing a long command. Het ookautomatically includes other files, which I made substantial use of in building the binary for this article. You don’t need to run folie, but I bet you’ll like it.

Hallo Wereld

Now it’s “Hello World” time. If you’re new to Forth, here comes an very selective introduction. type 2 2 + and hit enter. It says ok.. That’s reassuring, right? now type . (read “dot”) and it will print out the not-surprising result. dot is the first of a few global Forth shorthands that you’ll want to internalize. a lot of commands with a dot print out their results immediately. .s (dot-ess) prints out the stack contents, for instance. two a lot more idioms that we’ll see a lot of are @ for getting a variable or reading an input and ! for setting a variable or output. read these as “get” and “set” in your head when scanning Forth code.

Next, let’s see how to write a function. : starts a function definition and ; ends it. So : four 2 2 + ; defines a function that adds two and two together. (And compiles it in real time!) You can then turn around and call this function immediately. four .s will show you that our function has left the sum of two and two on the stack. In this sense, functions in Forth aren’t really functions. They don’t take explicit arguments or return explicit values. They just operate on whatever data is on the stack, and leave the results there too. That’s why Forth functions are called “words”. I’ll be sticking to this convention from now on.

Here, finally, is “Hello World”: : hw .” Hello, World!” cr ;” Strings are a little odd in Forth, mainly because of the way the language is parsed — the compiler reads up to a space and then executes what it has found, so there has to be a space between the print-a-string command (.”) and the first character that you want to print. The print command scans forward until it finds a closing “, though, so you don’t need an extra space there. cr sends a carriage return. type hw at the prompt. Hello, World!

Blinking LEDs

Even though serial text input and output is so easy in Forth, blinking an LED is the standard “hello world” of microcontrollers, so it’s time for some GPIO. because the system is already configured for this particular microcontroller board, turning an LED on is as easy as typing led.on at the prompt. want to turn it off? Led uit. manual blinking will get old pretty quickly, though, so let’s write a blink word. : blink led.on 100 ms led.off 200 ms ; will do the trick. try blink blink blink. See my blink demo code for elaboration. (More on ms in a few thousand milliseconds.)

The details of the GPIO initialization are hidden in core/Hackaday/LED.fs and in Embello’s stm32f1/io.fs respectively. Digging through, you’ll see the standard initialization procedure: the particular pin is set as output by flipping some bits in the STM32’s peripheral control registers. [jcw] has defined a bunch of these, making setting a pin as output, with the push-pull driver, as easy as PC13 OMODE-PP io-mode!. (Remember the “!” indicates set the value in a variable or register.)

To configure pin PA7 for ADC input: PA7 IMODE-ADC io-mode!. testing buttons, using the built-in pullup or pulldown resistors: PA3 IMODE-PULL io-mode! and then set the output to pull up or down using true PA3 io! or PA3 ios!. You’ll then be able to read the button state with PA3 io@ (“io get”) later on.

GPIO on the STM32 chips is very flexible, and if you want to get deep into the configuration options in the datasheet, you can set all of this fairly easily using [jcw]’s io.fs code. For instance, io.all prints all of the GPIO registers and their values, which is a great help for interactive debugging. That said, there’s some room here for a a lot more user-friendly hardware-abstraction layer, if you want to contribute one.

Multitasking on the Quick

So now we’ve got a blinking LED and serial-port printing “Hello World”. Not a bad start, and both of these make good use of Forth’s interactivity: the LED only lights up when you type blink. one of the chief virtues of Forth, for me, is the ease of going between interactive testing of words like this, and then deploying the functionality in a working system. One reason is that nearly all Forths support basic cooperative multitasking. Here’s what I mean.

First, let’s loop our blink function so that we don’t have to type so much. : bb begin blink again ; creates a function, bb for “bad blink”, that will run forever. The problem with “run forever” in Forth is that you never get back to the interpreter’s command line without physically pressing the reset button, and then everything you were working on in RAM is lost.

Instead, let’s blink in a loop with a way out. : gb begin blink key? totdat ; creates a function that will run our blink command until there’s some input from the keyboard — the return crucial is pressed. This particular looping construct is very beneficial for testing out functions that you’d like to run continuously, without hanging the system. keep it in geest.

Zodra we onze knipperende functie hebben aangepast om precies de manier waarop we het willen, laten we het een achtergrondtaak maken zodat deze onbeheerd kan knipperen.

Taak: Blinktask
: knipperen&
Blinktask activeren
begin opnieuw te knipperen
;
multitasken
knipperen&

In het kort, de taak: Word creëert een geheugenruimte voor onze knipperende achtergrondtaak die we blinktask bellen. De functie knippert en doet het werk op de achtergrond. Blink & Begint door te verklaren dat het de BLINDTASK-taakcontext zal gebruiken en dat het moet beginnen. Dan gaat het in een onbegrensde knipperende lus waaruit het nooit verlaat. Multitask wordt multitasking ingeschakeld en knippert en voert onze taak uit. Voer het uit en de LED knippert terwijl je nog steeds met de console kunt communiceren. Zoet. Typ taken en je zult zien dat er twee actieve zijn: één is onze knipperen en de andere is de interactieve tolk.

Maar hoe weet de knipperende taak wanneer u op een andere gelijktijdige processen oplevert? Indien rendelt het woord pauzeert van de huidige context en gaat verder naar de volgende, round-robin multitasking. De MS-functie bestaat onder andere uit een pauze-opdracht, dus wat lijkt erop dat een blokkerende vertraging in een setup met één taak wordt belet met het spelen van fantastisch goed met uw andere taken.

Het mooie van coöperatieve multitasking is dat u precies controleert wanneer er een contextschakelaar is, die kan helpen glitches te elimineren die u in preventieve systemen zult vinden. Het nadeel is dat u verantwoordelijk bent voor het onthouden om uw functies af en toe te pauzeren, en u moet de timing zelf verifiëren. Natuurlijk is dit een microcontroller en je hebt de behoorlijke rijke interne interrupt-controller ook om mee te spelen.

Het echte punt van multitasking op micros is dat het een geweldige workflow maakt voor het schrijven, testen en het inzetten van kleine daemons: functies die “altijd aan” willen zijn. Schrijf eerst de functie die de actie eenmaal doet. Ten tweede, test het in een lus met een ontsnappingsluik. Ten derde, als het eenmaal werkt, verwijder dan de ontsnapping en maak er een achtergrondtaak voor. U kunt het vervolgens in- en uitschakelen met behulp van inactief en wakker, zelfs vanuit andere taken. Zie MECRISP’s multitask.txt, de bron, voor nog veel meer details.

Wat is het volgende?

Tot nu toe hebben we MECRISP-STELLARIS opgezet, met extra bibliotheken van Jeelabs ‘EmbleLO Forth Frame, en een aantal snelle demo’s uitmaken. Als dit uw interesse heeft gewekt, breng ik u de volgende keer op een walkthrough van het bouwen van een aantal echte software. Er is veel meer te zeggen over de manier waarop Mecisp zich de nuances van Flash versus RAM, ingangen en uitgangen en de praktijk van interactieve ontwikkeling verwerkt. Sommige van de echt freaky aspecten van aan het werk zullen hun grappige-vormige hoofden opheffen, en we leren hoe dan ook van hen te houden.

In de tussentijd haal je je goedkope Stm32F103-platen op met onze binaire en krijg een klein beetje gewend aan het spelen in de Forth-omgeving op de chip. Blink een aantal LED’s. Kijk rond de Glossary van Mecrisp-Stellaris en de Documentatie van Embello API. Of alleen lijst om alle opdracht tot uw beschikking te zien en te beginnen met het weghekken.