Teensy Basics
- Wat is een Teensy?
- Hoe programmeer je een Teensy?
- Hoe sluit je iets aan op een Teensy?
- Aansluitingen maken
- Timing
- Seriële communicatie
Wat is een Teensy?
Een Teensy is een microcontroller. Met een microcontroller kan je analoge signalen (voltage ten opzichte van een nulpunt) omzetten naar digitale waarden en andersom. Zo kun je bijvoorbeeld potmeters, infrarood-sensors en temperatuursensoren als input gebruiken en die waarden via zo’n Teensy uitlezen in je computer. Aan de andere kant kan je lichten en motoren aansturen vanuit je computer.
Een Teensy is vergelijkbaar met een Arduino, maar heeft een aantal pluspunten: In vergelijking met de Arduino UNO, de populairste Arduino, heeft de Teensy meer aansluitmogelijkheden, meer rekenkracht en heeft het de mogelijkheid om simpele audiobewerkingen te doen, en dat voor dezelfde prijs.
Hoe programmeer je een Teensy?
De software die op een Teensy draait wordt geprogrammeerd in C. Je zult veel overeenkomsten zien met Javascript. Om de code te schrijven en te uploaden naar de Teensy heb je twee stuks software nodig. De eerste is de Arduino IDE. Omdat de Teensy qua werking erg op een Arduino lijkt kan deze in dezelfde taal als Arduino’s geprogrammeerd worden. Om dit mogelijk te maken is er wel een extra stuk software nodig: Teensyduino.
Installatie
- Je begint met het downloaden van de Arduino software. Deze kun je vinden op www.arduino.cc. Let op: je kan niet de versie uit de Windows App-store installeren, dan werkt de Teensy-software niet.
- Je installeert de software door de aanwijzingen te volgen na het openen van het installatiebestand.
- Ga in de Arduino IDE naar preferences (CNTRL / CMD + comma) en voeg deze URL toe aan de
Additional Board Manager URL
https://www.pjrc.com/teensy/package_teensy_index.json
TIP: zet ook meteen Editor Quick Suggestions aan voor code-completion
- Ga daarna naar
Board Managerin de linker zijbalk en zoek daar op Teensy, installeer vervolgens deTeensy by Paul Stoffregenmanager.
Gebruik
Als je na de complete installatie de Arduino IDE opstart krijg je het volgende scherm te zien:
De opbouw van de code is vergelijkbaar met een P5js-sketch. In de setup-functie wordt alle code uitgevoerd die eenmalig aan het begin moet draaien. In de loop-functie wordt de code uitgevoerd die continu achter elkaar moet worden uitgevoerd.
De knop links bovenin met de ✔ is bedoeld om de controleren of je code goed werkt. De knop ernaast is om je code naar de Teensy te sturen. Om dit te kunnen doen zal je in het menu het juiste apparaat moeten kiezen: Kies bij Tools onder het submenu boards voor Teensy 3.2/3.1 of Teensy 4.0, afhankelijk van welke Teensy je hebt. Vervolgens kun je de code uploaden. Er verschijnt een tweede window, van Teensyduino. Waar mogelijk staat dat je op de knop van de Teensy moet drukken om het programmeren te voltooien. Als er “Reboot OK” staat, dan is het programmeren gelukt.
Basisfuncties
Er is een aantal functies die je vaak gebruikt als je programmeert voor de Teensy, hieronder opgesomd:
pinMode(pin, type*);digitalWrite(pin, value**);analogWrite(pin, value***);digitalRead(pin);analogRead(pin);delay(time);
* INPUT, OUTPUT of INPUT_PULLUP.
** LOW of HIGH (ook in te vullen met 0 of 1).
*** waarde tussen 0 en 255.
Voorbeeldcode
Voor voorbeelden van code kijk je in het menu File → Examples. Of op de website van Arduino / Teensy.
Hoe sluit je iets aan op een Teensy?
De Teensy heeft aan elke zijkant veertien pinnen die allemaal een of meerdere functies hebben. Om een overzicht te krijgen van deze functies kun je onderstaande afbeelding gebruiken.
Zoals je ziet heeft bijna elke pin veel verschillende functies. De belangrijkste worden hieronder beschreven.
Digitale Pinnen
De getallen met de grijze achtergrond geven aan dat het digitale pinnen zijn. Deze zijn bi-directioneel. Je kunt hier dus bijvoorbeeld een knop op aansluiten en hem als input gebruiken. Je kunt in je programma aangeven of een pin als input of output werkt. Als de knop ingedrukt is en dus 3.3V aan spanning doorlaat, zal de uit te lezen waarde HIGH/1 zijn. Als de knop niet ingedrukt is de spanning gelijk aan 0V en is de uit te lezen waarde LOW/0. Als je een digitale pin als output gebruikt en er via een weerstand een LED op aansluit dan kan je deze LED aan laten gaan door HIGH naar de pin te sturen, en uit laten gaan door LOW naar de pin te sturen.
Om dingen te besturen die meer stroom trekken dan een LED (b.v. een motor) moet je in veel gevallen een schakeling met externe voeding en bijvoorbeeld een transistor gebruiken.
Let op: als je in de software een pin als output instelt kun je er beter geen spanning op zetten omdat je daarmee de Teensy kan beschadigen.
Analoge pinnen
De pinnen met de oranje achtergrond (A0-A9) zijn analoge inputs. Deze meten niet een binaire waarde, zoals de digitale, maar een continue waarde: een spanning ergens tussen 0 en 3.3V. Deze pinnen werken alleen als input. Als je op de juiste manier een potmeter verbindt met één van deze pinnen zal je als aan de potmeter draait een waarde kunnen lezen tussen de 0 en de 1023. Als de waarde 0 is en de potmeter dus helemaal dicht is staat er 0V op de pin. Is de waarde 1023, dan staat er 3.3V op de pin. Meer over hoe je de potmeter precies aansluit verderop in dit hoofdstuk.
PWM
Pulse Width Modulation is niet alleen een synthesetechniek, maar wordt ook gebruikt om een analoog signaal te simuleren. Door de pulsbreedte te veranderen lijkt het alsof de spanning op een van deze uitgangen (met de roze achtergrond op de afbeelding hierboven) verandert. Hiermee kan je bijvoorbeeld een LED in- en uit laten faden door een waarde tussen de 0 en de 1023 de sturen naar zo’n pin.
Voeding
De 3.3V-pin en de GND pin zijn belangrijk. Stroom gaat pas lopen als er een verbinding is met de GND. De Teensy meet vervolgens het spanningsverschil tussen de inkomende waarde en dit nulpunt, de GND. Als je bijvoorbeeld een LED wilt laten branden zal je deze moeten aansluiten tussen een digitale uitgang en de GND. Zorg er daarbij wel voor dat je er altijd een weerstand tussen plaatst, anders kan je de LED opblazen (dat klinkt spannender dan het is). Mocht je voor een bepaalde sensor (bijvoorbeeld een potmeter) voeding nodig hebben, dan kan je deze uit de 3.3V-pin halen.
Let op! De Teensy is gebouwd om om te kunnen gaan met een maximale spanning van 3.3V, kom je hier overheen dan heb je kans dat de Teensy het niet overleeft. Let dus goed op dat je alles op de juiste manier aansluit.
Voor meer informatie over werken met de Teensy kan je kijken op de websites www.pjrc.com, www.arduino.cc en vele tutorials op youtube en andere plekken op het internet.
Aansluitingen maken
Hieronder volgen een aantal voorbeelden van het aansluiten van bepaalde sensoren. Mocht je een specifieke sensor hebben die hieronder niet wordt beschreven, dan kan je via je favoriete zoekmachine naar \
Switch
//Inlezen drukknop
int inPin = 10; //de pin waarop de knop is aangesloten
int ledPin = 13; //pin waarop een LED is aangesloten
//(ingebouwde LED in dit geval)
bool pinState; //houd bij wat de status is van de pin
void setup() {
//zet de pin op input en zet de pullup-weerstand aan
pinMode(inPin,INPUT_PULLUP);
//zet de ledPin op output
pinMode(ledPin,OUTPUT);
}
void loop() {
// put your main code here, to run repeatedly:
int pinRead = digitalRead(inPin);
//kijk of er verandering is in de staat van de pin (ingedrukt of niet)
//alleen als de verandering plaatsvindt, wordt dit opgeslagen.
if (pinRead != pinState) {
pinState = pinRead;
//vervolgens kun je met de waarde doen wat je wilt,
//bijvoorbeeld een LED aansturen.
digitalWrite(ledPin,!pinState);
}
}
Over de pullup weerstand
In de code zie je dat er in de setup een pullup weerstand aangezet wordt. Deze weerstand zit ingebouwd in de Teensy en gaat van de +3.3V naar de desbetreffende pin. Dit zorgt ervoor dat als de knop niet ingedrukt is, de waarde 1 / HIGH is en als de knop wel ingedrukt is 0 / LOW. Op de plek waar de LED wordt aangezet staat er daarom dus ook een ! voor de pinState. Dat geeft aan dat de waarde gelijk is aan het omgekeerde van de pinState. Als de pinState laag is (knop is ingedrukt) gaat de LED aan, als de pinState hoog is (knop niet ingedrukt) gaat de LED uit
potmeter / analoge sensor
int sensorPin = A0; //pin waarop de sensor is aangesloten.
void setup() {
//Start de seriële verbinding, zodat we straks
//Zorg dat de pin een input-pin is.
pinMode(sensorPin, INPUT);
//de waarde van de sensor kunnen laten zien
Serial.begin(115200);
}
void loop() {
delay(10); //laat de waarde iets minder vaak zien
//Haal de waarde van de sensor op en
//sla deze op in de variabele *val*
int val = analogRead(sensorPin);
//Laat de waarde zien in de Serial Monitor
//(vergrootglasicoon rechtsboven / cdm/ctr + shift + m)
Serial.print("Sensorwaarde: ");
//println zorgt dat er een nieuwe regel
//wordt gemaakt na geprint te hebben
Serial.println(val);
}
In het plaatje hierboven zien we hoe een potmeter moet worden aangesloten. Deze manier van aansluiten gaat op voor elke andere analoge sensor, zoals bijvoorbeeld een infrarood afstandmeter, een analoge thermometer, regensensor etc.
Spanningsdeler
De manier waarop de analoge sensor is aangesloten zorgt dat het een spanningsdeler wordt. De waarde die wordt uitgelezen vanuit de middelste pin wordt bepaald door de hoeveelheid weerstand die tussen de linkerpin en de middelste pin zit én tussen de rechterpin en de middelste pin.
- Als deze weerstanden exact hetzelfde zijn zal de spanning precies door tweeën gedeeld worden: van de 3.3V die er doorheen gaat wordt 1.65V naar de middelste pin gestuurd.
- Als de weerstand aan de linkerkant maximaal is en aan de rechterkant 0, dan komt er 3.3V uit (de spanning wordt in zijn geheel naar de middelste pin gestuurd.)
- Als de weerstand aan de rechterkant maximaal is en aan de linkerkant 0, dan komt er 0V uit (de spanning wordt tegengehouden door de weerstand, de middelste pin zal dus de korste weg zoeken, naar de ground)
LED
//pin waarop de led is aangesloten
int ledPin = 4;
void setup() {
//zorg dat de ledPin in output mode staat:
pinMode(ledPin,OUTPUT);
}
void loop() {
//wacht elke iteratie van de loop 500ms voordat ie verder gaat.
delay(500);
//kies een willekeurige status voor de led, uit of aan
int state = random(0,1);
//Zorg dat de led in de staat komt die hierboven gekozen is,
digitalWrite(ledPin,state);
}
Timing
Om op een Teensy eens in de zoveel tijd iets uit te voeren moeten we weten hoe lang de Teensy ergens mee bezig, of de Teensy tijdelijk even vertragen. Dat kan op verschillende manieren, waarbij de een efficiënter is dan de ander.
delay()
Met delay(100) zet je de Teensy 100ms (of elk ander getal dat je tussen de haakjes invult) stil. Maar dan ook helemaal stil. Je kan op dat moment geen andere code uitvoeren of bijvoorbeeld data uit een sensor uitlezen, wat dus niet ideaal is. Om dat op te lossen zijn er twee opties, die hieronder beschreven staan.
millis()
De functie millis() geeft de hoeveelheid milliseconden aan sinds je de Teensy hebt aangezet. Je kan deze waarde opslaan in een variabele en op die manier achterhalen hoe lang er tussen twee events zit. Dat doe je met de onderstaande code:
//maak een variabele voor de milliseconden:
//dit is een variabele van het type unsigned long
//omdat daar een heel groot getal in kan
//en milliseconden lopen nogal snel op.
unsigned long startTime;
void setup() {
//haal de milliseconden sinds start op en plaats in de variabele
startTime = millis();
//begin seriële communicatie
Serial.begin(9600);
}
void loop() {
//haal de actuele tijd binnen
unsigned long nowTime = millis();
//kijk of het verschil tussen de starttijd en de huidige tijd
//groter is dan 500, ofwel of er 500ms zijn verstreken
if (nowTime - startTime > 500) {
//zet de starttijd op de huidige tijd, zodat je dit opnieuw kan doen
startTime = nowTime;
//doe hier iets!
Serial.println("500ms voorbij!");
}
}
elapsedMillis
Een andere optie is om het datatype elapsedMillis te gebruiken. Dit is net als int, float, string etc. een datatype waar je een variabele in kan opslaan. Dit type telt automatisch elke milliseconde een bij op. Dus als het in het begin 0 is, is het 1000ms later 1000 etc. Je kan dit getal elk moment naar 0 terugzetten, en zo dus ook kijken of er een x-aantal milliseconden voorbij zijn. Zie de voorbeeldcode hieronder:
//maak een variabele aan van het type ellapsedMillis
elapsedMillis verstreken = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
//kijk of er 500ms voorbij zijn
if (verstreken > 500) {
//zet de variabele weer op 0
verstreken = 0;
//doe iets!
Serial.println("500ms voorbij!");
}
}Seriële communicatie
De snelste manier om te checken of dat wat denk dat de code doet ook daadwerkelijk is wat je code doet is door via seriële communicatie een bericht te sturen van de Teensy naar je computer. Deze seriële communicatie verloopt via de USB-kabel. Je kan de data die van je Teensy komt vervolgens op twee manieren uitlezen. Zie hieronder voor meer informatie.
Seriële communicatie begin je altijd door in de setup()-functie aan te geven dat je berichten wil doorsturen. dit doe je moet de volgende regel code:
void setup() {
Serial.begin(9600);
}Serial.begin() geeft aan dat je vanuit de Teensy een seriële verbinding wil opzetten. Het getal dat als argument is meegegeven aan de functie, 9600, geeft aan hoe snel die communicatie moet verlopen. Dit getal is in het geval van de Teensy niet heel belangrijk omdat de Teensy altijd op de maximale USB-snelheid communiceert.
Serial monitor
In de seriële monitor kan je teruglezen welke data er vanuit de Teensy naar de computer wordt gestuurd. Je kunt de Serial Monitor openen door op het vergrootglas rechtsboven in je scherm te klikken. Of door de snelkoppeling ctrl/cmd + shift + m te gebruiken. Om te lezen welke data de Teensy stuurt moet je wel selecteren naar welke poort de computer moet luisteren. Dat doe je door bij Tools -> port de Teensy te selecteren.
Data sturen naar de Seriële monitor kan door middel van Serial.print() en Serial.println(), zie het code-voorbeeld hieronder:
int counter = 0;
void setup() {
Serial.begin(9600);
}
void draw() {
Serial.print("counterwaarde: ");
Serial.println(counter);
counter++;
}Met Serial.print() stuur je een regel tekst door naar de Serial Monitor. Met Serial.println() stuur je een regel tekst door naar de Serial Monitor en voeg je meteen een new-line toe, waardoor de volgende boodschap op de volgende regel wordt geprint.
Serial plotter
Met de seriële plotter kan je de data in een grafiek weergeven. Het komt nogal nauw hoe je de data via Serial.print() en Serial.println() verstuurt om het goed in de plotter te zien te krijgen. Hieronder een voorbeeld:
int pot1 = analogRead(A0);
int pot2 = analogRead(A1);
Serial.print("A0:");
Serial.print(pot1);
Serial.print(", A1:");
Serial.println(pot2);Na de naam voor de eerste lijn moet een dubbele punt en geen spatie, daarna volgt de waarde die in de plotter moet komen. Om nog een tweede waarde te sturen scheidt je de verschillende waarden met een komma. De laatste waarde verstuur je met Serial.println().
Hiermee zie je dat de waardes de hele tijd schalen naar de waardes die op dat moment worden uitgestuurd. Om dat aan te passen kan je een statische waarde voor de minimale en maximale waarde toevoegen.
int pot1 = analogRead(A0);
int pot2 = analogRead(A1);
Serial.print("Min:");
Serial.print(0);
Serial.print(", Max:");
Serial.print(1024);
Serial.print(", A0:");
Serial.print(pot1);
Serial.print(", A1:");
Serial.println(pot2);