SPAD-it Wiki - User contributions [en]

Arduino - Infrarood afstandbediening

2020-12-14T10:48:17Z

WikiAdmin: /* Beetje spelen */

Infrarood is onzichtbaar licht. De golflengte van dat licht is wat langer dan van rood licht en onze ogen zijn daarvoor ongevoelig. Infrarood licht kan wel worden waargenomen met een digitale camera. Met bijvoorbeeld de camera van je mobieltje kun je in veel gevallen zien wanneer een afstandbediening een signaal uitzendt. Maar sommige mobieltjes hebben zo'n goed infrarood filter dat het daarbij niet werkt. In elk geval zend een IR afstandbediening infrarood licht uit dat door een ''ontvanger'' wordt gezien. Het uitgezonden licht is niet gewoon een lamp die aan of uit staat, maar een snel knipperend lampje, waarbij informatie verstopt zit in de knippering. Daardoor kan zo'n afstandbediening complexe opdrachten geven.

===IR communicatieprotocol===
Voor het coderen van informatie in de knippering van afstandbedieningen bestaan diverse ''protocollen''. Een veelgebruikt protocol is het ''NEC protocol''. Hierbij wordt een digitaal signaal doorgegeven dat steeds bestaat uit 16 ''bits''. Een bit is simpelweg een 1 of een 0. Van de 16 bits zijn de eerste 8 bits het ''adres'', terwijl de tweede 8 bits staan voor het ''commando''. Simpel gezegd geeft het adres aan voor wie het signaal is bedoeld (TV, Video recorder, etc.), terwijl het commando aangeeft wat er moet gebeuren. Met 8 bits heb je genoeg voor 1024 adressen en dus ook 1024 commando's. Andere protocollen zijn o.a.: ''SONY'', ''RC5'' en ''RC6''.

Het NEC protocol gebruikt een standaard knipperfrequentie van 38 kHz. Dat wil zeggen dat het lapmje 38 duizend keer per seconde aan en uit gaat. Dit wordt gedaan om verstoring door andere bronnen te vermijden; de ontvanger reageert alleen op lampjes die met ongeveer 38 kHz knipperen. Andere bronnen van infrarood licht hebben dan geen effect. Voor het doorgeven van een 0-bit geeft de zender een korte tijd een knipper-signaal en zet daarna het lampje even uit. Voor het doorgeven van een 1-bit geeft de zender ook een korte tijd een knipper-signaal, maar zet daarna het lampje wat langer uit. Een 0 heeft dus een korte pauze en een 1 een lange pauze. Er komt nog wel wat meer bij kijken, maar het belangrijkste is hiermee gezegd. Overigens hebben andere protocollen andere kenmerken. Zo heeft het SONY protocol een draagfrequentie van 40 kHz en meerdere modi (12 bit tot 20 bit). In het algemeen vallen de draagfrequenties van afstandbedieningen tussen de 30 en 56 kHz en kun je mogelijk niet alle draagfrequenties met dezelfde ontvanger bedienen.

{|class="wikitable"
|-
|[[File:NEC_protocol.png]]
|-
|Digitale 0 en digitale 1 volgens het NEC protocol
|}

Als zender heb je niet meer nodig dan een eenvoudige infrarood LED met weerstand. De ontvanger bestaat uit een infrarood sensor die filtert op ongeveer 40 kHz (geschikt voor alle gangbare protocollen). Meestal gebruiken we daarvoor een speciaal element: een IR ontvanger. Daarna moeten we de eentjes en nulletjes zien te ontdekken uit het ontvangen signaal. De software die hiervoor nodig is vinden we simpelweg in een kant en klare bibliotheek: '''IRremote.h'''. Met deze bibliotheek kun je zowel een infrarood zender als een ontvanger aansturen. We nemen aan dat je beschikt over een infrarood afstandbediening (zender), zodat we ons hier kunnen concentreren op de ontvanger. De bibliotheek is bovendien geschikt voor meerdere protocollen, waaronder dus NEC, SONY, RC5 en RC6. Dit zullen we in dit project ook zien zodat het voor nu niet nodig is om het protocol van je afstandbediening vooraf te weten.

===De schakeling===
Omdat we ons hier zuiver willen concentreren op de techniek, houden we het project zo eenvoudig mogelijk. De software geeft resultaten door aan de PC via de Serial Monitor; we gaan hier geen dingen of lampjes besturen.

Extra benodigdheden:
*1 infrarood afstandbediening (zender)
*1 infrarood ontvanger module

{|class="wikitable"
|-
|[[File:IRreciever.jpg]]
|-
|Een IR-ontvanger
|}

{|class="wikitable"
|-
|[[File:IRreciever_schakeling.png]]
|-
|Aansluiten IR-ontvanger
|}

===Het programma===

<pre>
#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results; // variabele voor gedecodeerde resultaten

void showResults(decode_results *results) { // LET OP: "*results" ipv "results" => directe toegang tot de variabele
if (results->decode_type == UNKNOWN)
{
Serial.println("Onbekend protocol: kan helaas niet decoderen");
} else {
if (results->decode_type == NEC)
{
Serial.print("Decoded NEC: ");
}
else if (results->decode_type == SONY)
{
Serial.print("Decoded SONY: ");
}
else if (results->decode_type == RC5)
{
Serial.print("Decoded RC5: ");
}
else if (results->decode_type == RC6)
{
Serial.print("Decoded RC6: ");
}
else // DISH, SHARP, PANASONIC, JVC, SANYO, MITSUBISHI
{ // een van de andere herkende protocollen
Serial.print("Decoded type ");
Serial.print(results->decode_type);
Serial.print(": ");
}
Serial.print(results->value, HEX);
Serial.print(" (");
Serial.print(results->bits, DEC);
Serial.println(" bits)");
}
}

void setup() {
pinMode(RECV_PIN, INPUT);
pinMode(13, OUTPUT); // OnBoard LEDje knippert bij signaal

Serial.begin(9600); // Start de Serial monitor
irrecv.enableIRIn(); // Start de ontvanger software
}

bool on = false;
unsigned long last = millis();

void loop() {
if (irrecv.decode(&results))
{
// Laat het OnBoard LEDje knipperen en toon results
if (millis() - last > 250) // niet vaker dan 4x per secone (elke 250ms)
{
on = !on; // "!" is "NOT": aan gaat uit en uit gaat aan
if (on==true) {
digitalWrite(13, HIGH);
} else {
digitalWrite(13, LOW);
}
showResults(&results); // LET OP: hier moet "&results" gebruikt omdat de functie "*results" gebruikt
}
last = millis();
irrecv.resume(); // ontvang de volgende waarde
}
}
</pre>

===Uitleg===
De ''setup()'' methode zet de pin-modes van de pin voor de IR receiver (pin 11) en de pin van de interne LED (pin 13) in output-mode. Daarna wordt de seriele interface gestart en ook de software van de IRremote bibliotheek.

De ''loop()'' methode kijkt continu naar de receiver op pin 11. Indien de functie ''irrecv.decode()'' aangeeft dat er een signaal is uitgelezen, gaat de methode die informatie verwerken. Die informatie is dan al opgeslagen in de ''results'' variabele. Allereerst zal de OnBoard LED aan- of juist uitgezet worden (tot 4x per seconde). Daarna zal de uitgelezen waarde worden weggeschreven naar de Serial Monitor. Voor dat laatste roept het de functie ''showResults()'' aan.

De functie ''showResults()'' leunt natuurlijk erg op de ''results'' variabele zelf. Deze is van het type ''decode_results'' en heeft intern het ''decode_type'' (integer), en een ''value'' (unsigned long). Daarnaast kun je via ''decode_results'' rechtstreeks de bits van het signaal benaderen, waarbij ''rawlen'' aangeeft hoeveel bits er zijn. Voor het ''decode_type'' heeft de library een serie voorgeprogrammeerde waarden zoals NEC, SONY, en RC5. Dit zijn dus geen teksten (tussen quotjes) maar namen van (integer) constanten.

De functie vergelijkt dus de waarde van ''results->decode_type'' met voorgeprogrammeerde waarden, zoals UNKNOWN, NEC, en SONY. Indien een van deze waarden wordt herkend, wordt de naam van het herkende protocol op de Serial Monitor gezet:
<pre>
Serial.print("Decoded SONY: ");
</pre>
Na het printen van de naam van het protocol, print de functie de ''value'' in HEX format. '''Deze ''value'' is in het algemeen het gegeven waarmee je een bepaalde functie zou uitvoeren''', tenminste als je echt een actie zou willen koppelen aan het gebruiken van de afstanbediening. Die value werd, nadat het protocol herkend werd, ook meteen bepaald. Ook het aantal bits waaruit die ''value'' bestaat wordt tussen haakjes weergegeven. Dit aantal is afhankelijk van het protocol.

Het resultaat is ook als raw-data beschikbaar. Daarvoor heeft ''results'' een referentie aan ''rawbuf[]'' en een ''rawlen'' die de grootte van ''rawbuf'' aangeeft. Als je niet genoeg hebt aan ''value'' kun je hier eens naar kijken.

===Beetje spelen===
Loop eens door het huis om te zoeken naar afstandsbedieningen en kijk of je erachter kunt komen welke protocollen de afstandsbedieningen gebruiken. Hebben jullie een apparaat van Sony? Dan gebruikt die vast het SONY protocol! Apparaten van Philips gebruiken het RC5 of RC6 protocol, omdat die door Philips zijn ontwikkeld. Je zult ook wel eens merken dat een bepaald signaal verschillend wordt geinterpreteerd. Kennelijk lijken sommige protocollen soms teveel op elkaar om het onderscheid met voldoende zekerheid te maken, maar dit probleem kan natuurlijk ook worden veroorzaakt door onvolkomendheden in de IRremote bibliotheek.

In principe kun je met de IRremote bibliotheek ook infrarood LED's aansturen. IR-LED's zijn goedkoop en op dezelfde wijze aan te sluiten als gewone LED's. Meestal zijn ze zwart/donkerpaars van kleur. Met zo'n schakeling kun je in elk van de ondersteunde protocollen commando's versturen. Eerst gebruik je dan bovenstaand project om erachter komen welk protocol en welk commando gebruikt wordt om jullie televisie aan en uit te zetten, of je maakt zelfs een lijst van alle belangrijke commando's van je TV afstandbediening. Vervolgens zou je die commando's in een Arduino kunnen programmeren zodat je met de Arduino de TV kunt bedienen. Je zou ook commando's via je toetsenbord kunnen opgeven als je gebruik maakt van een Serial connectie. Dan kun je je PC gebruiken als afstandbediening.

===Navigatie===
*[[Arduino - Een digitale clock|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - Een joystick|Volgende project]]

Arduino - Een digitale clock

2020-12-14T10:26:09Z

WikiAdmin: /* Uitleg */

Een digitale clock module biedt Arduino de mogelijkheid om de echte datum en tijd uit te lezen. De term waar je op moet zoeken voor zo'n module is RTC - Real Time Clock. Een dergelijke module heeft een eigen batterij waarmee de klok oneindig doorloopt, ook als de stroom wordt uitgeschakeld. De interne klok draait om een kristal (TCXO - temperature compensated crystal oscillator) met een heel precies bekende eigen frequentie, waardoor de klok vrij nauwkeurig de tijd kan volgen. In dit voorbeeld gaan we uit van een populaire module, de DS3231, die voor minder dan €3,00 te koop wordt aangeboden. De specs hiervan geven een maximale afwijking van 0.5 seconde per dag. De module beschikt over een I2C bus waarmee hij met Arduino kan ''praten''. Een andere prettige eigenschap is dat deze module zowel op 3.3V kan werken als op 5V. Het ding heeft ook nog een temperatuurmeting aan boord, maar die heeft slechts een nauwkeurigheid van ±3˚C en dient vooral voor de interne temperatuurcompensatie.

{|class="wikitable"
|-
|[[File:DS3231_RTC.png]]
|-
|Een DS3231 RTC module
|}

===De schakeling===
Extra benodigdheden:
*1 DS3231 module

{|class="wikitable"
|-
|[[File:DS3231_Schakeling.png]]
|-
|Schakeling voor een RTC module voor een Arduino UNO
|}

De SDA aansluiting van de module moet aan analoge pin A4, terwijl de SCL aansluiting naar analoge pin A5 moet. De keuze van deze pin connecties is niet vrij; de I2C Wire interface vereist deze connecties. Het programma bevat dan ook geen regels om de pin-connecties in te stellen. Pas wel op: op een Arduino Mega gaat het voor de SDA om pin 20 en voor de SCL aansluiting om pin 21. Voor andere Arduino's kun je de juiste aansluitingen [https://www.arduino.cc/en/reference/wire hier] opzoeken.

Overigens lijkt de afgebeelde RTC module geen batterij te hebben en heeft hij een dubbele set aansluitingen. De aansluitingen die we nodig hebben zijn VCC (rood, 5 Volt), GND (zwart, 0 Volt), SCL (groen) en SDA (oranje). Eventuele andere aansluitingen op de module kunnen we negeren.

===Het programma===
<pre>
#include "Wire.h"
#define DS3231_I2C_ADDRESS 0x68 // vervangt "DS3231_I2C_ADDRESS" steeds door de byte "0x68"

char DayOfWeek[][4] = {"Mon","Tue","Wed","Thu","Fri","Sat","Sun"}; // DayOfWeek[0]=maandag en DayOfWeek[6]=zondag

struct DateTime {
byte year;
byte month;
byte day;
byte hour;
byte minute;
byte second;
byte dayOfWeek;
};

byte decToBcd(byte val)
// Convert normal decimal numbers to binary coded decimal
{
return( (val/10*16) + (val%10) );
}

byte bcdToDec(byte val)
// Convert binary coded decimal to normal decimal numbers
{
return( (val/16*10) + (val%16) );
}

void setDS3231time(DateTime dt)
{
// sets time and date data to DS3231
Wire.beginTransmission(DS3231_I2C_ADDRESS);
Wire.write(0); // set next input to start at the seconds register
Wire.write(decToBcd(dt.second)); // set seconds
Wire.write(decToBcd(dt.minute)); // set minutes
Wire.write(decToBcd(dt.hour)); // set hours
Wire.write(decToBcd(dt.dayOfWeek)); // set day of week (1=Sunday, 7=Saturday)
Wire.write(decToBcd(dt.day)); // set date (1 to 31)
Wire.write(decToBcd(dt.month)); // set month
Wire.write(decToBcd(dt.year)); // set year (0 to 99)
Wire.endTransmission();
}

void readDS3231time(DateTime &dt) // dt by reference
{
Wire.beginTransmission(DS3231_I2C_ADDRESS);
Wire.write(0); // set DS3231 register pointer to 00h
Wire.endTransmission();
Wire.requestFrom(DS3231_I2C_ADDRESS, 7);
// request seven bytes of data from DS3231 starting from register 00h
dt.second = bcdToDec(Wire.read() & 0x7f);
dt.minute = bcdToDec(Wire.read());
dt.hour = bcdToDec(Wire.read() & 0x3f);
dt.dayOfWeek = bcdToDec(Wire.read());
dt.day = bcdToDec(Wire.read());
dt.month = bcdToDec(Wire.read());
dt.year = bcdToDec(Wire.read());
}

void displayDateTime(DateTime dt)
{
Serial.print(DayOfWeek[dt.dayOfWeek]);
Serial.print(' ');
if (dt.day<10) Serial.print('0');
Serial.print(dt.day, DEC);
Serial.print('-');
if (dt.month<10) Serial.print('0');
Serial.print(dt.month, DEC);
Serial.print("-20"); // "year" bestaat uit slechts een of twee decimalen
if (dt.year<10) Serial.print('0');
Serial.print(dt.year, DEC);
Serial.print(' ');
if (dt.hour<10) Serial.print('0');
Serial.print(dt.hour, DEC);
Serial.print(':');
if (dt.minute<10) Serial.print('0');
Serial.print(dt.minute, DEC);
Serial.print(':');
if (dt.second<10) Serial.print('0');
Serial.print(dt.second, DEC);
Serial.println();
}

void setup()
{
Wire.begin();
Serial.begin(9600);
// als nodig stel je hier de datum en tijd opnieuw in
// DateTime dt;
// dt.year=17; // = 2017
// dt.month=6;
// dt.day=8;
// dt.hour=10;
// dt.minute=3;
// dt.second=0;
// dt.dayOfWeek=3; // 3=donderdag
// setDS3231time(dt);
}

void loop()
{
DateTime dt;
readDS3231time(dt);
displayDateTime(dt);
delay(1000); // elke seconde
}
</pre>

===Uitleg===
Het programma gebruikt weer de library ''Wire.h'' die het I2C protocol implementeert. De tweede regel legt het adres vast van de DS3231 module op de I2C bus. Dat adres is 0x68 maar in de code kan ''DS3231_I2C_ADDRESS'' worden gebruikt.
<pre>
#define DS3231_I2C_ADDRESS 0x68
</pre>
Deze ''#define'' instructie zorgt er in feite voor dat overal waar ''DS3231_I2C_ADDRESS'' staat ''0x68'' wordt gelezen. Overigens is de schrijfwijze ''0x68'' een hexadecimale representatie van de byte. De decimale waarde ervan is 104.

Vervolgens wordt een lijst met strings gedefinieerd waarin we de namen van de weekdagen opslaan. Het is handig om dit in een lijst te hebben omdat we later nummers van weekdagen moeten vertalen naar hun respectievelijke namen.

Dan volgt er een stukje waarin een ''struct'' wordt gedefinieerd. Een ''struct'' is een variabele type dat meerdere elementen kan bevatten. Hier gaat het om een ''struct'' die we ''DateTime'' noemen, met daarin 7 bytes die we de namen geven ''year'', ''month'', ''day'', ''hour'', ''minute'', ''second'' en ''dayOfWeek''. Elke variabele van het type DateTime bevat vanaf nu 7 bytes die via hun namen beschikbaar zijn.

Er volgen twee functies voor het omzetten van bytes van Bcd naar decimale codering en andersom. Dit heeft te maken met enigszins afwijkende de wijze waarop de gegevens van en naar de clock module worden gestuurd: Bcd format.

De functie ''setDS3231time'' kan gebruikt worden om de datum en tijd in te stellen op de klok-module. Dit hoeft maar zelden te gebeuren, maar als je een nieuwe module hebt is het vaak wel nodig. Merk op dat deze functie een parameter mee krijgt van het type DateTime. De werking van de functie is alsvolgt. Via de I2C verbinding wordt een transmissie gestart. Daarna wordt er een '0' weggeschreven. Dit zorgt ervoor dat de module de gegevens die hij gaat ontvangen wegschrijft op de juikste plek (beginnend vanaf positie 0). Daarna worden de elementen van datum en tijd in de juiste volgorde weggeschreven naar de module. Kennelijk staat intern in de DS3231 seconde op positie 0, minute op positie 1, en zo voort. Als alles is opgestuurd wordt de transmissie afgesloten.

De functie ''readDS3231time'' heeft ook een parameter van het type DateTime. Bij de parameternaam ''dt'' staat nu echter het '''&''' teken. Dit wijst erop dat de parameter ''by reference'' wordt doorgegeven: bij het doorgeven wordt geen kopie gemaakt van de waarde van de variabele (dat is standaard) maar wordt de variabele zelf doorgegeven. Daardoor kan de functie de inhoud van de variabele aanpassen en dat is natuurlijk wat deze read functie moet doen. De functie begint met een write opdracht binnen een transmissie. Dit zorgt ervoor dat de read opdrachten die volgen beginnen op positie 0. De eerste byte staat dan voor ''second''. Zonder die eerste write is het onduidelijk welke byte de module zal doorgeven en krijg je dus rommel. De feitelijke leesopdracht is:
<pre>
Wire.requestFrom(DS3231_I2C_ADDRESS, 7);
</pre>
Hierbij worden 7 bytes gelezen (daarvoor is de parameter 7). Deze worden in de Wire bibliotheek opgeslagen en zijn beschikbaar om uit te lezen. Dat uitlezen gebeurt vervolgens in de 7 volgende statements.

De functie ''displayDateTime()'' verwerkt de opgegeven datum en schrijft die naar de Serial Monitor. Daarbij wordt ervoor gezorgt dat alle getallen met twee cijfers worden weggeschreven. 3 januarie 2001 wordt dan 03-01-2001 en niet 3-1-201. Merk op dat deze functie de lijst met weekdagen gebruikt om het dagnummer dayOfWeek om te zetten in een tekst.

De ''setup()'' functie hoeft geen pin modi in te stellen omdat de I2C bus altijd via de A4 en A5 pins lopen (op een Arduino UNO). Het enige dat hier hoeft te gebeuren is het starten van de I2C verbinding en de normale seriele verbinding.
<pre>
Wire.begin();
Serial.begin(9600);
</pre>
Verder kun je hier de datum en tijd van de module opnieuw instellen. Als die al goed staat moet je dit niet doen natuurlijk, want elke keer dat je programma start wordt de setup() doorlopen en wordt de datum/tijd opnieuw ingesteld op hetgeen je hier opgeeft.

Ook de loop() functie is nu erg eenvoudig. De datum/tijd wordt uitgelezen uit de module middels de ''readDS3231time()'' functie, waarna die wordt weggeschreven naar de Serial Monitor via ''displayDateTime()''. Dan wacht de functie een seconde voor het zich kan herhalen.

===Beetje spelen===
Mochten datum en tijd verkeerd zijn ingesteld, en die kans is natuurlijk vrij groot, dan kun je juiste instellingen voor datum en tijd in de setup() zetten en de code daarvoor activeren (door de "//" ervoor weg te halen). Let op dat je dit stuk van de code zo precies mogelijk op het juiste moment uitvoert en vooral dat je ervoor waakt de code later niet te herstarten. Elke keer als setup() wordt uitgevoerd wordt de datum en tijd van de module namelijk weer teruggezet naar hetgeen in het programma staat. Om dat te voorkomen kun je het beste de betreffende regels, meteen na het succesvol uitvoeren ervan, weer veranderen in commentaar en de code opnieuw naar je Arduino sturen. Vanaf dat moment zou de RTC datum en tijd correct moeten onthouden en mee laten lopen met de echte tijd. Het is tenslotte een Real Time Clock. Desnoods breidt je je project uit met een knop waarmee datum en tijd wordt ingesteld. Dan time je met een goede klok het moment om op de knop te drukken. De uitdaging is om de klok op de seconde af correct ingesteld te krijgen.

===Navigatie===
*[[Arduino - Temperatuur meten met een DS18B20 sensor|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - Infrarood afstandbediening|Volgende project]]

Arduino - Een digitale clock

2020-12-14T10:25:41Z

WikiAdmin: /* De schakeling */

Een digitale clock module biedt Arduino de mogelijkheid om de echte datum en tijd uit te lezen. De term waar je op moet zoeken voor zo'n module is RTC - Real Time Clock. Een dergelijke module heeft een eigen batterij waarmee de klok oneindig doorloopt, ook als de stroom wordt uitgeschakeld. De interne klok draait om een kristal (TCXO - temperature compensated crystal oscillator) met een heel precies bekende eigen frequentie, waardoor de klok vrij nauwkeurig de tijd kan volgen. In dit voorbeeld gaan we uit van een populaire module, de DS3231, die voor minder dan €3,00 te koop wordt aangeboden. De specs hiervan geven een maximale afwijking van 0.5 seconde per dag. De module beschikt over een I2C bus waarmee hij met Arduino kan ''praten''. Een andere prettige eigenschap is dat deze module zowel op 3.3V kan werken als op 5V. Het ding heeft ook nog een temperatuurmeting aan boord, maar die heeft slechts een nauwkeurigheid van ±3˚C en dient vooral voor de interne temperatuurcompensatie.

{|class="wikitable"
|-
|[[File:DS3231_RTC.png]]
|-
|Een DS3231 RTC module
|}

===De schakeling===
Extra benodigdheden:
*1 DS3231 module

{|class="wikitable"
|-
|[[File:DS3231_Schakeling.png]]
|-
|Schakeling voor een RTC module voor een Arduino UNO
|}

De SDA aansluiting van de module moet aan analoge pin A4, terwijl de SCL aansluiting naar analoge pin A5 moet. De keuze van deze pin connecties is niet vrij; de I2C Wire interface vereist deze connecties. Het programma bevat dan ook geen regels om de pin-connecties in te stellen. Pas wel op: op een Arduino Mega gaat het voor de SDA om pin 20 en voor de SCL aansluiting om pin 21. Voor andere Arduino's kun je de juiste aansluitingen [https://www.arduino.cc/en/reference/wire hier] opzoeken.

Overigens lijkt de afgebeelde RTC module geen batterij te hebben en heeft hij een dubbele set aansluitingen. De aansluitingen die we nodig hebben zijn VCC (rood, 5 Volt), GND (zwart, 0 Volt), SCL (groen) en SDA (oranje). Eventuele andere aansluitingen op de module kunnen we negeren.

===Het programma===
<pre>
#include "Wire.h"
#define DS3231_I2C_ADDRESS 0x68 // vervangt "DS3231_I2C_ADDRESS" steeds door de byte "0x68"

char DayOfWeek[][4] = {"Mon","Tue","Wed","Thu","Fri","Sat","Sun"}; // DayOfWeek[0]=maandag en DayOfWeek[6]=zondag

struct DateTime {
byte year;
byte month;
byte day;
byte hour;
byte minute;
byte second;
byte dayOfWeek;
};

byte decToBcd(byte val)
// Convert normal decimal numbers to binary coded decimal
{
return( (val/10*16) + (val%10) );
}

byte bcdToDec(byte val)
// Convert binary coded decimal to normal decimal numbers
{
return( (val/16*10) + (val%16) );
}

void setDS3231time(DateTime dt)
{
// sets time and date data to DS3231
Wire.beginTransmission(DS3231_I2C_ADDRESS);
Wire.write(0); // set next input to start at the seconds register
Wire.write(decToBcd(dt.second)); // set seconds
Wire.write(decToBcd(dt.minute)); // set minutes
Wire.write(decToBcd(dt.hour)); // set hours
Wire.write(decToBcd(dt.dayOfWeek)); // set day of week (1=Sunday, 7=Saturday)
Wire.write(decToBcd(dt.day)); // set date (1 to 31)
Wire.write(decToBcd(dt.month)); // set month
Wire.write(decToBcd(dt.year)); // set year (0 to 99)
Wire.endTransmission();
}

void readDS3231time(DateTime &dt) // dt by reference
{
Wire.beginTransmission(DS3231_I2C_ADDRESS);
Wire.write(0); // set DS3231 register pointer to 00h
Wire.endTransmission();
Wire.requestFrom(DS3231_I2C_ADDRESS, 7);
// request seven bytes of data from DS3231 starting from register 00h
dt.second = bcdToDec(Wire.read() & 0x7f);
dt.minute = bcdToDec(Wire.read());
dt.hour = bcdToDec(Wire.read() & 0x3f);
dt.dayOfWeek = bcdToDec(Wire.read());
dt.day = bcdToDec(Wire.read());
dt.month = bcdToDec(Wire.read());
dt.year = bcdToDec(Wire.read());
}

void displayDateTime(DateTime dt)
{
Serial.print(DayOfWeek[dt.dayOfWeek]);
Serial.print(' ');
if (dt.day<10) Serial.print('0');
Serial.print(dt.day, DEC);
Serial.print('-');
if (dt.month<10) Serial.print('0');
Serial.print(dt.month, DEC);
Serial.print("-20"); // "year" bestaat uit slechts een of twee decimalen
if (dt.year<10) Serial.print('0');
Serial.print(dt.year, DEC);
Serial.print(' ');
if (dt.hour<10) Serial.print('0');
Serial.print(dt.hour, DEC);
Serial.print(':');
if (dt.minute<10) Serial.print('0');
Serial.print(dt.minute, DEC);
Serial.print(':');
if (dt.second<10) Serial.print('0');
Serial.print(dt.second, DEC);
Serial.println();
}

void setup()
{
Wire.begin();
Serial.begin(9600);
// als nodig stel je hier de datum en tijd opnieuw in
// DateTime dt;
// dt.year=17; // = 2017
// dt.month=6;
// dt.day=8;
// dt.hour=10;
// dt.minute=3;
// dt.second=0;
// dt.dayOfWeek=3; // 3=donderdag
// setDS3231time(dt);
}

void loop()
{
DateTime dt;
readDS3231time(dt);
displayDateTime(dt);
delay(1000); // elke seconde
}
</pre>

===Uitleg===
Het programma gebruikt weer de library ''Wire.h'' die het I2C protocol implementeerd. De tweede regel legt het adres vast van de DS3231 module op de I2C bus. Dat adres is 0x68 maar in de code kan ''DS3231_I2C_ADDRESS'' worden gebruikt.
<pre>
#define DS3231_I2C_ADDRESS 0x68
</pre>
Deze ''#define'' instructie zorgt er in feite voor dat overal waar ''DS3231_I2C_ADDRESS'' staat ''0x68'' wordt gelezen. Overigens is de schrijfwijze ''0x68'' een hexadecimale representatie van de byte. De decimale waarde ervan is 104.

Vervolgens wordt een lijst met strings gedefinieerd waarin we de namen van de weekdagen opslaan. Het is handig om dit in een lijst te hebben omdat we later nummers van weekdagen moeten vertalen naar hun respectievelijke namen.

Dan volgt er een stukje waarin een ''struct'' wordt gedefinieerd. Een ''struct'' is een variabele type dat meerdere elementen kan bevatten. Hier gaat het om een ''struct'' die we ''DateTime'' noemen, met daarin 7 bytes die we de namen geven ''year'', ''month'', ''day'', ''hour'', ''minute'', ''second'' en ''dayOfWeek''. Elke variabele van het type DateTime bevat vanaf nu 7 bytes die via hun namen beschikbaar zijn.

Er volgen twee functies voor het omzetten van bytes van Bcd naar decimale codering en andersom. Dit heeft te maken met enigszins afwijkende de wijze waarop de gegevens van en naar de clock module worden gestuurd: Bcd format.

De functie ''setDS3231time'' kan gebruikt worden om de datum en tijd in te stellen op de klok-module. Dit hoeft maar zelden te gebeuren, maar als je een nieuwe module hebt is het vaak wel nodig. Merk op dat deze functie een parameter mee krijgt van het type DateTime. De werking van de functie is alsvolgt. Via de I2C verbinding wordt een transmissie gestart. Daarna wordt er een '0' weggeschreven. Dit zorgt ervoor dat de module de gegevens die hij gaat ontvangen wegschrijft op de juikste plek (beginnend vanaf positie 0). Daarna worden de elementen van datum en tijd in de juiste volgorde weggeschreven naar de module. Kennelijk staat intern in de DS3231 seconde op positie 0, minute op positie 1, en zo voort. Als alles is opgestuurd wordt de transmissie afgesloten.

De functie ''readDS3231time'' heeft ook een parameter van het type DateTime. Bij de parameternaam ''dt'' staat nu echter het '''&''' teken. Dit wijst erop dat de parameter ''by reference'' wordt doorgegeven: bij het doorgeven wordt geen kopie gemaakt van de waarde van de variabele (dat is standaard) maar wordt de variabele zelf doorgegeven. Daardoor kan de functie de inhoud van de variabele aanpassen en dat is natuurlijk wat deze read functie moet doen. De functie begint met een write opdracht binnen een transmissie. Dit zorgt ervoor dat de read opdrachten die volgen beginnen op positie 0. De eerste byte staat dan voor ''second''. Zonder die eerste write is het onduidelijk welke byte de module zal doorgeven en krijg je dus rommel. De feitelijke leesopdracht is:
<pre>
Wire.requestFrom(DS3231_I2C_ADDRESS, 7);
</pre>
Hierbij worden 7 bytes gelezen (daarvoor is de parameter 7). Deze worden in de Wire bibliotheek opgeslagen en zijn beschikbaar om uit te lezen. Dat uitlezen gebeurt vervolgens in de 7 volgende statements.

De functie ''displayDateTime()'' verwerkt de opgegeven datum en schrijft die naar de Serial Monitor. Daarbij wordt ervoor gezorgt dat alle getallen met twee cijfers worden weggeschreven. 3 januarie 2001 wordt dan 03-01-2001 en niet 3-1-201. Merk op dat deze functie de lijst met weekdagen gebruikt om het dagnummer dayOfWeek om te zetten in een tekst.

De ''setup()'' functie hoeft geen pin modi in te stellen omdat de I2C bus altijd via de A4 en A5 pins lopen (op een Arduino UNO). Het enige dat hier hoeft te gebeuren is het starten van de I2C verbinding en de normale seriele verbinding.
<pre>
Wire.begin();
Serial.begin(9600);
</pre>
Verder kun je hier de datum en tijd van de module opnieuw instellen. Als die al goed staat moet je dit niet doen natuurlijk, want elke keer dat je programma start wordt de setup() doorlopen en wordt de datum/tijd opnieuw ingesteld op hetgeen je hier opgeeft.

Ook de loop() functie is nu erg eenvoudig. De datum/tijd wordt uitgelezen uit de module middels de ''readDS3231time()'' functie, waarna die wordt weggeschreven naar de Serial Monitor via ''displayDateTime()''. Dan wacht de functie een seconde voor het zich kan herhalen.

===Beetje spelen===
Mochten datum en tijd verkeerd zijn ingesteld, en die kans is natuurlijk vrij groot, dan kun je juiste instellingen voor datum en tijd in de setup() zetten en de code daarvoor activeren (door de "//" ervoor weg te halen). Let op dat je dit stuk van de code zo precies mogelijk op het juiste moment uitvoert en vooral dat je ervoor waakt de code later niet te herstarten. Elke keer als setup() wordt uitgevoerd wordt de datum en tijd van de module namelijk weer teruggezet naar hetgeen in het programma staat. Om dat te voorkomen kun je het beste de betreffende regels, meteen na het succesvol uitvoeren ervan, weer veranderen in commentaar en de code opnieuw naar je Arduino sturen. Vanaf dat moment zou de RTC datum en tijd correct moeten onthouden en mee laten lopen met de echte tijd. Het is tenslotte een Real Time Clock. Desnoods breidt je je project uit met een knop waarmee datum en tijd wordt ingesteld. Dan time je met een goede klok het moment om op de knop te drukken. De uitdaging is om de klok op de seconde af correct ingesteld te krijgen.

===Navigatie===
*[[Arduino - Temperatuur meten met een DS18B20 sensor|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - Infrarood afstandbediening|Volgende project]]

Arduino - Motor met Power

2020-12-07T12:15:33Z

WikiAdmin: /* Draairichting omkeren */

Een Arduino is prima om een paar LEDjes aan te sturen en eventueel een klein servo-motortje. Maar als je wat meer wilt, zoals veel LEDjes aansturen, of een behoorlijke elektrische motor, volstaat een Arduino niet meer. Toch kun je kunt zo'n motor wel aansluiten met een Arduino, en dan bijvoorbeeld de PWM mogelijkheden ervan gebruiken, maar dan kan het vermogen niet van de Arduino zelf komen; alleen het stuursignaal. Dit kan heel goed met een MOSFET driver. Zo'n MOSFET werkt als een heel snelle, elektronisch aanstuurbare schakelaar, die gemakkelijk mee kan doen met het signaal van de PWM. Daar komt als voordeel bij dat je een andere spanningsbron kunt gebruiken voor de motor. De motor kan bijvoorbeeld op een dikke acuu van 24 Volt werken, terwijl de Arduino het doet met een batterijtje van 5 Volt.

===MOSFET driver===

Bij de [[Arduino - De stappenmotor|stappenmotor]] hebben we die drivers al voorbij zien komen, maar er niet veel aandacht aan besteed. Nu gaan we iets dieper in op dergelijke drivers. Zoals gezegd werkt een MOSFET als een elektronisch bestuurbare schakelaar. Preciezer: het werkt als een spanninggestuurde schakelaar. Het gaat dan om de spanning aan de '''Gate''' ten opzichte van die aan de '''Source''' terwijl de '''Gate''' een vrijwel geen stroom opneemt. Nog preciezer: de MOSFET blokkeert de stroom als de spanning tussen Gate en Source onder een drempelwaarde ligt en laat maximaal door boven de verzadigingsspanning. Bij gate-spanningen daartussen is de stroom door de MOSFET ongeveer evenredig met de spanning. Dit is nu echter ongunstig omdat de MOSFET dan (veel) vermogen opneemt en heet kan worden. We gebruiken hem dus alleen in volledig geblokkeerde toestand en volledig verzadigde toestand. Een MOSFET kan echt ontzettend snel schakelen zodat de frequentie van het PWM signaal geen enkel probleem vormt.

{|class="wikitable"
|-
|[[File:MOSFET_aansturing.png]]
|-
|Arduino stuurt motor aan via (N-channel) MOSFET
|}

De '''Gate''' van de MOSFET krijgt het PWM signaal van de Arduino. Als het PWM signaal laag is, blokkeert de MOSET en kan er geen stroom door de motor lopen, maar als het signaal hoog is, wordt de weerstand van de MOSFET tussen '''Drain''' en '''Source''' (bijna) nul en krijgt de motor de volle lading van de Vdd. Daarbij kan een MOSFET heel snel schakelen en verbruikt die zelf dus maar heel weinig vermogen. Vdd is de voedingsspanning waar de motor op loopt. Deze mag gekoppeld zijn aan de +5 Volt die ook de Arduino voedt, maar dat hoeft niet en mag ook uit een andere bron komen (zoals in bovenstaand schema). Je kunt dan motoren gebruiken die op een heel andere spanning draaien dan de Arduino. Het is wel belangrijk dat de nul van de voeding van de Arduino gekoppeld wordt aan de nul van de motorvoeding.

De dikke lijnen door de motor en MOSFET geven aan dat hier veel stroom mag lopen. De maximale stroom door de MOSFET hangt af van het type dat wordt gekozen en ook of die wel of niet gekoeld wordt. Er zijn MOSFET's die wel 100 ampere kunnen schakelen!

Dan zien we nog een klein detail: de diode over de motor. Een diode is een elementje waar de stroom maar in één richting doorheen kan: de richting van het pijltje. Zoals je ziet zit de diode ''verkeerd om'', waardoor er geen stroom doorheen kan lopen. Het lijkt er daarom voor niets in te zitten. Dat is echter niet helemaal waar. De motor bevat spoelen en spoelen hebben de neiging om de stroom constant te houden. Als er dus een stroom van Vdd naar nul loopt (als het PWM signaal hoog is), en de MOSFET gaat blokkeren op het moment dat PWM laag wordt, zorgen de spoelen in de motor ervoor dat er toch nog even een stroom blijft lopen. Het gevolg is dat er op de Drain een spanning kan ontstaan die zo hoog kan zijn dat hij schadelijk is voor de Arduino en/of de MOSFET. Deze spanning wordt ook wel aangeduidt als de ''back EMF''. De diode is hiervoor bedoeld: het kortsluiten en dus onschadelijk maken van de ''back-EMF''. Als je in plaats van een motor een lamp wilt aansturen, kun je deze diode weglaten. Lampen geven namelijk geen back-EMF. Overigens hebben veel MOSFET's ook een ingebouwde diode (omgekeerd: van Source naar Drain) die ze beschermd tegen dit soort spanningen.

Het bovenstaande schema zal zeker wel werken, maar het is altijd beter om een weerstand op te nemen in de lijn met het PWM signaal. Dit is ook om de Arduino te beschermen. Een weerstand van 10kΩ is meestal een goede waarde. Daarnaast kan de output van de Arduino naar nul worden getrokken met een weerstand zodat het signaal sneller naar nul kan gaan. Beide extra weerstanden zijn opties en worden ook vaak weggelaten.

===Draairichting omkeren===

De schakeling uit de vorige paragraaf voldoet als je de motor alleen aan en uit wilt zetten, of alleen de motorsnelheid wilt besturen. In veel gevallen wil je echter ook dat de motor achteruit kan draaien. Voor het veranderen van de draairichting moet je de motor in een brug-schakeling opnemen. Deze is eerder besproken bij het [[Arduino_-_De_stappenmotor#Werking|stappenmotor-project]].

{|class="wikitable"
|-
|[[File:Brugschakeling.png]]
|-
|Motorspoel in brugschakeling
|}

Onthoud altijd goed dat je bij een brug-schakeling nooit de twee boven elkaar staande schakelaars sluit, want dan krijg je kortsluiting en gaan er dingen kapot. Natuurlijk gebruiken we ook hier MOSFETs in plaats van schakelaars. De MOSFET die we hierboven hebben gebruikt is een zogenaamde '''N-channel MOSFET'''. Dit type schakelt op basis van een positief spanningsverschil tussen Gate en Source. De Source is verbonden met aarde (nul) en de Gate met het input signaal. Als de Gate dan 5 Volt krijgt is de MOSFET open en anders zit hij dicht. De essentie is nu: de Gate voert 5 Volt meer dan op de Source. Omdat de Source aan de nul hangt is dat normaal een onbeduidend detail. Maar als je nu nog eens goed naar de burgschakeling kijkt, dan zie je dat het hier wat anders ligt. De bovenste MOSFET's hangen met de ene kant aan de plus, terwijl de spanning op de andere kant (voorheen de Source) ervan afhangt of de MOSFET blokkeert of doorlaat. Als hij doorlaat wordt die spanning ook hoog, blokkeert hij, dan wordt die spanning laag. Stel nu dat we hier ook een N-channel MOSFET zouden gebruiken. Dan moet de Gate, om hem volledig op doorlaten te zetten, een hogere spanning krijgen dan de Source (bijvoorbeeld 5 Volt hoger, de exacte spanning hangt af van het precieze type MOSFET). Maar zodra hij stroom gaat doorlaten, neemt de spanning op de Source toe en komt die zo'n beetje aan de plus te hangen. Dan zou hij dus weer meteen sluiten. Dat gaat dus niet goed. Daarbij wil je soms dat de motor op een veel hogere spanning draait dan de 5 Volt van je Arduino. Dat lukt natuurlijk nooit met alleen je Arduino.

Gelukkig is er nog en ander type MOSFET: de zogenaamde '''P-channel MOSFET'''. Deze wordt iets anders getekend (het pijltje van de Gate loopt andersom) en het schakelgedrag is net andersom en ook iets lastiger te begrijpen. Daarbij wordt hier de Source aan de plus gehangen terwijl de Drain naar de motor loopt. De spanning op de Source zit dus hoger dan die op de Drain. Zo werkt ook het schakelgedrag: de MOSFET opent als de Gate een spanning voert die (bijvoorbeeld 5 Volt) '''lager''' is dan de Source en hij sluit als de Gate een spanning krijgt die gelijk is aan die van de Source (of daar voldoende dichtbij komt).

Hieronder laten we nu het principe zien van de brugschakeling met vier MOSFET's voor de schakelaars. De dikke lijnen geven weer aan waar veel stroom kan lopen. De dunne lijnen zijn voor zwakke stuursignalen. De bovenste twee MOSFET's zijn van het P-type en de onderste twee van het N-type. De schakeling heeft twee PWM signalen nodig; beide richtingen worden afzonderlijk aangestuurd. Daar komt bij dat je ervoor moet zorgen dat als je '''PWM A''' wilt gebruiken (de ene draairichting) '''ON A''' hoog is (en '''ON B''' laag) en als je PWM B wilt gebruiken (de andere draairichting) '''ON B''' hoog moet zijn en ('''ON A''' laag). Als zowel '''ON A''' als '''ON B''' laag zijn draait de motor sowieso niet omdat dan beide P-channel MOSFET's zullen blokkeren. Ze beide hoog maken is een slecht idee omdat er dan kortsluiting ontstaat zodra een van de PWM ingangen even hoog wordt. De motor zal dan ook niet lopen, maar in plaats daarvan gaan je FET's eraan.

{|class="wikitable"
|-
|[[File:MOSFET_brugschakeling_simple.png]]
|-
|Brugschakeling met P-channel en N-channel MOSFET's
|}

Naast de vier MOSFET's gebruikt bovenstaande schakeling nog twee andere (gewone) NPN transistors. Deze worden hier alsvolgt gebruikt. Een spanning op '''ON A''' komt via de weerstand bij de basis (b) van de transistor terecht. Als die spanning voert, laat de NPN transistor stroom door van c (collector) naar e (emitter). Het gevolg is dat de gate van de P-channel MOSFET via de weerstanden voldoende laag gemaakt wordt om de P-channel MOSFET in geleiding te brengen. Als de spanning op '''ON A''' wegvalt, wordt de Gate gelijk aan de voedingsspanning en dus aan de spanning op de Source, waardoor de MOSFET gaat blokkeren. Hetzelfde geldt voor '''ON B'''. De bovenste MOSFET's staan dus continu aan of uit, terwijl het PWM signaal alleen op de onderste MOSFET's wordt gebruikt. Dit is des te meer een prima idee omdat de N-channel MOSFET's in het algemeen wat sneller schakelen dan de P-channel MOSFET's.

[[MOSFET's en de brugschakeling in meer detail|Hier]] zijn overigens meer details te vinden voor als je zelf een MOSFET brugschakeling zou willen ontwerpen. Er is ook een goed werkend voorbeeld tot wel 20 Ampere bij 30 Volt.

Al met al heb je nu een aardig idee hoe het werkt, maar echt gemakkelijk is het natuurlijk niet; het is een heel klusje om alle benodigde onderdelen goed aan te sluiten. Gelukkig zijn er voldoende alternatieven. Zo zijn er voor relatief weinig geld kant-en-klare driver boards te koop. Meestal gaat het dan om bordjes die gemaakt zijn voor het aansturen van bipolaire stappenmotoren, maar die zijn ook heel bruikbaar voor gewone gelijkstroommotoren. Voor de werking daarvan moet namelijk ook de stroomrichting worden omgekeerd zodat die ook gebasseerd zijn op de H-brug schakeling. Dergelijke bordjes zijn vaak gebasseerd op een chip met twee of soms zelfs vier ingebouwde H-brug schakelingen aan boord. Iets minder krachtig dan met losse MOSFET's maar veel gemakkelijke in gebruik. Een veelgebruikt voorbeeld is de L298N chip, inderdaad bedoeld voor bipolaire stappenmotoren. Een dergelijk bordje gaat tot zo'n 35 Volt en 2 Ampere, terwijl de logica op 5 Volt mag draaien (max 7 Volt). Prima geschikt dus voor onze Arduino. Voor deze specs moet het bordje wel uitgevoerd worden met een geschikte koeler, maar gekochte bordjes hebben vrijwel altijd een koeler. Omdat deze modules geschikt zijn voor bipolaire stappenmoteren, zijn ze gemaakt voor 2 sets van spoelen en hebben ze twee volledige H-brug schakelingen aan boord. In ondertsaand project sturen we maar een DC motor aan, maar je kunt dus ook twee motoren tegelijk mee aansturen. Of één zwaardere motor, door de beide H-bruggen parallel te gebruiken. Dan gaat hij tot 4 Ampere.

===De schakeling===

Extra benodigdheden:
*1 L298N MOSFET driver module
*1 DC motor (bijv. 12 Volt)
*1 Bijpassende batterij (dan ook 12 Volt)

{|class="wikitable"
|-
|[[File:naam bestand.png]]
|-
|Beschrijving bovenstaande figuur
|}

===Het programma===

<pre>
int motor=10;
int wait=10;

void setup()
{
pinMode(motor,OUTPUT);
}

void loop()
{
for (int i=0; i<256; i++) {
analogWrite(motor,i);
delay(wait);
}
for (int i=254; i>=0; i--) {
analogWrite(motor,i);
delay(wait);
}
}
</pre>

===Uitleg===
Het programma is uiterst simpel. De loop heeft twee delen waarin de motor eerst steeds meer vermogen krijgt en daarna steeds minder. Als het programma draait zul je zien dat de motor steeds sneller gaat draaien en dan weer afremt om meteen daarna weer te versnellen. En zo voort. Uiteraard kun je de motorsnelheid programmatisch aan bepaalde inputs koppelen en de snelheid regelen met bijvoorbeeld een potmeter. In dit project willen we alleen laten zien hoe je een zwaardere motor aan kunt sturen met een Arduino.

===Beetje spelen===
Leuk om zo'n motor aan te sturen, maar wat nu als de motor ook achteruit moet kunnen draaien?

===Navigatie===
*[[Arduino - GPS ontvanger|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - Micro-SDkaart|Volgende project]]

Arduino - Motor met Power

2020-12-07T12:08:43Z

WikiAdmin: /* MOSFET driver */

Een Arduino is prima om een paar LEDjes aan te sturen en eventueel een klein servo-motortje. Maar als je wat meer wilt, zoals veel LEDjes aansturen, of een behoorlijke elektrische motor, volstaat een Arduino niet meer. Toch kun je kunt zo'n motor wel aansluiten met een Arduino, en dan bijvoorbeeld de PWM mogelijkheden ervan gebruiken, maar dan kan het vermogen niet van de Arduino zelf komen; alleen het stuursignaal. Dit kan heel goed met een MOSFET driver. Zo'n MOSFET werkt als een heel snelle, elektronisch aanstuurbare schakelaar, die gemakkelijk mee kan doen met het signaal van de PWM. Daar komt als voordeel bij dat je een andere spanningsbron kunt gebruiken voor de motor. De motor kan bijvoorbeeld op een dikke acuu van 24 Volt werken, terwijl de Arduino het doet met een batterijtje van 5 Volt.

===MOSFET driver===

Bij de [[Arduino - De stappenmotor|stappenmotor]] hebben we die drivers al voorbij zien komen, maar er niet veel aandacht aan besteed. Nu gaan we iets dieper in op dergelijke drivers. Zoals gezegd werkt een MOSFET als een elektronisch bestuurbare schakelaar. Preciezer: het werkt als een spanninggestuurde schakelaar. Het gaat dan om de spanning aan de '''Gate''' ten opzichte van die aan de '''Source''' terwijl de '''Gate''' een vrijwel geen stroom opneemt. Nog preciezer: de MOSFET blokkeert de stroom als de spanning tussen Gate en Source onder een drempelwaarde ligt en laat maximaal door boven de verzadigingsspanning. Bij gate-spanningen daartussen is de stroom door de MOSFET ongeveer evenredig met de spanning. Dit is nu echter ongunstig omdat de MOSFET dan (veel) vermogen opneemt en heet kan worden. We gebruiken hem dus alleen in volledig geblokkeerde toestand en volledig verzadigde toestand. Een MOSFET kan echt ontzettend snel schakelen zodat de frequentie van het PWM signaal geen enkel probleem vormt.

{|class="wikitable"
|-
|[[File:MOSFET_aansturing.png]]
|-
|Arduino stuurt motor aan via (N-channel) MOSFET
|}

De '''Gate''' van de MOSFET krijgt het PWM signaal van de Arduino. Als het PWM signaal laag is, blokkeert de MOSET en kan er geen stroom door de motor lopen, maar als het signaal hoog is, wordt de weerstand van de MOSFET tussen '''Drain''' en '''Source''' (bijna) nul en krijgt de motor de volle lading van de Vdd. Daarbij kan een MOSFET heel snel schakelen en verbruikt die zelf dus maar heel weinig vermogen. Vdd is de voedingsspanning waar de motor op loopt. Deze mag gekoppeld zijn aan de +5 Volt die ook de Arduino voedt, maar dat hoeft niet en mag ook uit een andere bron komen (zoals in bovenstaand schema). Je kunt dan motoren gebruiken die op een heel andere spanning draaien dan de Arduino. Het is wel belangrijk dat de nul van de voeding van de Arduino gekoppeld wordt aan de nul van de motorvoeding.

De dikke lijnen door de motor en MOSFET geven aan dat hier veel stroom mag lopen. De maximale stroom door de MOSFET hangt af van het type dat wordt gekozen en ook of die wel of niet gekoeld wordt. Er zijn MOSFET's die wel 100 ampere kunnen schakelen!

Dan zien we nog een klein detail: de diode over de motor. Een diode is een elementje waar de stroom maar in één richting doorheen kan: de richting van het pijltje. Zoals je ziet zit de diode ''verkeerd om'', waardoor er geen stroom doorheen kan lopen. Het lijkt er daarom voor niets in te zitten. Dat is echter niet helemaal waar. De motor bevat spoelen en spoelen hebben de neiging om de stroom constant te houden. Als er dus een stroom van Vdd naar nul loopt (als het PWM signaal hoog is), en de MOSFET gaat blokkeren op het moment dat PWM laag wordt, zorgen de spoelen in de motor ervoor dat er toch nog even een stroom blijft lopen. Het gevolg is dat er op de Drain een spanning kan ontstaan die zo hoog kan zijn dat hij schadelijk is voor de Arduino en/of de MOSFET. Deze spanning wordt ook wel aangeduidt als de ''back EMF''. De diode is hiervoor bedoeld: het kortsluiten en dus onschadelijk maken van de ''back-EMF''. Als je in plaats van een motor een lamp wilt aansturen, kun je deze diode weglaten. Lampen geven namelijk geen back-EMF. Overigens hebben veel MOSFET's ook een ingebouwde diode (omgekeerd: van Source naar Drain) die ze beschermd tegen dit soort spanningen.

Het bovenstaande schema zal zeker wel werken, maar het is altijd beter om een weerstand op te nemen in de lijn met het PWM signaal. Dit is ook om de Arduino te beschermen. Een weerstand van 10kΩ is meestal een goede waarde. Daarnaast kan de output van de Arduino naar nul worden getrokken met een weerstand zodat het signaal sneller naar nul kan gaan. Beide extra weerstanden zijn opties en worden ook vaak weggelaten.

===Draairichting omkeren===

De schakeling uit de vorige paragraaf voldoet als je de motor alleen aan en uit wilt zetten, of alleen de motorsnelheid wilt besturen. In veel gevallen wil je echter ook dat de motor achteruit kan draaien. Voor het veranderen van de draairichting moet je de motor in een brug-schakeling opnemen. Deze is eerder besrpoken bij het [[Arduino_-_De_stappenmotor#Werking|stappenmotor-project]].

{|class="wikitable"
|-
|[[File:Brugschakeling.png]]
|-
|Motorspoel in brugschakeling
|}

Onthoud altijd goed dat je bij een brug-schakeling nooit de twee boven elkaar staande schakelaars sluit, want dan krijg je kortsluiting en gaan er dingen kapot. Natuurlijk gebruiken we ook hier MOSFETs in plaats van schakelaars. De MOSFET die we hierboven hebben gebruikt is een zogenaamde '''N-channel MOSFET'''. Dit type schakelt op basis van een positief spanningsverschil tussen Gate en Source. De Source is verbonden met aarde (nul) en de Gate met het input signaal. Als de Gate dan 5 Volt krijgt is de MOSFET open en anders zit hij dicht. De essentie is nu: de Gate voert 5 Volt meer dan op de Source. Omdat de Source aan de nul hangt is dat normaal een onbeduidend detail. Maar als je nu nog eens goed naar de burgschakeling kijkt, dan zie je dat het hier wat anders ligt. De bovenste MOSFET's hangen met de ene kant aan de plus, terwijlde spanning op de andere kant (voorheen de Source) ervan afhangt of de MOSFET blokkeert of doorlaat. Als hij doorlaat wordt die spanning ook hoog, blokkeert hij, dan wordt die spanning laag. Stel nu dat we hier ook een N-channel MOSFET zouden gebruiken. Dan moet de Gate, om hem volledig op doorlaten te zetten, een hogere spanning krijgen dan de Source (bijvoorbeeld 5 Volt hoger, de exacte spanning hangt af van het precieze type MOSFET). Maar zodra hij stroom gaat doorlaten, neemt de spanning op de Source toe en komt die zo'n beetje aan de plus te hangen. Dan zou hij dus weer meteen sluiten. Dat gaat dus niet goed. Daarbij wil je soms dat de motor op een veel hogere spanning draait dan de 5 Volt van je Arduino. Dat lukt natuurlijk nooit met alleen je Arduino.

Gelukkig is er nog en ander type MOSFET: de zogenaamde '''P-channel MOSFET'''. Deze wordt iets anders getekend (het pijltje van de Gate loopt andersom) en het schakelgedrag is net andersom en ook iets lastiger te begrijpen. Daarbij wordt hier de Source aan de plus gehangen terwijl de Drain naar de motor loopt. De spanning op de Source zit dus hoger dan die op de Drain. Zo werkt ook het schakelgedrag: de MOSFET opent als de Gate een spanning voert die (bijvoorbeeld 5 Volt) '''lager''' is dan de Source en hij sluit als de Gate een spanning krijgt die gelijk is aan die van de Source (of daar voldoende dichtbij komt).

Hieronder laten we nu het principe zien van de brugschakeling met vier MOSFET's voor de schakelaars. De dikke lijnen geven aan waar veel stroom kan lopen. De dunne lijnen zijn voor zwakke stuursignalen. De bovenste twee MOSFET's zijn van het P-type en de onderste twee van het N-type. De schakeling heeft twee PWM signalen nodig; beide richtingen worden afzonderlijk aangestuurd. Daar komt bij dat je ervoor moet zorgen dat als je '''PWM A''' wilt gebruiken (de ene draairichting) '''ON A''' hoog is (en '''ON B''' laag) en als je PWM B wilt gebruiken (de andere draairichting) '''ON B''' hoog moet zijn en ('''ON A''' laag). Als zowel '''ON A''' als '''ON B''' laag zijn draait de motor sowieso niet omdat dan beide P-channel MOSFET's zullen blokkeren. Ze beide hoog maken is een slecht idee omdat er dan kortsluiting ontstaat zodra een van de PWM ingangen even hoog wordt. De motor zal dan ook niet lopen, maar in plaats daarvan gaan je FET's eraan.

{|class="wikitable"
|-
|[[File:MOSFET_brugschakeling_simple.png]]
|-
|Brugschakeling met P-channel en N-channel MOSFET's
|}

Naast de vier MOSFET's gebruikt bovenstaande schakeling nog twee andere (gewone) NPN transistors. Deze worden hier alsvolgt gebruikt. Een spanning op '''ON A''' komt via de weerstand bij de basis (b) van de transistor terecht. Als die spanning voert, laat de NPN transistor stroom door van c (collector) naar e (emitter). Het gevolg is dat de gate van de P-channel MOSFET via de weerstanden voldoende laag gemaakt wordt om de P-channel MOSFET in geleiding te brengen. Als de spanning op '''ON A''' wegvalt, wordt de Gate gelijk aan de voedingsspanning en dus aan de spanning op de Source, waardoor de MOSFET gaat blokkeren. Hetzelfde geldt voor '''ON B'''. De bovenste MOSFET's staan dus continu aan of uit, terwijl het PWM signaal alleen op de onderste MOSFET's wordt gebruikt. Dit is des te meer een prima idee omdat de N-channel MOSFET's in het algemeen wat sneller schakelen dan de P-channel MOSFET's.

[[MOSFET's en de brugschakeling in meer detail|Hier]] zijn overigens meer details te vinden voor als je zelf een MOSFET brugschakeling zou willen ontwerpen. Er is ook een goed werkend voorbeeld tot wel 20 Ampere bij 30 Volt.

Al met al heb je nu een aardig idee hoe het werkt, maar echt gemakkelijk is het natuurlijk niet; het is een heel klusje om alle benodigde onderdelen goed aan te sluiten. Gelukkig zijn er voldoende alternatieven. Zo zijn er voor relatief weinig geld kant-en-klare driver boards te koop. Meestal gaat het dan om bordjes die gemaakt zijn voor het aansturen van bipolaire stappenmotoren, maar die zijn ook heel bruikbaar voor gewone gelijkstroommotoren. Voor de werking daarvan moet namelijk ook de stroomrichting worden omgekeerd zodat die ook gebasseerd zijn op de H-brug schakeling. Dergelijke bordjes zijn vaak gebasseerd op een chip met twee of soms zelfs vier ingebouwde H-brug schakelingen aan boord. Iets minder krachtig dan met losse MOSFET's maar veel gemakkelijke in gebruik. Een veelgebruikt voorbeeld is de L298N chip, inderdaad bedoeld voor bipolaire stappenmotoren. Een dergelijk bordje gaat tot zo'n 35 Volt en 2 Ampere, terwijl de logica op 5 Volt mag draaien (max 7 Volt). Prima geschikt dus voor onze Arduino. Voor deze specs moet het bordje wel uitgevoerd worden met een geschikte koeler, maar gekochte bordjes hebben vrijwel altijd een koeler. Omdat deze modules geschikt zijn voor bipolaire stappenmoteren, zijn ze gemaakt voor 2 sets van spoelen en hebben ze twee volledige H-brug schakelingen aan boord. In ondertsaand project sturen we maar een DC motor aan, maar je kunt dus ook twee motoren tegelijk mee aansturen. Of één zwaardere motor, door de beide H-bruggen parallel te gebruiken. Dan gaat hij tot 4 Ampere.

===De schakeling===

Extra benodigdheden:
*1 L298N MOSFET driver module
*1 DC motor (bijv. 12 Volt)
*1 Bijpassende batterij (dan ook 12 Volt)

{|class="wikitable"
|-
|[[File:naam bestand.png]]
|-
|Beschrijving bovenstaande figuur
|}

===Het programma===

<pre>
int motor=10;
int wait=10;

void setup()
{
pinMode(motor,OUTPUT);
}

void loop()
{
for (int i=0; i<256; i++) {
analogWrite(motor,i);
delay(wait);
}
for (int i=254; i>=0; i--) {
analogWrite(motor,i);
delay(wait);
}
}
</pre>

===Uitleg===
Het programma is uiterst simpel. De loop heeft twee delen waarin de motor eerst steeds meer vermogen krijgt en daarna steeds minder. Als het programma draait zul je zien dat de motor steeds sneller gaat draaien en dan weer afremt om meteen daarna weer te versnellen. En zo voort. Uiteraard kun je de motorsnelheid programmatisch aan bepaalde inputs koppelen en de snelheid regelen met bijvoorbeeld een potmeter. In dit project willen we alleen laten zien hoe je een zwaardere motor aan kunt sturen met een Arduino.

===Beetje spelen===
Leuk om zo'n motor aan te sturen, maar wat nu als de motor ook achteruit moet kunnen draaien?

===Navigatie===
*[[Arduino - GPS ontvanger|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - Micro-SDkaart|Volgende project]]

Arduino - 4-digit LED Segment Display

2020-12-07T11:31:13Z

WikiAdmin: /* Uitleg */

===4-Digit Segment Display===
In het [[Arduino - 1-digit LED Segment Display|vorige project]] hebben we het 1-digit segment display behandeld. Dit display heeft 9 pootjes die aangesloten moeten worden op de Arduino. Als we nu 4 digits zouden willen aansluiten, zien we meteen dat de Arduino daar gewoonweg niet genoeg aanlsuitingen voor heeft; we zouden dan minstens 33 aansluitingen moeten hebben (de common cathode/annode kan worden gecombineerd). Om nu toch met een beperkt aantal pootjes uit te kunnen heeft men een truuk bedacht waarmee de digits snel achter elkaar aangezet kunnen worden. Het 4-digit segment display heeft, net als het 1-digit segment display, een aansluiting voor elk van de LED's a, b, c, d, e, f, g en dp (digital point). Daarnaast is de common cathode (of annode - we gaan nu uit van een common cathode) vervangen door vier aansluitingen: een voor elke digit!
Laten we uitgaan van een common cathode. Elke LED heeft twee aansluitingen: de plus en de min kant. De LED brandt alleen als de plus kant hoog is en de min kant laag. In alle andere gevallen brandt de LED niet. Als de min-kant hoog is, kan de plus-kant hoog of laag zijn: de LED brandt niet. Nu heeft elke digit zijn eigen common cathode. Als die common cathode hoog is, is de hele digit uit, ongeacht de situaties van a, b, c, d, e, f, g, en dp. Als de common cathode laag is, branden de LED's van die digit volgens het patroon dat op a, b, c, d, e, f, g, en dp staat. Wat we moeten doen is dus om beurten digits selecteren met het bijbehorende patroon. Natuurlijk is elke digit dan maar een kwart van de tijd aan terwijl de Arduino driekwart van de tijd met de andere digits bezig is, maar dit kan zo snel worden afgewisseld dat de gebruiker er niets van merkt.

{|class="wikitable"
|-
|[[File:4_digit_segment_display.png|500px]]
|-
|Het 4 segment display met pin aansluitingen
|}

Net als bij het 1-digit display, heeft elke digit weer 8 LED's: drie horizontale streepjes, twee vertikale streepjes boven, twee vertikale streepjes onder en de punt. De digits zelf hebben nu echter ook een aanlsuiting. Een digit gaat aan als de betreffende aansluiting nul wordt. Een LEDje van de zo geselecteerde digit gaat aan als de betreffende pin hoog wordt.

===De schakeling===
Extra benodigdheden:
*1 4-digit segment display met common cathode (= gemeenschappelijke min)
*8 weerstanden van 180Ω-220Ω

{|class="wikitable"
|-
|[[File:4_digit_segment_display_-_circuit.png]]
|-
|Schakeling voor 4 digit segment display
|}

Let op, want het zijn een heleboel draadjes die allemaal correct verbonden moeten worden. Het kan een goed idee zijn om steeds twee kleuren om en om te gebruiken: dus bijvoorbeeld blauw af te wisselen met groen. Dan worden de connecties iets minder snel verwisseld.

Een ander belangrijk ding om op te merken is dat de schakeling de pins 0 en 1 van de Arduino niet gebruikt. Op zich zijn deze pins prima bruikbaar, maar op de printplaat van de Arduino gebruikt de seriele communicatie dezelfde pins. Je kunt deze pins dus niet samen met de seriele communicatie gebruiken. Als je het wel probeert zul je merken dat je schakeling vreemde resultaten oplevert.

===Het programma===
Het volgende programma bevat een paar nieuwe elementen. Upload het eerst maar naar je Arduino. Het wordt hieronder in detail besproken.

<pre>
byte digits[4]; // lijst met pin-nummers van de 4 digit-common annodes
byte LEDs[8]; // lijst met alle LED-pins a,b,c,d,e,f,g, en de punt
byte patronen[10]; // lijst met bit patronen voor alle cijfers, de punt, en de '-'
byte point=B00000001; // de punt
byte minus=B00000010; // de "-"

void setup()
{
// vul de tabel met aan/uit patronen voor elk van de cijfers
// "B" is de "binary formatter": B10000010 => alleen het eerste en een-na-laatste bit staan aan
// het eerste bit is voor de "a" LED, het tweede voor de "b" LED, enz. Het laatste is voor de punt
// pattern = Babcdefgp;
patronen[ 0]=B11111100;
patronen[ 1]=B01100000;
patronen[ 2]=B11011010;
patronen[ 3]=B11110010;
patronen[ 4]=B01100110;
patronen[ 5]=B10110110;
patronen[ 6]=B10111110;
patronen[ 7]=B11100000;
patronen[ 8]=B11111110;
patronen[ 9]=B11110110;
// specify pins for the common anodes (-)
digits[0] = 5;
digits[1] = 4;
digits[2] = 3;
digits[3] = 2;
// specify pins for LED cathodes (+)
LEDs[0] = 13;
LEDs[1] = 12;
LEDs[2] = 11;
LEDs[3] = 10;
LEDs[4] = 9;
LEDs[5] = 8;
LEDs[6] = 7;
LEDs[7] = 6;
// set all used pins in output mode
for (byte i=0; i<4; i++)
pinMode(digits[i], OUTPUT);
for (byte i=0; i<8; i++)
pinMode(LEDs[i], OUTPUT);
/*
// cool test patroon - met tijdmeting
unsigned long tijd=millis();
for (unsigned long i=0; i<20; i++)
{
byte patroon = B10000000;
for (byte j=0; j<6; j++)
doDisplay(patroon >> j,patroon >> j,patroon >> j,patroon >> j,50,255);
}
tijd = millis() - tijd;
Serial.begin(9600);
delay(10);
Serial.print("20 rondes kostte: ");
Serial.print(0.001*tijd);
Serial.println(" seconden");
*/

/*
// make a light go round
doDisplay(B10000000,B00000000,B00000000,B00000000,50);
doDisplay(B00000000,B10000000,B00000000,B00000000,50);
doDisplay(B00000000,B00000000,B10000000,B00000000,50);
doDisplay(B00000000,B00000000,B00000000,B10000000,50);
doDisplay(B00000000,B00000000,B00000000,B01000000,50);
doDisplay(B00000000,B00000000,B00000000,B00100000,50);
doDisplay(B00000000,B00000000,B00000000,B00010000,50);
doDisplay(B00000000,B00000000,B00010000,B00000000,50);
doDisplay(B00000000,B00010000,B00000000,B00000000,50);
doDisplay(B00010000,B00000000,B00000000,B00000000,50);
doDisplay(B00001000,B00000000,B00000000,B00000000,50);
doDisplay(B00000100,B00000000,B00000000,B00000000,50);
doDisplay(B10000000,B00000000,B00000000,B00000000,50);
*/
doDisplay(B11111111,B11111111,B11111111,B11111111,500); // turn all LEDs on for some time
doDisplay(0,0,0,0,500); // turn off all LEDs for some time
}

void loop()
{
// doDisplay(patronen[0], patronen[1] | point, patronen[2], patronen[3], 500);
// de loop
for (byte i=0; i<10; i++)
doDisplay(patronen[i % 10], patronen[(i+1)%10] | point, patronen[(i+2)%10], patronen[(i+3)%10], 500);
// "patronen[i] | point" also turns on the point for the given pattern by doing a bit-wise OR
}

void selectDigit(byte d)
{
for (byte i=0; i<4; i++)
{
if (i==d)
{
digitalWrite(digits[i], LOW); // LOW allows the flow of electrical current
}
else
{
digitalWrite(digits[i], HIGH);
}
}
}

void showPattern(byte patroon) // deze functie toont het gegeven LED patroon
{
// set all LEDs individually, depending on the bits in the given pattern
for (byte i=0; i<8; i++)
{
// "&" performs a bitwise AND on the numbers
// >> shifts 10000000 a number of bits to the right (so "10000000 >> 2" makes "00100000")
digitalWrite(LEDs[i], patroon & (B10000000>>i) );
}
}

void doDisplay(byte d0,byte d1,byte d2,byte d3,long int duration)
{ // duration in milli seconds
unsigned long start=millis();
do
{
// display all 4 patterns in quick succession
selectDigit(0);
showPattern(d0);
delay(1);
selectDigit(1);
showPattern(d1);
delay(1);
selectDigit(2);
showPattern(d2);
delay(1);
selectDigit(3);
showPattern(d3);
delay(1);
}
while (millis()-start<duration);
}
</pre>

===Uitleg===
Het programma lijkt erg op dat van het [[Arduino - 1-digit LED Segment Display|vorige project]]. We hebben weer de twee lijsten voor de 8 pin-connecties van de plus-uiteindes van de LED's ('''byte LEDs[8];''') en die voor de patronen van de 10 cijfers '''byte patronen[10];'''. Nieuw is dat we hier ook een lijst maken van de pin-connecties van de common nul-zijden van de LED's, elk voor een van de vier digits. Deze lijst heet dan ook digits[4]. Een digit staat sowieso helemaal uit als zijn common nul HIGH is. Vervolgens definieren we een paar vaste patronen, een voor de punt, een voor het minus teken, een waarbij alle LED's van een digit aan staat en een waarvoor alles uit staat.

In de setup() worden de lijsten weer van waarden voorzien en worden zowel de LEDs[] als de digits[] pins op OUTPUT ingesteld. Ook nu gaat dat weer handig met een for-loop. Dan staan er een paar delen uit (commentaar gemaakt). Hier worden bepaalde patronen op de digits gezet waarmee je kunt testen of alles goed werkt. Ach, het is vooral cool.

Ook hier is de loop() functie relatief eenvoudig. Hij heeft een for-loop waarin de functie doDisplay() wordt aangeroepen met een bepaalde set patronen en een tijdsduur. Deze functie doDisplay() laat het eerste patroon zien op de eerste digit, het tweede op de tweede digit, het derde op de derde digit en het vierde op de vierde digit. Dit wordt in een for-loop herhaald tot de gewenste display tijd om is. De patronen die de for-loop aan doDisplay() worden meegegeven zijn natuurlijk cijfers uit de lijst patronen[]. De index van de lijst wordt voor elke digit berekend met formules. Hier volgt wat uitleg:
<pre>
[i % 10] // Dit is gewoon i, maar als i groter wordt dan 10 wordt er 10 afgetrokken.
[(i+1) % 10] // Dit is i+1, maar als i+1 groter wordt dan 10 wordt er 10 afgetrokken.
[(i+2) % 10] // Dit is i+2, maar als i+2 groter wordt dan 10 wordt er 10 afgetrokken.
[(i+3) % 10] // Dit is i+3, maar als i+3 groter wordt dan 10 wordt er 10 afgetrokken.
</pre>
Het teken ''%10'' betekent ''modulus''; n%10 is n waarvan zoveel keer 10 is afgetrokken als maar kan (zonder dat de uitkomst negatief wordt). Als i=0 gebruikt de loop dus patronen[0], patronen[1], patronen[2] en patronen[3]. Als i=1 gebruikt de loop patronen[1], patronen[2], patronen[3] en patronen[4]. En als i=9 gaat de modulus zijn werk doen en gebruikt de loop patronen[9], patronen[0], patronen[1] en patronen[2].

Dit programma heeft twee nieuwe functies ten opzichte van het vorige. De eerste hebben we al genoemd doDisplay(). De andere is selectDigit() en wordt gebruikt om een patroon op de juiste digit te tonen. De functie selectDigit() heeft als parameter het nummer van de digit dat moet worden geselecteerd; selectDigit(1) zorgt dat de pin die hoort bij digit 1 LOW wordt. De pins van de andere digits worden HIGH zodat geen enkele LED daarvan aan kan gaan. Bedenk dat het hier gaat om de common nul kanten van de LEDs van elk van de digits. De functie doDisplay() krijgt de vier patronen mee als parameters en toont achter elkaar elk van deze patronen op hun respectievelijke digit. Daarvoor wordt selectDigit() aangeroepen en vervolgens showPattern() met het overeenkomstige patroon. Daarna volgt een delay() om ervoor te zorgen dat het patroon ook echt even zichtbaar wordt. Dit moet zich herhalen tot de gewenste displaytijd om is. Daarom zit dit alles ingepakt in een ''do while'' loop en begint de fuinctie met het vastleggen van de startijd.

Je ziet dat de processor behoorlijk bezig is om dit display goed te laten werken. Er is nauwelijks tijd tussendoor voor metingen, berekeningen of andere belangrijke dingen. Ach, steeds een paar micro-seconden kan er nog wel af, maar als er millisecondes tussen komen ga je dat al snel zien. Ook legt het display een flink beslag op de beschikbare pins. Over beschikbare pins gesproken. Het is je misschien opgevallen dat pins 0 en 1 niet gebruikt zijn. Dat is niet voor niets. Deze pins worden impliciet gebruikt voor de seriele communicatie. Ze zijn prima bruikbaar als elke andere digitale pin, maar als je dat gaat doen kun je geen gebruik meer maken van de seriele communicatie met de PC. Of, als je dat wel doet, doen de pins wat anders dan wat het programma opgeeft.

===Beetje spelen===
We hebben al aardig wat uit de kast gehaald om deze display goed aan het werk te krijgen in een overzichtelijk programmaatje (je zou eens op Internet moeten neuzen om te zien wat voor onhandelbare programma's anderen aanbieden ter demonstratie van dit display). Als ik dit display op mijn slaapkamer zou gebruiken als klok kom ik er achter dat het display 's nachts wel erg helder is. Terwijl het overdag best helder mag zijn heb ik het 's nachts liever wat gedimd. Zouden we zo'n dim-feature ook kunnen toevoegen? Dan kunnen we ook een lichtsensor laten bepalen hoe helder de display moet zijn om hem goed te kunnen zien.

Denk er even over na hoe je dat zou doen. Ik stel me voor dat dit wat lastig is, dat vond ik ook, maar uiteindelijk heb ik wel een [[4-digit LED Segment Display - gedimd|oplossing]] bedacht. Als je het leuk vind kun je ff kijken.

===Navigatie===
*[[Arduino - 1-digit LED Segment Display|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - Temperatuur meten met een DS18B20 sensor|Volgende project]]

Arduino - 1-digit LED Segment Display

2020-12-07T11:20:34Z

WikiAdmin: /* Beetje spelen */

===Een Segment Display===
Een segment display bevat een aantal langwerpige elementen, meestal LED's, die voornamelijk bedoeld zijn om cijfers weer te geven, maarin principe kunnen er ook eenvoudige letters mee worden gemaakt.

{|class="wikitable"
|-
|[[File:105px-Seven_segment_display-animated.gif|155px]]
|-
|Cijfers en primitieve letters in een segment display
|}

Het display uit bovenstaand voorbeeld heeft 8 LED's: drie horizontale streepjes, twee vertikale streepjes boven, twee vertikale streepjes onder en de punt. Elk ''segment'' kan apart worden aan- en uitgezet. Bij de aansturing van een segment display ontstaan de cijfers (en letters) door de juiste combinatie van segmenten aan te zetten. De pootjes van zo'n display zijn verbonden met de 8 individuele LEDjes, terwijl er meestal een gemeenschappelijke plus is (common annode), of juist een gemeenschappelijke min (common cathode). Hoewel ze in principe gelijkwaardig zijn, werkt een common cathode iets gemakkelijker omdat de LEDjes daarvan aangaan als de plus-kant van dat LEDje hoog wordt. Bij een common annode is het plus signaal altijd aanwezig en gaat een LEDje juist aan als de andere kant laag wordt. Voor veel mensen is dat net iets minder logisch. Een 8 segment display, zoals boven, heeft dus 8 connecties voor elke LED plus een common annode (plus) of cathode (min).

{|class="wikitable"
|-
|[[File:SegmentDisplay_CC_PinConfig.png|350px]]
|-
|Common Cathode Segment Display - pin cofiguratie
|}

De letters geven aan om welke LED het gaat. Zet je bijvoorbeeld a,b,c,d en g aan, dan krijg je het cijfer 3. De punt is verbonden met pootje 5. Net als bij andere LED's moet de stroom door de LED's van een segment display worden beperkt met een weerstand. Je moet dan voor elke LED een eigen weerstand gebruiken omdat de LED-jes anders elkaar beinvloeden. Zie je overigens dat zowel pootje 3 als 8 aan de common cathode zitten? Het volstaat dus om een van de twee pootjes met de nul te verbinden.

===De schakeling===
Extra benodigdheden:
*1 1-digit segment display met common cathode (= gemeenschappelijke min)
*8 weerstanden van 180Ω-220Ω

{|class="wikitable"
|-
|[[File:1DigitSegmentDisplay.png]]
|-
|Schakeling voor 1 digit segment display
|}

===Het programma===
Het volgende programma bevat een paar nieuwe elementen. Upload het eerst maar naar je Arduino. Het wordt hieronder in detail besproken.

<pre>
byte LEDs[8]; // lijst met alle LED-pins a,b,c,d,e,f,g, en de punt
byte patronen[10]; // lijst met bit patronen voor alle cijfers, de punt, en de '-'
byte point=B00000001; // de punt
byte minus=B00000010; // de "-"
int wachttijd = 100; // tijdsduur van elk cijfer

void setup()
{
// maak een lijstje van de LED pins in volgorde van hun functie (functies 'a', 'b', etc)
LEDs[0]=7; // a - zit aan pin 7 van de Arduino
LEDs[1]=6; // b - zit aan pin 6 van de Arduino
LEDs[2]=5; // c - etc.
LEDs[3]=10; // d
LEDs[4]=11; // e
LEDs[5]=8; // f
LEDs[6]=9; // g
LEDs[7]=4; // punt
// vul de tabel met aan/uit patronen voor elk van de cijfers
// "B" is de "binary formatter": B10000010 => alleen het eerste en een-na-laatste bit staan aan
// het eerste bit is voor de "a" LED, het tweede voor de "b" LED, enz. Het laatste is voor de punt
// pattern = Babcdefgp;
patronen[ 0]=B11111100;
patronen[ 1]=B01100000;
patronen[ 2]=B11011010;
patronen[ 3]=B11110010;
patronen[ 4]=B01100110;
patronen[ 5]=B10110110;
patronen[ 6]=B10111110;
patronen[ 7]=B11100000;
patronen[ 8]=B11111110;
patronen[ 9]=B11110110;
// zet alle LED-pins op output mode
for (int i=0; i<8; i++)
pinMode(LEDs[i],OUTPUT);
// test patroon
for (int i=0; i<4; i++)
{
byte patroon = B10000000;
for (byte j=0; j<6; j++)
{
showPattern(patroon >> j); // schuif patroon j plekken naar rechts
delay(50);
}
}
showPattern(B11111111);
delay(1000);
}

void showPattern(byte patroon) // deze functie toont het gegeven LED patroon
{
byte first = B10000000; // the first bit that refers to LED "a"
for (byte i=0; i<8; i++)
// ">>" shifts B10000000 a number of bits to the right (so "B10000000 >> 2" makes "B00100000")
// "&" performs a bitwise AND on the numbers
digitalWrite(LEDs[i], patroon & (first>>i) );
}

void loop()
{
for (int i=9; i>=0; i--)
{
showPattern(patronen[i]);
delay(wachttijd);
}
}
</pre>

===Uitleg===
Het eerste statement begint al met iets nieuws: '''byte LEDs[8];''' maakt ''LEDs'' geen gewone variabele van het type byte, maar een '''lijst''' van 8 bytes. LEDs[0] is dan de eerste byte uit die lijst, LEDs[1] de tweede, en zo voort, zodat de laatste LEDs[7] is. Met een enkel statement kunnen we dus een hoop variabelen definieren. Daarbij zijn die variabelen via een loop om beurten te benaderen. Daar komen we later op terug. Het tweede statement is nu beter te begrijpen: het definieert tien bytes in een statement '''byte patronen[10];'''.
Regel drie lijkt een gewone byte te definieren met de naam '''point'''. Maar de waarde van die byte is doet vreemd aan: '''B00000001'''. Met die '''B''' wordt bedoeld dat de waarde '''binair''' wordt opgegeven. We zijn gewend om waarden decimaal op te geven, 12, 349, en zo voort. Omdat het hier om een byte gaat, bestaat elke waarde in de processor uit 8 eentjes en nulletjes, en dat is nu precies wat we met Bxxxxxxxx doen: elk eentje en nulletje wordt opgegeven. Voor de processor maakt het niet uit of je '''12''' opgeeft, of '''B00001100''' - van binnen is het exact hetzelfde. De punt bestaat dus uit allemaal nullen, behalve de laatste ''bit'' die 1 is.

In de setup() worden de lijsten van waarden voorzien. De lijst LEDs[] geeft precies aan welk LEDje aan welke pin van de Arduino zit. LEDs[0] is dus de pin van de LED die overeenkomt met positie ''a'' van het segment display. LEDs[1] is de pin van positie ''b'', en zo voort. In het commentaar staat ''Babcdefgp'': waarmee wordt aangegeven dat de eerste bit voor ''a'' is, de tweede voor ''b'', en zo voort. De lijst patronen[] wordt helemaal gevuld met waarden die bitsgewijs worden opgegeven. Door dat bitgewijs opgeven van de getallen kun je heel gemakkelijk opgeven welke LEDjes er aan moeten staan voor elk patroon. Zo zie je dat voor patroon[0] alle LEDjes behalve de laatste twee aan staan. Als je nu kijkt naar de pin-configuratie kun je waarschijnlijk snel zien dat het hier gaat om het cijfer ''0''. Met een beetje moeite kun je ook de andere cijfers herkennen. De lijst ''patronen[]'' geeft dus aan welke LEDjes er aan en uit moeten staan voor elk van de cijfers.

Het volgende deel van de setup() zet alle pins van de LED's op output mode. Dit gaat met een for-loop waarbij de loop-variabele ''i'' wordt gebruikt om alle LEDs langs te lopen.

Dan volgt er een stukje code waarmee alle lampjes om beurten snel achter elkaar worden aangezet. Dan volgt er een for-loop die 4 keer wordt doorlopen. Eerst wordt er een byte gedefinieerd met alleen een 1 op de positie van LED ''a''. In de for-loop die volgt worden patronen op de pins van de Arduino gezet met de functie showPattern(). Het bijzondere is dat er geen vast patroon wordt meegegeven met deze functie, maar een patroon dat wisselt met j. de parameter is namelijk ''patroon >> j''. Dit ''>>'' teken staat ervoor dat patroon j plaatsen naar rechts opschuift. Als we beginnen met B10000000 en we schuiven dat 3 plaatsen op (j is dan 3), dan krijgen we patroon B00010000. Dit is dan het patroon dat wordt doorgegeven aan showPattern() functie.

Tenslotte worden alle lichtjes gedurende een seconde aangezet door aanroep van de showPattern() functie met B11111111 als parameter.

De loop() functie is relatief eenvoudig. In een for loop, die van 9 naar 0 aftelt, wordt showPattern() aangeroepen met patronen[i], waarna het programma ''wachttijd'' pauzeert. Het resultaat zal dus zijn dat het display steeds opnieuw aftelt van 9 naar 0.

Blijft over om de werking van de functie showPattern() uit te leggen. Gelukkig heeft de functie maar twee statements. Het eerste statement is gemakkelijk: de byte ''first'' wordt definieerd met een patroon waarvan alleen het eerste bit aan staat. Daarna volgt een for-loop waarbij i oploopt van 0 tot en met 7 (kleiner dan 8) en waarbinnen een digitalWrite() plaatsvindt op pin LEDs[i]. Dat is dus de pin van de i-de LED van het display. Omdat het een digitalWrite() is, wordt naar die LED natuurlijk een 1 of een 0 gestuurd. Laten we eerst vaststellen dat ''(first>>i)'' een patroon is waarvan precies één bit aan staat en wel bit i+1. Als i=0 is het gewoon de byte ''first''. Als i=1 is het de byte B01000000 (tweede bit staat aan). Bij i=2 wordt het byte B00100000 (derde bit staat aan). En zo voort. Net als in de ''setup()'' wordt dit gedaan door de ''>>'' operator die de byte een aantal posities naar rechts opschuift. Deze byte wordt vervolgens gecombineerd met het patroon dat als parameter wordt meegegeven aan de functie. Die combinatie wordt gemaakt met het '&' teken dat wijst op een ''bitwise AND''. Er ontstaat dan een nieuwe byte die op elke positie alleen een 1 heeft als beide ''operanden'' op die positie een 1 hebben. Die operanden zijn dus ''patroon'' en ''(first>>i)''. Van die laatste weten we inmiddels dat precies een bit 1 is en alle anderen 0 zijn. Het resultaat van ''patroon & (first>>i)'' is dan ook een byte die alleen groter zal zijn dan 0 als de i-de bit van patroon ook een 1 is. Als het resultaat ongelijk is aan 0 geldt dat als digitale 1. LEDs[i] zal daardoor aan worden gezet als de overeenkomstige bit in ''patroon'' 1 is en anders wordt de LED uit gezet. Het resultaat is dus dat de LEDs worden aan- en uitgezet volgens het opgegeven patroon. En dat heel compact en efficient geprogrammeerd.

===Beetje spelen===
Als je hier wat wilt spelen kun je de teller omkeren: in plaats van aftellen gaat hij dan van 0 naar 9. Leuker is het wellicht om hem te laten aftellen en bij 0 aangekomen alle lampjes een paar keer snel aan en uit te laten gaan.

Zoals uitgelegd zijn de cijfers als patronen gedefinieerd. Maar je kunt op dezelfde manier ook andere patronen maken, zoals de letters van het alfabet. Onderstaand zie je een voorbeeld van hoe je cijfers en de meeste letters zou kunnen maken met dit display (met soms een kleine in plaats van een hoofdletter). Met al deze patronen kun je het programma ook woorden laten spellen. Eventueel kun je de nog ontbrekende letters ook toevoegen, maar dan wordt de X al snel hetzelfde als de H (tenzij je een kleine letter h gebruikt) en de V hetzelfde als de U. Tja, voor het alfabet blijft het met dit display een beetje behelpen.

{|class="wikitable"
|-
|[[File:letter_display.jpg|500px]]
|-
|Cijfers en letters in het segment display
|}

===Navigatie===
*[[Arduino - Allerlei sensoren|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - 4-digit LED Segment Display|Volgende project]]

2020-12-05T13:49:41Z

WikiAdmin: verbeterde en gecontroleerde versie

verbeterde en gecontroleerde versie

File:LCD 1602 v2.png

WikiAdmin:

Arduino - Motor met Power

2018-02-24T11:35:17Z

WikiAdmin: /* Draairichting omkeren */

Een Arduino is prima om een paar LEDjes aan te sturen en eventueel een klein servo-motortje. Maar als je wat meer wilt, zoals veel LEDjes aansturen, of een behoorlijke elektrische motor, volstaat een Arduino niet meer. Toch kun je kunt zo'n motor wel aansluiten met een Arduino, en dan bijvoorbeeld de PWM mogelijkheden ervan gebruiken, maar dan kan het vermogen niet van de Arduino zelf komen; alleen het stuursignaal. Dit kan heel goed met een MOSFET driver. Zo'n MOSFET werkt als een heel snelle, elektronisch aanstuurbare schakelaar, die gemakkelijk mee kan doen met het signaal van de PWM. Daar komt als voordeel bij dat je een andere spanningsbron kunt gebruiken voor de motor. De motor kan bijvoorbeeld op een dikke acuu van 24 Volt werken, terwijl de Arduino het doet met een batterijtje van 5 Volt.

===MOSFET driver===

Bij de [[Arduino - De stappenmotor|stappenmotor]] hebben we die drivers al voorbij zien komen, maar er niet veel aandacht aan besteed. Nu gaan we iets dieper in op dergelijke drivers. Zoals gezegd werkt een MOSFET als een elektronisch bestuurbare schakelaar. Preciezer: het werkt als een spanninggestuurde schakelaar. Het gaat dan om de spanning aan de '''Gate''' ten opzichte van die aan de '''Source''' terwijl de '''Gate''' een vrijwel geen stroom opneemt. Nog preciezer: de MOSFET blokkeert de stroom als de spanning tussen Gate en Source onder een drempelwaarde ligt en laat maximaal door . Bij gate-spanningen daartussen is de stroom door de MOSFET ongeveer evenredig met de spanning. Dit is nu echter ongunstig omdat de MOSFET dan (veel) vermogen opneemt en heet kan worden. We gebruiklen hem dus alleen in volledig geblokkeerde toestand en volledig verzadigde toestand.

{|class="wikitable"
|-
|[[File:MOSFET_aansturing.png]]
|-
|Arduino stuurt motor aan via (N-channel) MOSFET
|}

De '''Gate''' van de MOSFET krijgt het PWM signaal van de Arduino. Als het PWM signaal laag is, blokkeert de MOSET en kan er geen stroom door de motor lopen, maar als het signaal hoog is, wordt de weerstand van de MOSFET tussen '''Drain''' en '''Source''' (bijna) nul en krijgt de motor de volle lading van de Vdd. Daarbij kan een MOSFET heel snel schakelen en verbruikt die zelf dus maar heel weinig vermogen. Vdd is de voedingsspanning waar de motor op loopt. Deze mag gekoppeld zijn aan de +5 Volt die ook de Arduino voedt, maar dat hoeft niet en mag ook uit een andere bron komen (zoals in bovenstaand schema). Je kunt dan motoren gebruiken die op een heel andere spanning draaien dan de Arduino. Het is wel belangrijk dat de nul van de voeding van de Arduino gekoppeld wordt aan de nul van de motorvoeding.

De dikke lijnen door de motor en MOSFET geven aan dat hier veel stroom mag lopen. De maximale stroom door de MOSFET hangt af van het type dat wordt gekozen en ook of die wel of niet gekoeld wordt. Er zijn MOSFET's die wel 100 ampere kunnen schakelen!

Dan zien we nog een klein detail: de diode over de motor. Een diode is een elementje waar de stroom maar in één richting doorheen kan. Zoals je ziet zit de diode ''verkeerd om'', waardoor er geen stroom doorheen kan lopen. Het lijkt er daarom voor niets in te zitten. Dat is echter niet helemaal waar. De motor bevat spoelen en spoelen hebben de neiging om de stroom constant te houden. Als er dus een stroom van Vdd naar nul loopt (als het PWM signaal hoog is), en de MOSFET gaat blokkeren op het moment dat PWM laag wordt, zorgen de spoelen in de motor ervoor dat er toch nog even een stroom blijft lopen. Het gevolg is dat er op de Drain een spanning kan ontstaan die zo hoog kan zijn dat hij schadelijk is voor de Arduino en/of de MOSFET. Deze spanning wordt ook wel aangeduidt als de ''back EMF''. De diode is hiervoor bedoeld: het kortsluiten en dus onschadelijk maken van de ''back-EMF''. Als je in plaats van een motor een lamp wilt aansturen, kun je deze diode weglaten. Lampen geven namelijk geen back-EMF. Overigens hebben veel MOSFET's ook een ingebouwde diode (omgekeerd: van Source naar Drain) die ze beschermd tegen dit soort spanningen.

Het bovenstaande schema zal zeker wel werken, maar het is altijd beter om een weerstand op te nemen in de lijn met het PWM signaal. Dit is ook om de Arduino te beschermen. Een weerstand van 10kΩ is meestal een goede waarde. Daarnaast kan de output van de Arduino naar nul worden getrokken met een weerstand zodat het signaal sneller naar nul kan gaan. Beide extra weerstanden zijn opties en worden in de meeste schakelingen weggelaten.

===Draairichting omkeren===

De schakeling uit de vorige paragraaf voldoet als je de motor alleen aan en uit wilt zetten, of alleen de motorsnelheid wilt besturen. In veel gevallen wil je echter ook dat de motor achteruit kan draaien. Voor het veranderen van de draairichting moet je de motor in een brug-schakeling opnemen. Deze is eerder besrpoken bij het [[Arduino_-_De_stappenmotor#Werking|stappenmotor-project]].

{|class="wikitable"
|-
|[[File:Brugschakeling.png]]
|-
|Motorspoel in brugschakeling
|}

Onthoud altijd goed dat je bij een brug-schakeling nooit de twee boven elkaar staande schakelaars sluit, want dan krijg je kortsluiting en gaan er dingen kapot. Natuurlijk gebruiken we ook hier MOSFETs in plaats van schakelaars. De MOSFET die we hierboven hebben gebruikt is een zogenaamde '''N-channel MOSFET'''. Dit type schakelt op basis van een positief spanningsverschil tussen Gate en Source. De Source is verbonden met aarde (nul) en de Gate met het input signaal. Als de Gate dan 5 Volt krijgt is de MOSFET open en anders zit hij dicht. De essentie is nu: de Gate voert 5 Volt meer dan op de Source. Omdat de Source aan de nul hangt is dat normaal een onbeduidend detail. Maar als je nu nog eens goed naar de burgschakeling kijkt, dan zie je dat het hier wat anders ligt. De bovenste MOSFET's hangen met de ene kant aan de plus, terwijlde spanning op de andere kant (voorheen de Source) ervan afhangt of de MOSFET blokkeert of doorlaat. Als hij doorlaat wordt die spanning ook hoog, blokkeert hij, dan wordt die spanning laag. Stel nu dat we hier ook een N-channel MOSFET zouden gebruiken. Dan moet de Gate, om hem volledig op doorlaten te zetten, een hogere spanning krijgen dan de Source (bijvoorbeeld 5 Volt hoger, de exacte spanning hangt af van het precieze type MOSFET). Maar zodra hij stroom gaat doorlaten, neemt de spanning op de Source toe en komt die zo'n beetje aan de plus te hangen. Dan zou hij dus weer meteen sluiten. Dat gaat dus niet goed. Daarbij wil je soms dat de motor op een veel hogere spanning draait dan de 5 Volt van je Arduino. Dat lukt natuurlijk nooit met alleen je Arduino.

Gelukkig is er nog en ander type MOSFET: de zogenaamde '''P-channel MOSFET'''. Deze wordt iets anders getekend (het pijltje van de Gate loopt andersom) en het schakelgedrag is net andersom en ook iets lastiger te begrijpen. Daarbij wordt hier de Source aan de plus gehangen terwijl de Drain naar de motor loopt. De spanning op de Source zit dus hoger dan die op de Drain. Zo werkt ook het schakelgedrag: de MOSFET opent als de Gate een spanning voert die (bijvoorbeeld 5 Volt) '''lager''' is dan de Source en hij sluit als de Gate een spanning krijgt die gelijk is aan die van de Source (of daar voldoende dichtbij komt).

Hieronder laten we nu het principe zien van de brugschakeling met vier MOSFET's voor de schakelaars. De dikke lijnen geven aan waar veel stroom kan lopen. De dunne lijnen zijn voor zwakke stuursignalen. De bovenste twee MOSFET's zijn van het P-type en de onderste twee van het N-type. De schakeling heeft twee PWM signalen nodig; beide richtingen worden afzonderlijk aangestuurd. Daar komt bij dat je ervoor moet zorgen dat als je '''PWM A''' wilt gebruiken (de ene draairichting) '''ON A''' hoog is (en '''ON B''' laag) en als je PWM B wilt gebruiken (de andere draairichting) '''ON B''' hoog moet zijn en ('''ON A''' laag). Als zowel '''ON A''' als '''ON B''' laag zijn draait de motor sowieso niet omdat dan beide P-channel MOSFET's zullen blokkeren. Ze beide hoog maken is een slecht idee omdat er dan kortsluiting ontstaat zodra een van de PWM ingangen even hoog wordt. De motor zal dan ook niet lopen, maar in plaats daarvan gaan je FET's eraan.

{|class="wikitable"
|-
|[[File:MOSFET_brugschakeling_simple.png]]
|-
|Brugschakeling met P-channel en N-channel MOSFET's
|}

Naast de vier MOSFET's gebruikt bovenstaande schakeling nog twee andere (gewone) transistors. Deze worden hier alsvolgt gebruikt. Een spanning op '''ON A''' komt via de weerstand bij de basis (b) van de transistor terecht. Als die spanning voert, laat de NPN transistor stroom door van c (collector) naar e (emitter). Het gevolg is dat de gate van de P-channel MOSFET via de weerstanden voldoende laag gemaakt wordt om de P-channel MOSFET in geleiding te brengen. Als de spanning op '''ON A''' wegvalt, wordt de Gate gelijk aan de voedingsspanning en dus aan de spanning op de Source, waardoor de MOSFET gaat blokkeren. Hetzelfde geldt voor '''ON B'''. De bovenste MOSFET's staan dus continu aan of uit, terwijl het PWM signaal alleen op de onderste MOSFET's wordt gebruikt. Dit is des te meer een prima idee omdat de N-channel MOSFET's in het algemeen wat sneller schakelen dan de P-channel MOSFET's.

===De schakeling===

Extra benodigdheden:
*1 MOSFET driver module
*1 DC motor
*1 Bijpassende batterij

{|class="wikitable"
|-
|[[File:naam bestand.png]]
|-
|Beschrijving bovenstaande figuur
|}

===Het programma===

<pre>
int motor=10;
int wait=10;

void setup()
{
pinMode(motor,OUTPUT);
}

void loop()
{
for (int i=0; i<256; i++) {
analogWrite(motor,i);
delay(wait);
}
for (int i=254; i>=0; i--) {
analogWrite(motor,i);
delay(wait);
}
}
</pre>

===Uitleg===
Het programma is uiterst simpel. De loop heeft twee delen waarin de motor eerst steeds meer vermogen krijgt en daarna steeds minder. Als het programma draait zul je zien dat de motor steeds sneller gaat draaien en dan weer afremt om meteen daarna weer te versnellen. En zo voort. Uiteraard kun je de motorsnelheid programmatisch aan bepaalde inputs koppelen en de snelheid regelen met bijvoorbeeld een potmeter. In dit project willen we alleen laten zien hoe je een zwaardere motor aan kunt sturen met een Arduino.

===Beetje spelen===
Leuk om zo'n motor aan te sturen, maar wat nu als de motor ook achteruit moet kunnen draaien?

===Navigatie===
*[[Arduino - GPS ontvanger|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - Micro-SDkaart|Volgende project]]

File:MOSFET brugschakeling simple.png

2018-02-24T11:17:16Z

WikiAdmin: WikiAdmin uploaded a new version of File:MOSFET brugschakeling simple.png

2018-02-18T19:30:12Z

WikiAdmin: /* MOSFET driver */

Arduino - Motor met Power

2018-02-18T13:08:49Z

WikiAdmin:

File:MOSFET aansturing.png

2018-02-18T12:44:41Z

WikiAdmin:

Arduino - Motor met Power

2018-02-18T10:21:50Z

WikiAdmin: Created page with "Een Arduino is prima om een paar LEDjes aan te sturen en eventueel een klein servo-motortje. Maar als je wat meer wilt, zoals veel LEDjes aansturen, of een behoorlijke elektri..."

Arduino - De stappenmotor

2018-02-18T10:15:38Z

WikiAdmin: /* Werking */

Een stappenmotor is precies wat de naam suggereert: een motor die niet gewoon toeren maakt, maar stapjes zet. Elk stapje wordt afzonderlijk aangestuurd en de motor kan ook weer stapjes terug doen. Door snel achter elkaar, met hoge frequentie, veel stapjes te zetten kan een stappenmotor toch toeren maken, maar daarin blinken ze niet uit en dat is ook niet primair de bedoeling van stappenmotoren. In plaats daarvan zijn ze heel goed in het maken van een precies aantal stappen, bijvoorbeeld om iets in een bepaalde positie te brengen. Een voorbeeld is de printkop van een printer. Ook kun je met enig prutswerk een servo vaak vervangen door een stappenmotor. Maar terwijl een servo beperkt is tot een deel van 360 graden, kunnen stappenmotoren zonder probleem vele slagen maken. Daarbij meet een servo steeds de positie, terwijl een stappenmotor niet beschikt over een positiemeting. Je moet er dus vanuit gaan dat het aantal gezette stappen klopt. Als die stappen te snel komen wordt er wel eens een telfoutje gemaakt en dan is er geen vanzelfsprekende correctie. En als de stroom uitvalt heb je helemaal geen idee meer wat de positie is van het ding dat door de stappenmotor wordt aangestuurd. Daarom hebben systemen met stappenmotoren doorgaans een ingebouwd ijkpunt. Zo kun je de motor terugdraaien totdat iets een positie-signaal afgeeft, bijvoorbeeld doordat een uitsteeksel tegen een knopje aankomt. Dat kan dan het beginpunt zijn vanaf waar je begint met tellen. Afgezien daarvan kun je er doorgaans op vertrouwen dat de aansturing zodanig is dat er geen telfouten optreden. Een stappenmotor is dan een prachtig stuk techniek waarmee posities nauwkeurig kunnen worden ingesteld zonder terugkoppeling door middel van een meting.

===Werking===
Het voert te ver voor hier om de werking van een [https://nl.wikipedia.org/wiki/Elektromotor elektromotor] uit te leggen, maar het basisprincipe is dat een elektromagneet een andere magneet (vaak een permanente magneet) afwisselend aantrekt en afstoot. Een elektromagneet bestaat uit een draad die om een kern is gewikkeld (een spoel). De richting van het magneetveld wordt bepaald door de stroomrichting en de sterkte van het veld door de stroomsterkte. Een stappenmotor is precies zo'n type elektromotor met permanente magneten en elektromagneten. Het verschil zit in de aansturing waarbij de elektromagneten zo geschakeld worden dat ze de dichtstbijzijnde permanente magneet aantrekken of juist afstoten. Met een slim uitgedachte opzet van permanente magneten en spoelen kan een stappenmotor een stapje maken door de juiste spoel in de juiste stroomrichting te bekrachtigen. Zo'n stapje komt dan overeen met een bepaalde draaihoek die afhankelijk is van de opzet van de stappenmotor.

{|class="wikitable"
|-
|[[File:VariableReluctanceStepper.png]]
|-
|Werking stappenmotor: Als spoel C stroom krijgt, draait de as punt 5 naar spoel C; Als daarna spoel D stroom krijgt, draait daarna punt 4 naar spoel D; Spoel A trekt daarna punt 3 naar spoel A. Enz. De volgorde zorgt voor de draaing (en hier ook de draairichting).
|}

In het huis van sommige stappenmotoren zit ook een tandwielhuis dat voor extra vertraging zorgt en dus voor meer kracht, maar ook voor meer stappen per rotatie (en dus meer precisie). Daarbij kunnen stappenmotoren hun positie bevriezen en een extra tandwielvertraging vergemakkelijkt deze eigenschap.

Er zijn twee soorten stappenmotoren. De bipolaire stappenmotoren hebben spoelen waar de stroom in de ene of in de andere richting doorheen gaat. Omdat de stroomrichting door die spoelen dus moet kunnen omkeren heet dit type bipolair. Het andere, minder voorkomende type, heeft voor elke stroomrichting eigen spoelen. De stroom door elk van deze spoelen loopt altijd in dezelfde richting zodat dit type wordt aangeduid als unipolaire stappenmotoren.

Bipolaire stappenmotoren hebben twee groepen spoelen, terwijl unipolaire stappenmotoren vier groepen spoelen hebben. Spoelen van een groep worden tegelijk en op dezelfde wijze aangestuurd. Bij bipiolaire stappenmotoren zijn er drie mogelijkheden: een positieve stroom, een negatieve stroom, of natuurlijk geen stroom. Voor unipolaire stappenmotoren zijn er maar twee: stroom of geen stroom - de stroomrichting wordt niet omgedraaid. Daarentegen hebben die dus twee keer zoveel spoel-groepen. Twee groepen spoelen betekent dat een bipolaire stappenmotor vier aansluitdraden heeft: twee voor elke groep spoelen. Een unipolaire stappenmotor, met vier groepen spoelen, heeft vijf aansluitdraden omdat alle spoelen aan een kant aan een gemeenschappelijke draad zitten. Als je ooit ergens een motor vindt (of uit sloopt) kun je aan het aantal aansluitdraden meestal zien wat voor soort motor het is:
* twee dragen: normale elektromotor
* vier draden: bipolaire stappenmotor
* vijf of zes draden: unipolaire stappenmotor
Door de juiste afwisseling van aansturing kan de stappenmotor stapje voor stapje zetten: de spoelen trekken het anker van de motor dwingend in een bepaalde richting. Als dit met hoge frequentie gebeurt kan de motor zelfs behoorlijk wat toeren maken. Het aansturen van unipolaire stappenmotoren komt erop neer dat de spoelen in de juiste volgorde bekrachtigd moeten worden. Dat is een betrekkelijk eenvoudig klusje voor een Arduino. Maar voor bipolaire stappenmotoren moet dus de stroom''richting'' worden omgedraaid. Dat kan een Arduino niet. Daarvoor moet gebruik worden gemaakt van een brug-schakeling met vier (elektronische) schakelaars die tegelijk omschakelen. Dit is aanzienlijk lastiger maar met de moderne elektronica toch goed uit te voeren. Daarom raakt de unipolaire stappenmotor - die duurder is aan spoelen - langzaamaan in onbruik.

{|class="wikitable"
|-
|[[File:Brugschakeling.png]]
|-
|Spoel in brugschakeling
|}

Voor de aansturing van een bipolaire stappenmotor worden drivers gebruikt die voor weinig geld te koop zijn. Een bijkomend voordeel van zo'n driver is dat hij tevens veel meer stroom kan leveren dan met rechtstreekse aansluiting op de Arduino mogelijk zou zijn (+40mA). Ook unipolaire stappenmotoren kunnen beter via een (ander soort) driver worden aangesloten. Dankzij deze drivers kunnen we stappenmotoren gebruiken die behoorlijk wat sterker kunnen zijn dan de mini-motortjes in de servo's van een eerder project. Een ander voordeel is dat drivers de Arduino beschermen tegen piekspanningen die de spoelen van de motor kunnen geven. Spoelen verzetten zich namelijk tegen verandering van de stroom door de spoel en genereren een tegen-spanning bij het (snel) afsluiten van de stroom. Die piekspanning kan zo hoog zijn dat het gevoelige elektronica beschadigt.

===De schakeling===

Extra benodigdheden:
*1 stappenmotor ([http://42bots.com/tutorials/28byj-48-stepper-motor-with-uln2003-driver-and-arduino-uno/ 28BYJ-48] - unipolaire stappenmotor)
*1 stappenmotor driver module (ULN2003)

{|class="wikitable"
|-
|[[File:28byj-48.jpg]]
|-
|De 28BYJ-48 unipolaire stappenmotor met driver
|}

====28BYJ-48====
Dit stappenmotortje is vrij populair, vooral vanwege zijn lage prijs: minder dan €5 (en dat is dan inclusief driver module). Hoewel het vaak prima motortjes zijn moet je wel een beetje oppassen. Ondanks dat ze steevast worden aangeduidt met hetzelfde typenummer ''28BYJ-48'' en je van buiten weinig verschil zult zien, gaat het in dit geval bepaald niet steeds om hetzelfde ding. Er bestaan versies met behoorlijk afwijkende specificaties. De meeste versies zijn voor 5 Volt, maar sommige lopen op 12 Volt. Er zijn, ook voor een gegeven voltage, verschillen in de weerstand van de spoelen en dus in stroomverbruik en kracht. Daarnaast zijn er grote verschillen en de ingebouwde tandwielvertraging. Hoewel de versies sterk op elkaar lijken hebben sommige meer dan 4000 stappen per rotatie, terwijl andere slechts 32 stappen per rotatie vragen. Gegevens op Internet zijn erg onbetrouwbaar. Vaak kun je in tabellen vinden dat de 12 Volt versie evenveel torque (kracht) geeft als een 5 Volt versie, terwijl dat erg onwaarschijnlijk is. [https://grahamwideman.wikispaces.com/Motors-+28BYJ-48+Stepper+motor+notes Hier] een uitgebried rapport van iemand die het e.e.a. heeft proberen na te gaan. Boodschap: onderzoek je eigen motor en vertrouw niet blindelings op de specs.

Wat alle types wel gemeen hebben is dat het gaat om een unipolaire stappenmotor met vijf aansluitdraden. Om de Arduino te beschermen en ook om meer stroom te kunnen leveren wordt hij aangesloten via een driver module met de ULN2003 chip als basis. Liefst gebruik je hierbij voor de stappenmotor ook een externe voeding (bijvoorbeeld van een powerbank). Die driver module laat met LEDjes vaak zien welke spoel-groepen bekrachtigd zijn en welke niet. De motor heeft een vertragingshuis met tandwielen (de as zit niet in het midden - dan moet er wel iets tussen zitten). De vertraging hiervan is (meestal!) bijna 1:64 (preciezer: 1:63.68395). Hij kan zo'n 15 toeren per minuut maken en levert, vanwege de ingebouwde vertraging, een behoorlijke kracht. Omdat we een Arduino gebruiken zal hij meestal draaien op 5 Volt (maar er zijn dus ook versies met hetzelfde typenummer, die tot 12 Volt gaan).

Voor een motor is ook de kracht die hij kan leveren een belangrijk gegeven. De 28BYJ-48 levert volgens specificatie een moment-kracht van zo'n 30 mN∙m (milli Newton-meter). Dit betekent dat het een kracht levert van 30 milli Newton op een afstand van een meter van de as. Op 1 cm afstand is die kracht dan 100x groter: 3 Newton, ofwel ongeveer 300 gram. De kracht wordt dus groter naarmate de afstand kleiner wordt. De gegeven kracht hangt overigens wel af van de frequentie waarmee de motor wordt aangestuurd en de voedingsspanning die wordt gebruikt. Als je teveel kracht vraagt, zal de motor nog wel stappen maken, maar neemt de kans toe dat hij stappen gaat overslaan. Dit geldt ook als je de stappen te snel wilt maken en dus een te grote stap-frequentie gebruikt.

Omdat de ingebouwde motor al 64 stappen nodig heeft om een ronde te maken en de 28BYJ-48 daarnaast een tandwielvertraging heeft van 1:63.68395 zijn er (ongeveer) 4076 stappen nodig voor een hele ronde van de as. Met ''stappen'' bedoelen we hier eigenlijk ''halve stappen''. Bij een hele stap gaat een magneet van het anker van de ene spoel naar de volgende, maar door twee naast elkaar liggende spoelen tegelijk te bekrachtigen, beweegt het anker zich naar een positie tussen de beide spoelen. Dit is geen bijzonderheid, maar wordt juist veel gebruikt voor extra precisie.

{|class="wikitable"
|-
|[[File:28byj-48_schakeling.png]]
|-
|Aansluiten 28BYJ-48 met ULN2003
|}

===Het programma===

<pre>
#include <Stepper.h>
#define STEPS 4076
Stepper myStepper(STEPS, 8, 9, 10, 11);

void setup() {
myStepper.setSpeed(10);
}

void loop() {
myStepper.step(10);
}
</pre>

===Uitleg===

===Beetje spelen===
Verdiepende opdrachtjes

===Navigatie===
*[[Arduino - Een servo|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - PIR bewegingsmelder|Volgende project]]

Arduino - De stappenmotor

2018-02-17T15:18:46Z

WikiAdmin:

Een stappenmotor is precies wat de naam suggereert: een motor die niet gewoon toeren maakt, maar stapjes zet. Elk stapje wordt afzonderlijk aangestuurd en de motor kan ook weer stapjes terug doen. Door snel achter elkaar, met hoge frequentie, veel stapjes te zetten kan een stappenmotor toch toeren maken, maar daarin blinken ze niet uit en dat is ook niet primair de bedoeling van stappenmotoren. In plaats daarvan zijn ze heel goed in het maken van een precies aantal stappen, bijvoorbeeld om iets in een bepaalde positie te brengen. Een voorbeeld is de printkop van een printer. Ook kun je met enig prutswerk een servo vaak vervangen door een stappenmotor. Maar terwijl een servo beperkt is tot een deel van 360 graden, kunnen stappenmotoren zonder probleem vele slagen maken. Daarbij meet een servo steeds de positie, terwijl een stappenmotor niet beschikt over een positiemeting. Je moet er dus vanuit gaan dat het aantal gezette stappen klopt. Als die stappen te snel komen wordt er wel eens een telfoutje gemaakt en dan is er geen vanzelfsprekende correctie. En als de stroom uitvalt heb je helemaal geen idee meer wat de positie is van het ding dat door de stappenmotor wordt aangestuurd. Daarom hebben systemen met stappenmotoren doorgaans een ingebouwd ijkpunt. Zo kun je de motor terugdraaien totdat iets een positie-signaal afgeeft, bijvoorbeeld doordat een uitsteeksel tegen een knopje aankomt. Dat kan dan het beginpunt zijn vanaf waar je begint met tellen. Afgezien daarvan kun je er doorgaans op vertrouwen dat de aansturing zodanig is dat er geen telfouten optreden. Een stappenmotor is dan een prachtig stuk techniek waarmee posities nauwkeurig kunnen worden ingesteld zonder terugkoppeling door middel van een meting.

===Werking===
Het voert te ver voor hier om de werking van een [https://nl.wikipedia.org/wiki/Elektromotor elektromotor] uit te leggen, maar het basisprincipe is dat een elektromagneet een andere magneet (vaak een permanente magneet) afwisselend aantrekt en afstoot. Een elektromagneet bestaat uit een draad die om een kern is gewikkeld (een spoel). De richting van het magneetveld wordt bepaald door de stroomrichting en de sterkte van het veld door de stroomsterkte. Een stappenmotor is precies zo'n type elektromotor met permanente magneten en elektromagneten. Het verschil zit in de aansturing waarbij de elektromagneten zo geschakeld worden dat ze de dichtstbijzijnde permanente magneet aantrekken of juist afstoten. Met een slim uitgedachte opzet van permanente magneten en spoelen kan een stappenmotor een stapje maken door de juiste spoel in de juiste stroomrichting te bekrachtigen. Zo'n stapje komt dan overeen met een bepaalde draaihoek die afhankelijk is van de opzet van de stappenmotor.

{|class="wikitable"
|-
|[[File:VariableReluctanceStepper.png]]
|-
|Werking stappenmotor: Als spoel C stroom krijgt, draait de as punt 5 naar spoel C; Als daarna spoel D stroom krijgt, draait daarna punt 4 naar spoel D; Spoel A trekt daarna punt 3 naar spoel A. Enz. De volgorde zorgt voor de draaing (en hier ook de draairichting).
|}

In het huis van sommige stappenmotoren zit ook een tandwielhuis dat voor extra vertraging zorgt en dus voor meer kracht, maar ook voor meer stappen per rotatie (en dus meer precisie). Daarbij kunnen stappenmotoren hun positie bevriezen en een extra tandwielvertraging vergemakkelijkt deze eigenschap.

Er zijn twee soorten stappenmotoren. De bipolaire stappenmotoren hebben spoelen waar de stroom in de ene of in de andere richting doorheen gaat. Omdat de stroomrichting door die spoelen dus moet kunnen omkeren heet dit type bipolair. Het andere, minder voorkomende type, heeft voor elke stroomrichting eigen spoelen. De stroom door elk van deze spoelen loopt altijd in dezelfde richting zodat dit type wordt aangeduid als unipolaire stappenmotoren.

Bipolaire stappenmotoren hebben twee groepen spoelen, terwijl unipolaire stappenmotoren vier groepen spoelen hebben. Spoelen van een groep worden tegelijk en op dezelfde wijze aangestuurd. Bij bipiolaire stappenmotoren zijn er drie mogelijkheden: een positieve stroom, een negatieve stroom, of natuurlijk geen stroom. Voor unipolaire stappenmotoren zijn er maar twee: stroom of geen stroom - de stroomrichting wordt niet omgedraaid. Daarentegen hebben die dus twee keer zoveel spoel-groepen. Twee groepen spoelen betekent dat een bipolaire stappenmotor vier aansluitdraden heeft: twee voor elke groep spoelen. Een unipolaire stappenmotor, met vier groepen spoelen, heeft vijf aansluitdraden omdat alle spoelen aan een kant aan een gemeenschappelijke draad zitten. Als je ooit ergens een motor vindt (of uit sloopt) kun je aan het aantal aansluitdraden meestal zien wat voor soort motor het is:
* twee dragen: normale elektromotor
* vier draden: bipolaire stappenmotor
* vijf of zes draden: unipolaire stappenmotor
Door de juiste afwisseling van aansturing kan de stappenmotor stapje voor stapje zetten: de spoelen trekken het anker van de motor dwingend in een bepaalde richting. Als dit met hoge frequentie gebeurt kan de motor zelfs behoorlijk wat toeren maken. Het aansturen van unipolaire stappenmotoren komt erop neer dat de spoelen in de juiste volgorde bekrachtigd moeten worden. Dat is een betrekkelijk eenvoudig klusje voor een Arduino. Maar voor bipolaire stappenmotoren moet dus de stroom''richting'' worden omgedraaid. Dat kan een Arduino niet. Daarvoor moet gebruik worden gemaakt van een brug-schakeling met vier (elektronische) schakelaars die tegelijk omschakelen. Dit is aanzienlijk lastiger maar met de moderne elektronica toch goed uit te voeren. Daarom raakt de unipolaire stappenmotor - die duurder is aan spoelen - langzaamaan in onbruik.

{|class="wikitable"
|-
|[[File:Brugschakeling.png]]
|-
|Spoel in brugschakeling
|}

Voor de aansturing van een bipolaire stappenmotor worden drivers gebruikt die voor weinig geld te koop zijn. Een bijkomend voordeel van zo'n driver is dat hij tevens veel meer stroom kan leveren dan met rechtstreekse aansluiting op de Arduino mogelijk zou zijn (+40mA). Ook unipolaire stappenmotoren kunnen beter via een (ander soort) driver worden aangesloten. Dankzij deze drivers kunnen we stappenmotoren gebruiken die behoorlijk wat sterker kunnen zijn dan de mini-motortjes in de servo's van een eerder project. Een ander voordeel is drivers de Arduino beschermen tegen piekspanningen die de spoelen van de motor kunnen geven. Spoelen verzetten zich namelijk tegen verandering van de stroom door de spoel en genereren een tegen-spanning bij het (snel) afsluiten van de stroom. Die piekspanning kan zo hoog zijn dat het gevoelige elektronica beschadigt.

===De schakeling===

Extra benodigdheden:
*1 stappenmotor ([http://42bots.com/tutorials/28byj-48-stepper-motor-with-uln2003-driver-and-arduino-uno/ 28BYJ-48] - unipolaire stappenmotor)
*1 stappenmotor driver module (ULN2003)

{|class="wikitable"
|-
|[[File:28byj-48.jpg]]
|-
|De 28BYJ-48 unipolaire stappenmotor met driver
|}

====28BYJ-48====
Dit stappenmotortje is vrij populair, vooral vanwege zijn lage prijs: minder dan €5 (en dat is dan inclusief driver module). Hoewel het vaak prima motortjes zijn moet je wel een beetje oppassen. Ondanks dat ze steevast worden aangeduidt met hetzelfde typenummer ''28BYJ-48'' en je van buiten weinig verschil zult zien, gaat het in dit geval bepaald niet steeds om hetzelfde ding. Er bestaan versies met behoorlijk afwijkende specificaties. De meeste versies zijn voor 5 Volt, maar sommige lopen op 12 Volt. Er zijn, ook voor een gegeven voltage, verschillen in de weerstand van de spoelen en dus in stroomverbruik en kracht. Daarnaast zijn er grote verschillen en de ingebouwde tandwielvertraging. Hoewel de versies sterk op elkaar lijken hebben sommige meer dan 4000 stappen per rotatie, terwijl andere slechts 32 stappen per rotatie vragen. Gegevens op Internet zijn erg onbetrouwbaar. Vaak kun je in tabellen vinden dat de 12 Volt versie evenveel torque (kracht) geeft als een 5 Volt versie, terwijl dat erg onwaarschijnlijk is. [https://grahamwideman.wikispaces.com/Motors-+28BYJ-48+Stepper+motor+notes Hier] een uitgebried rapport van iemand die het e.e.a. heeft proberen na te gaan. Boodschap: onderzoek je eigen motor en vertrouw niet blindelings op de specs.

Wat alle types wel gemeen hebben is dat het gaat om een unipolaire stappenmotor met vijf aansluitdraden. Om de Arduino te beschermen en ook om meer stroom te kunnen leveren wordt hij aangesloten via een driver module met de ULN2003 chip als basis. Liefst gebruik je hierbij voor de stappenmotor ook een externe voeding (bijvoorbeeld van een powerbank). Die driver module laat met LEDjes vaak zien welke spoel-groepen bekrachtigd zijn en welke niet. De motor heeft een vertragingshuis met tandwielen (de as zit niet in het midden - dan moet er wel iets tussen zitten). De vertraging hiervan is (meestal!) bijna 1:64 (preciezer: 1:63.68395). Hij kan zo'n 15 toeren per minuut maken en levert, vanwege de ingebouwde vertraging, een behoorlijke kracht. Omdat we een Arduino gebruiken zal hij meestal draaien op 5 Volt (maar er zijn dus ook versies met hetzelfde typenummer, die tot 12 Volt gaan).

Voor een motor is ook de kracht die hij kan leveren een belangrijk gegeven. De 28BYJ-48 levert volgens specificatie een moment-kracht van zo'n 30 mN∙m (milli Newton-meter). Dit betekent dat het een kracht levert van 30 milli Newton op een afstand van een meter van de as. Op 1 cm afstand is die kracht dan 100x groter: 3 Newton, ofwel ongeveer 300 gram. De kracht wordt dus groter naarmate de afstand kleiner wordt. De gegeven kracht hangt overigens wel af van de frequentie waarmee de motor wordt aangestuurd en de voedingsspanning die wordt gebruikt. Als je teveel kracht vraagt, zal de motor nog wel stappen maken, maar neemt de kans toe dat hij stappen gaat overslaan. Dit geldt ook als je de stappen te snel wilt maken en dus een te grote stap-frequentie gebruikt.

Omdat de ingebouwde motor al 64 stappen nodig heeft om een ronde te maken en de 28BYJ-48 daarnaast een tandwielvertraging heeft van 1:63.68395 zijn er (ongeveer) 4076 stappen nodig voor een hele ronde van de as. Met ''stappen'' bedoelen we hier eigenlijk ''halve stappen''. Bij een hele stap gaat een magneet van het anker van de ene spoel naar de volgende, maar door twee naast elkaar liggende spoelen tegelijk te bekrachtigen, beweegt het anker zich naar een positie tussen de beide spoelen. Dit is geen bijzonderheid, maar wordt juist veel gebruikt voor extra precisie.

{|class="wikitable"
|-
|[[File:28byj-48_schakeling.png]]
|-
|Aansluiten 28BYJ-48 met ULN2003
|}

===Het programma===

<pre>
#include <Stepper.h>
#define STEPS 4076
Stepper myStepper(STEPS, 8, 9, 10, 11);

void setup() {
myStepper.setSpeed(10);
}

void loop() {
myStepper.step(10);
}
</pre>

===Uitleg===

===Beetje spelen===
Verdiepende opdrachtjes

===Navigatie===
*[[Arduino - Een servo|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - PIR bewegingsmelder|Volgende project]]

2018-02-04T17:05:40Z

WikiAdmin: /* De schakeling */

Een stappenmotor is precies wat de naam suggereert: een motor die niet gewoon toeren maakt, maar stapjes zet. Elk stapje wordt afzonderlijk aangestuurd en de motor kan ook weer stapjes terug doen. Door snel achter elkaar, met hoge frequentie, veel stapjes te zetten kan een stappenmotor toch toeren maken, maar daarin blinken ze niet uit en dat is ook niet primair de bedoeling van stappenmotoren. In plaats daarvan zijn ze heel goed in het maken van een precies aantal stappen, bijvoorbeeld om iets in een bepaalde positie te brengen. Een voorbeeld is de printkop van een printer. Ook kun je met enig prutswerk een servo vaak vervangen door een stappenmotor. Maar terwijl een servo beperkt is tot een deel van 360 graden, kunnen stappenmotoren zonder probleem vele slagen maken. Daarbij meet een servo steeds de positie, terwijl een stappenmotor niet beschikt over een positiemeting. Je moet er dus vanuit gaan dat het aantal gezette stappen klopt. Als die stappen te snel komen wordt er wel eens een telfoutje gemaakt en dan is er geen vanzelfsprekende correctie. En als de stroom uitvalt heb je helemaal geen idee meer wat de positie is van het ding dat door de stappenmotor wordt aangestuurd. Daarom hebben systemen met stappenmotoren doorgaans een ingebouwd ijkpunt. Zo kun je de motor terugdraaien totdat iets een positie-signaal afgeeft, bijvoorbeeld doordat een uitsteeksel tegen een knopje aankomt. Dat kan dan het beginpunt zijn vanaf waar je begint met tellen. Afgezien daarvan kun je er doorgaans op vertrouwen dat de aansturing zodanig is dat er geen telfouten optreden. Een stappenmotor is dan een prachtig stuk techniek waarmee posities nauwkeurig kunnen worden ingesteld zonder terugkoppeling door middel van een meting.

===Werking===
Het voert te ver voor hier om de werking van een [https://nl.wikipedia.org/wiki/Elektromotor elektromotor] uit te leggen, maar het basisprincipe is dat een elektromagneet een andere magneet (vaak een permanente magneet) afwisselend aantrekt en afstoot. Een elektromagneet bestaat uit een draad die om een kern is gewikkeld (een spoel). De richting van het magneetveld wordt bepaald door de stroomrichting en de sterkte van het veld door de stroomsterkte. Een stappenmotor is precies zo'n type elektromotor met permanente magneten en elektromagneten. Het verschil zit in de aansturing waarbij de elektromagneten zo geschakeld worden dat ze de dichtstbijzijnde permanente magneet aantrekken of juist afstoten. Met een slim uitgedachte opzet van permanente magneten en spoelen kan een stappenmotor een stapje maken door de juiste spoel in de juiste stroomrichting te bekrachtigen. Zo'n stapje komt dan overeen met een bepaalde draaihoek die afhankelijk is van de opzet van de stappenmotor.

In het huis van sommige stappenmotoren zit ook een tandwielhuis dat voor extra vertraging zorgt en dus voor meer kracht, maar ook voor meer stappen per rotatie (en dus meer precisie). Daarbij kunnen stappenmotoren hun positie bevriezen en een extra tandwielvertraging vergemakkelijkt deze eigenschap.

Er zijn twee soorten stappenmotoren. De bipolaire stappenmotoren hebben spoelen waar de stroom in de ene of in de andere richting doorheen gaat. Omdat de stroomrichting door die spoelen dus moet kunnen omkeren heet dit type bipolair. Het andere, minder voorkomende type, heeft voor elke stroomrichting eigen spoelen. De stroom door elk van deze spoelen loopt altijd in dezelfde richting zodat dit type wordt aangeduid als unipolaire stappenmotoren.

Bipolaire stappenmotoren hebben twee groepen spoelen, terwijl unipolaire stappenmotoren vier groepen spoelen hebben. Spoelen van een groep worden tegelijk en op dezelfde wijze aangestuurd. Bij bipiolaire stappenmotoren zijn er drie mogelijkheden: een positieve stroom, een negatieve stroom, of natuurlijk geen stroom. Voor unipolaire stappenmotoren zijn er maar twee: stroom of geen stroom - de stroomrichting wordt niet omgedraaid. Daarentegen hebben die dus twee keer zoveel spoel-groepen. Twee groepen spoelen betekent dat een bipolaire stappenmotor vier aansluitdraden heeft: twee voor elke groep spoelen. Een unipolaire stappenmotor, met vier groepen spoelen, heeft vijf aansluitdraden omdat alle spoelen aan een kant aan een gemeenschappelijke draad zitten. Als je ooit ergens een motor vindt (of uit sloopt) kun je aan het aantal aansluitdraden meestal zien wat voor soort motor het is:
* twee dragen: normale elektromotor
* vier draden: bipolaire stappenmotor
* vijf draden: unipolaire stappenmotor
Door de juiste afwisseling van aansturing kan de stappenmotor stapje voor stapje zetten: de spoelen trekken het anker van de motor dwingend in een bepaalde richting. Als dit met hoge frequentie gebeurt kan de motor zelfs behoorlijk wat toeren maken. Het aansturen van unipolaire stappenmotoren komt erop neer dat de spoelen in de juiste volgorde bekrachtigd moeten worden. Dat is een betrekkelijk eenvoudig klusje voor een Arduino. Maar voor bipolaire stappenmotoren moet dus de stroom''richting'' worden omgedraaid. Dat kan een Arduino niet. Daarvoor moet gebruik worden gemaakt van een brug-schakeling met vier (elektronische) schakelaars die tegelijk omschakelen. Dit is aanzienlijk lastiger maar met de moderne elektronica toch goed uit te voeren. Daarom raakt de unipolaire stappenmotor - die duurder is aan spoelen - langzaamaan in onbruik.

{|class="wikitable"
|-
|[[File:Brugschakeling.png]]
|-
|Spoel in brugschakeling
|}

Voor de aansturing van een bipolaire stappenmotor worden drivers gebruikt die voor weinig geld te koop zijn. Een bijkomend voordeel van zo'n driver is dat hij tevens veel meer stroom kan leveren dan met rechtstreekse aansluiting op de Arduino mogelijk zou zijn (+40mA). Ook unipolaire stappenmotoren kunnen beter via een (ander soort) driver worden aangesloten. Dankzij deze drivers kunnen we stappenmotoren gebruiken die behoorlijk wat sterker kunnen zijn dan de mini-motortjes in de servo's van een eerder project. Een ander voordeel is drivers de Arduino beschermen tegen piekspanningen die de spoelen van de motor kunnen geven. Spoelen verzetten zich namelijk tegen verandering van de stroom door de spoel en genereren een tegen-spanning bij het (snel) afsluiten van de stroom. Die piekspanning kan zo hoog zijn dat het gevoelige elektronica beschadigt.

===De schakeling===

Extra benodigdheden:
*1 stappenmotor ([http://42bots.com/tutorials/28byj-48-stepper-motor-with-uln2003-driver-and-arduino-uno/ 28BYJ-48] - unipolaire stappenmotor)
*1 stappenmotor driver module (ULN2003)

{|class="wikitable"
|-
|[[File:28byj-48.jpg]]
|-
|De 28BYJ-48 unipolaire stappenmotor met driver
|}

====28BYJ-48====
Zoals gezegd is dit een unipolaire stappenmotor met vijf aansluitdraden. Om de Arduino te beschermen en ook om meer stroom te kunnen leveren wordt hij aangesloten via een driver module met de ULN2003 chip als basis. Die driver module laat met LEDjes vaak zien welke spoel-groepen bekrachtigd zijn en welke niet. De motor heeft een vertragingshuis met tandwielen (de as zit niet in het midden - dan moet er wel iets tussen zitten). De vertraging hiervan is bijna 1:64 (preciezer: 1:63.68395). Hij kan zo'n 15 toeren per minuut maken en levert, vanwege de ingebouwde vertraging, een behoorlijke kracht. Omdat we een Arduino gebruiken zal hij meestal draaien op 5 Volt, maar er zijn ook versies, met hetzelfde nummer, die tot 12 Volt gaan.

Voor een motor is ook de kracht die hij kan leveren een belangrijk gegeven. De 28BYJ-48 levert volgens specificatie een moment-kracht van zo'n 30 mN∙m (milli Newton-meter). Dit betekent dat het een kracht levert van 30 milli Newton op een meter afstand van de as. Op 1 cm afstand is die kracht dan 100x groter: 3 Newton, ofwel ongeveer 300 gram. De kracht wordt dus groter naarmate de afstand kleiner wordt. De gegeven kracht hangt overigens wel af van de frequentie waarmee de motor wordt aangestuurd en de voedingsspanning die wordt gebruikt. Als je teveel kracht vraagt, zal de motor nog wel stappen maken, maar neemt de kans toe dat hij stappen gaat overslaan. Dit geldt ook als je de stappen te snel wilt maken en dus een te grote stap-frequentie gebruikt.

Omdat de ingebouwde motor al 64 stappen nodig heeft om een ronde te maken en de 28BYJ-48 daarnaast een tandwielvertraging heeft van 1:63.68395 zijn er (ongeveer) 4076 stappen nodig voor een hele ronde van de as. Met ''stappen'' bedoelen we hier eigenlijk ''halve stappen''. Bij een hele stap gaat een magneet van het anker van de ene spoel naar de volgende, maar door twee naast elkaar liggende spoelen tegelijk te bekrachtigen, beweegt het anker zich naar een positie tussen de beide spoelen. Dit is geen bijzonderheid, maar wordt juist veel gebruikt voor extra precisie.

{|class="wikitable"
|-
|[[File:28byj-48_schakeling.png]]
|-
|Aansluiten 28BYJ-48 met ULN2003
|}

===Het programma===

<pre>
Hier de broncode van het programma
</pre>

===Uitleg===

===Beetje spelen===
Verdiepende opdrachtjes

===Navigatie===
*[[Arduino - Een servo|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - PIR bewegingsmelder|Volgende project]]

2018-02-04T16:52:26Z

WikiAdmin: /* De schakeling */

Een stappenmotor is precies wat de naam suggereert: een motor die niet gewoon toeren maakt, maar stapjes zet. Elk stapje wordt afzonderlijk aangestuurd en de motor kan ook weer stapjes terug doen. Door snel achter elkaar, met hoge frequentie, veel stapjes te zetten kan een stappenmotor toch toeren maken, maar daarin blinken ze niet uit en dat is ook niet primair de bedoeling van stappenmotoren. In plaats daarvan zijn ze heel goed in het maken van een precies aantal stappen, bijvoorbeeld om iets in een bepaalde positie te brengen. Een voorbeeld is de printkop van een printer. Ook kun je met enig prutswerk een servo vaak vervangen door een stappenmotor. Maar terwijl een servo beperkt is tot een deel van 360 graden, kunnen stappenmotoren zonder probleem vele slagen maken. Daarbij meet een servo steeds de positie, terwijl een stappenmotor niet beschikt over een positiemeting. Je moet er dus vanuit gaan dat het aantal gezette stappen klopt. Als die stappen te snel komen wordt er wel eens een telfoutje gemaakt en dan is er geen vanzelfsprekende correctie. En als de stroom uitvalt heb je helemaal geen idee meer wat de positie is van het ding dat door de stappenmotor wordt aangestuurd. Daarom hebben systemen met stappenmotoren doorgaans een ingebouwd ijkpunt. Zo kun je de motor terugdraaien totdat iets een positie-signaal afgeeft, bijvoorbeeld doordat een uitsteeksel tegen een knopje aankomt. Dat kan dan het beginpunt zijn vanaf waar je begint met tellen. Afgezien daarvan kun je er doorgaans op vertrouwen dat de aansturing zodanig is dat er geen telfouten optreden. Een stappenmotor is dan een prachtig stuk techniek waarmee posities nauwkeurig kunnen worden ingesteld zonder terugkoppeling door middel van een meting.

===Werking===
Het voert te ver voor hier om de werking van een [https://nl.wikipedia.org/wiki/Elektromotor elektromotor] uit te leggen, maar het basisprincipe is dat een elektromagneet een andere magneet (vaak een permanente magneet) afwisselend aantrekt en afstoot. Een elektromagneet bestaat uit een draad die om een kern is gewikkeld (een spoel). De richting van het magneetveld wordt bepaald door de stroomrichting en de sterkte van het veld door de stroomsterkte. Een stappenmotor is precies zo'n type elektromotor met permanente magneten en elektromagneten. Het verschil zit in de aansturing waarbij de elektromagneten zo geschakeld worden dat ze de dichtstbijzijnde permanente magneet aantrekken of juist afstoten. Met een slim uitgedachte opzet van permanente magneten en spoelen kan een stappenmotor een stapje maken door de juiste spoel in de juiste stroomrichting te bekrachtigen. Zo'n stapje komt dan overeen met een bepaalde draaihoek die afhankelijk is van de opzet van de stappenmotor.

In het huis van sommige stappenmotoren zit ook een tandwielhuis dat voor extra vertraging zorgt en dus voor meer kracht, maar ook voor meer stappen per rotatie (en dus meer precisie). Daarbij kunnen stappenmotoren hun positie bevriezen en een extra tandwielvertraging vergemakkelijkt deze eigenschap.

Er zijn twee soorten stappenmotoren. De bipolaire stappenmotoren hebben spoelen waar de stroom in de ene of in de andere richting doorheen gaat. Omdat de stroomrichting door die spoelen dus moet kunnen omkeren heet dit type bipolair. Het andere, minder voorkomende type, heeft voor elke stroomrichting eigen spoelen. De stroom door elk van deze spoelen loopt altijd in dezelfde richting zodat dit type wordt aangeduid als unipolaire stappenmotoren.

Bipolaire stappenmotoren hebben twee groepen spoelen, terwijl unipolaire stappenmotoren vier groepen spoelen hebben. Spoelen van een groep worden tegelijk en op dezelfde wijze aangestuurd. Bij bipiolaire stappenmotoren zijn er drie mogelijkheden: een positieve stroom, een negatieve stroom, of natuurlijk geen stroom. Voor unipolaire stappenmotoren zijn er maar twee: stroom of geen stroom - de stroomrichting wordt niet omgedraaid. Daarentegen hebben die dus twee keer zoveel spoel-groepen. Twee groepen spoelen betekent dat een bipolaire stappenmotor vier aansluitdraden heeft: twee voor elke groep spoelen. Een unipolaire stappenmotor, met vier groepen spoelen, heeft vijf aansluitdraden omdat alle spoelen aan een kant aan een gemeenschappelijke draad zitten. Als je ooit ergens een motor vindt (of uit sloopt) kun je aan het aantal aansluitdraden meestal zien wat voor soort motor het is:
* twee dragen: normale elektromotor
* vier draden: bipolaire stappenmotor
* vijf draden: unipolaire stappenmotor
Door de juiste afwisseling van aansturing kan de stappenmotor stapje voor stapje zetten: de spoelen trekken het anker van de motor dwingend in een bepaalde richting. Als dit met hoge frequentie gebeurt kan de motor zelfs behoorlijk wat toeren maken. Het aansturen van unipolaire stappenmotoren komt erop neer dat de spoelen in de juiste volgorde bekrachtigd moeten worden. Dat is een betrekkelijk eenvoudig klusje voor een Arduino. Maar voor bipolaire stappenmotoren moet dus de stroom''richting'' worden omgedraaid. Dat kan een Arduino niet. Daarvoor moet gebruik worden gemaakt van een brug-schakeling met vier (elektronische) schakelaars die tegelijk omschakelen. Dit is aanzienlijk lastiger maar met de moderne elektronica toch goed uit te voeren. Daarom raakt de unipolaire stappenmotor - die duurder is aan spoelen - langzaamaan in onbruik.

{|class="wikitable"
|-
|[[File:Brugschakeling.png]]
|-
|Spoel in brugschakeling
|}

Voor de aansturing van een bipolaire stappenmotor worden drivers gebruikt die voor weinig geld te koop zijn. Een bijkomend voordeel van zo'n driver is dat hij tevens veel meer stroom kan leveren dan met rechtstreekse aansluiting op de Arduino mogelijk zou zijn (+40mA). Ook unipolaire stappenmotoren kunnen beter via een (ander soort) driver worden aangesloten. Dankzij deze drivers kunnen we stappenmotoren gebruiken die behoorlijk wat sterker kunnen zijn dan de mini-motortjes in de servo's van een eerder project. Een ander voordeel is drivers de Arduino beschermen tegen piekspanningen die de spoelen van de motor kunnen geven. Spoelen verzetten zich namelijk tegen verandering van de stroom door de spoel en genereren een tegen-spanning bij het (snel) afsluiten van de stroom. Die piekspanning kan zo hoog zijn dat het gevoelige elektronica beschadigt.

===De schakeling===

Extra benodigdheden:
*1 stappenmotor ([http://42bots.com/tutorials/28byj-48-stepper-motor-with-uln2003-driver-and-arduino-uno/ 28BYJ-48] - unipolaire stappenmotor)
*1 stappenmotor driver module (ULN2003)

{|class="wikitable"
|-
|[[Bestand:28BYJ-48.jpg]]
|-
|De 28BYJ-48 unipolaire stappenmotor met driver
|}

====28BYJ-48====
Zoals gezegd is dit een unipolaire stappenmotor met vijf aansluitdraden. Om de Arduino te beschermen en ook om meer stroom te kunnen leveren wordt hij aangesloten via een driver module met de ULN2003 chip als basis. Die driver module laat met LEDjes vaak zien welke spoel-groepen bekrachtigd zijn en welke niet. De motor heeft een vertragingshuis met tandwielen (de as zit niet in het midden - dan moet er wel iets tussen zitten). De vertraging hiervan is bijna 1:64 (preciezer: 1:63.68395). Hij kan zo'n 15 toeren per minuut maken en levert, vanwege de ingebouwde vertraging, een behoorlijke kracht. Omdat we een Arduino gebruiken zal hij meestal draaien op 5 Volt, maar er zijn ook versies, met hetzelfde nummer, die tot 12 Volt gaan.

Voor een motor is ook de kracht die hij kan leveren een belangrijk gegeven. De 28BYJ-48 levert volgens specificatie een moment-kracht van zo'n 30 mN∙m (milli Newton-meter). Dit betekent dat het een kracht levert van 30 milli Newton op een meter afstand van de as. Op 1 cm afstand is die kracht dan 100x groter: 3 Newton, ofwel ongeveer 300 gram. De kracht wordt dus groter naarmate de afstand kleiner wordt. De gegeven kracht hangt overigens wel af van de frequentie waarmee de motor wordt aangestuurd en de voedingsspanning die wordt gebruikt. Als je teveel kracht vraagt, zal de motor nog wel stappen maken, maar neemt de kans toe dat hij stappen gaat overslaan. Dit geldt ook als je de stappen te snel wilt maken en dus een te grote stap-frequentie gebruikt.

Omdat de ingebouwde motor al 64 stappen nodig heeft om een ronde te maken en de 28BYJ-48 daarnaast een tandwielvertraging heeft van 1:63.68395 zijn er (ongeveer) 4076 stappen nodig voor een hele ronde van de as. Met ''stappen'' bedoelen we hier eigenlijk ''halve stappen''. Bij een hele stap gaat een magneet van het anker van de ene spoel naar de volgende, maar door twee naast elkaar liggende spoelen tegelijk te bekrachtigen, beweegt het anker zich naar een positie tussen de beide spoelen. Dit is geen bijzonderheid, maar wordt juist veel gebruikt voor extra precisie.

===Het programma===

<pre>
Hier de broncode van het programma
</pre>

===Uitleg===

===Beetje spelen===
Verdiepende opdrachtjes

===Navigatie===
*[[Arduino - Een servo|Vorige project]]
*[[Arduino cursus|Cursus overzicht]]
*[[Arduino - PIR bewegingsmelder|Volgende project]]