DK Electronicsmotorshield V1.0
juli 2016
Ik had al van alles gedownload toen ik er achter kwam dat er een groot verschil is in aansturing van versie 1.x en 2.x. Ik heb versie 1.0 en die stuurt de pinnen anders dan V2.x aan.
De mooie libery voor versie 2, die ik van Adafruit, al gedownload en geinstaleerd had kan ik dus weer verwijderen.

De theorie

Het schema links is handig maar als je dat probeert te snappen aan het hand van het schema er naast kom je tegen een paar vreemde dingen aan. Rechts D0-7 pootje 1 en 2 niet aangesloten, is dus Arduino 0 t/m 7 nu genummerd als 1 t/m 8, vind je terug als J1 op het schema links. J3 staat rechts als een 10 polige aansluiting getend maar in de tekening links als een 8 polige sluiting. Arduino 8 T/m 15 wordt 1 t/m 8 op J3.
JP1 een 6 pins aansluiting op de tekening links is de getekende 8 pins aansluiting er onder bij de voeding. De reset staat getekend bij de linker tekening bij pin 1 wat bij de tekening rechts pin 6 is.
Met andere woorden even goed kijken waar je dingen aan moet sluiten.

Omdat pin 2 niet gebruikt wordt, kan je daar net als bij Analoog 0 t/m 5 gebruiken (is ook digitaal 14 t/m 19), als je daar een pinnetjes soldeert.

Het motershield is ontworpen om gelijkstroom motoren tussen de 4.5v tot 25v en tot to 0.6A vermogen.
Het is mogelijk om 3V motoren aan te sturen maar dan gaat dat niet zo netjes. Als je 6V motoren wil aansturen gebruik dan een voedingspanning van 7,2V. Er is altijd een verlies van ca 1,2 V.
Als je de motoren via de Arduino van voedingspanning wil voorzien dan moet je de jumper plaatsen. (er is maar 1 jumper) het plaatsen van de jumper geeft meteen ook de mogelijkheid dat de Arduino verstoord wordt door piekspanningen van de motoren en kan problemen geven bij kortsluiting bij de moter.
De blauwe omlijnde gaten zijn voor zelf te solderen pinnen voor de 0 t/m 5 analoge/digitale aansluitingen. De zwarte pijl is de jumper als je de motoren wil voeden met dezelfde spanning als die voor de Arduino.
De rode lijn is de externe voeding plus en de blauwe lijn de externe voeding min. Het middelste IC is de 74HC595.
Let bij het aansluiten van externe voedingspanning goed op dat (alleen!!) de min van de externe voeding aan de GND van het Shield verbonden wordt. Ik lees het en vertaal het maar als ik de tekening zie is de gnd centraal verbonden en kan je dus geen min te verbreken. De jumper verbreekt de externe voeding.Dus mijn vermoeden is dat als je de externe voeding gebruikt voor de motoren dat je alleen de jumper hoeft te verwijderen. Je verbreekt volgens de tekening alleen de plus die van Arduino komt naar de externe voeding.
Mocht je problemen krijgen bij het aansluiten van de servo's, overweeg dan een externe voeding aan te sluiten voor de servo. Daarvoor moet je dan volgens de beschrijving een printbaan door snijden.
En uiteraard is mijn board weer anders.De voeding voor de servo's van mijn board is zeker bovenlangs aangesloten. Maar dat moet geen probleem worden, in het ergste geval knip ik de middelste draden naar de servo door en verbind die aan een externe 6V. De min van de externe voeding dan wel verbinden met de GND van het board.


De buitenste 2, L293 IC's heb ik hier al eens beschreven.
En dan eens kijken hoe ik de 74HC595 moet laten werken.
QA t/m QH zijn de parrallel uitgangen en SQH9 de seriele uitgang.
Als ik J1 (1-8) beschouw als de Arduino aansluitingen 0-7 en J3 (1-8) de aansluitingen 8 t/m 15 dan zie ik:

74HC595 alsvolgt verbonden:
JUMPERS/Connectoren
X1: P1-M1A P2-M1B P3-GND P4-M2A P5-M2B aansluitingen
X2: P1-M3A P2-M3B P3-GND P4-M4A P5-M4B aansluitingen
SER1:servo1-PW1B
SER2:servo2-PW1A
JP1: 1-NC 2-NC 3--JP3-D2 4-D3 5-D4 6-D5 7-D6 8-D7(Dx==digitale Arduino aansluitingen)
JP2: 1-D8 2-D9 3-D10 4-D11 5-D12 6-NC 7-GND 8-NC
JP10: alles GND bij analoog poorten
JP8: alles 5V bij analoog poorten
JP2: 6x Analoog verbonden met JP6 - 1-1 2-2 etc.
P1: Extern + via jumper
P2: Extern GND
JP1: 1=reset 2=NC 3=VCc 4+5=GND=P2 6=Extern max 9V via jumper P1

Tussen de linker haakjes zijn de pootnummers van het IC
(16) + 5V VCC positive supply voltage
(8) - 5V GND
(11)DIR_CLK(SHIFT register Clock input(SHCP)) verbonden met Arduino pin 4
(14)DIR_SER (DS serial data input) met Arduino pin 8
(10)Master Reset active LOW (dus aan plus om niet te resetten.)
(12)DIR_LATCH (STCP storage register clock input) met Arduino pin 12
(13)DIR_EN (OE output_Enable active 0) met Arduino pin 7
(9)QH niet verbonden seriele uitgang
(15)QA naar motor 3A aansturen
(1)QB naar motor 2A aansturen
(2)QC naar motor 1A aansturen
(3)QD naar motor 1B aansturen
(4)QE naar motor 2B aansturen
(5)QF naar motor 4A aansturen
(6)QG naar motor 3B aansturen
(7)QH naar motor 4B aansturen

Als we de tekening van Adafruit bekijken en we bekijken de onderzijde van het shield dan kunnen we redelijk makkelijk de connectoren terug vinden. JP3 (bij pin 2) J8 J10 en J4 moet je dus zelf de pinnen solderen.
Als je een moter voor en achteruit wil laten draaien moet je een moter op A en B aansluiten. Dus b.v. 1A en 1B. Bij X1 of X2 de linker/rechter 2 verbindingen.
2 Stappen motoren of 4 moteren voor en achteruit keuze of 8 motoren 1 draairichting.
Wil je motor 1 dus vooruit laten draaien dan moet 1A o.a. hoog(aan/plus) worden en 1B laag(uit/min). Beide plus of beide min gaat de motor niet draaien.

En Arduino:
Arduino 6 PWM0A pulsen voor IC1 A kant
Arduino 5 PWM0B pulsen voor IC1 B kant
Arduino 11 PWM2A pulsen voor IC2 A kant
Arduino 3 PWM2B pulsen voor IC2 B kant

Je moet seriele data op een poort zetten, inklokken in het shiftregister met Serclock (SRCLK hoog zetten) en daarna het data register aanbieden door RCLK hoog te maken. Enable laag.
Op artimesdiy.nl wordt dat goed uigelegd.
En uiteraard de output aanzetten anders gebeurt er niets.
De servo krijgt de pulsen van:
Arduino 9 PWM1A pulsen voor servo 1
Arduino 10 PWM1B pulsen voor servo 2


Er zijn 4 motoren met 2 uitgangen(a/b), dus 8 unieke adressen.
M4b 1
M2b 2
M1b 4
M1a 8
M2a 16
M3b 32
M4a 64
M3a 128
Wil je moter 4 linksom laten draaien dan waarde 64 HIGH en 1 LOW.
Wil je moter 4 rechtsom laten draaien dan waarde 64 LOW en 1 HIGH.
Wil je moter 3 linksom laten draaien dan waarde 128 HIGH en 32 LOW.
Wil je moter 3 rechtsom laten draaien dan waarde 128 LOW en 32 HIGH.
Wil je moter 2 linksom laten draaien dan waarde 16 HIGH en 2 LOW.
Wil je moter 2 rechtsom laten draaien dan waarde 16 LOW en 2 HIGH.
Wil je moter 1 linksom laten draaien dan waarde 8 HIGH en 4 LOW.
Wil je moter 1 rechtsom laten draaien dan waarde 8 LOW en 4 HIGH.
Even een klein stukje achtergrond.
Een computer rekent binair met 1 en 0. Dat wordt meestal weergegeven in Hexadecimale getallen.
0 = 0000
1 = 0001
2 = 0010
3 = 0011
4 = 0100
Nu zijn er 8 adressen voor 4 motoren nodig. Een 1 is die motor selecteren een nul is geen selectie.
0000 0000
In dit geval is op het shield, motor 1 niet de eerste nul maar de 4e en de 5e van rechts.
0000 yx00 zijn de aansluitingen voor motor 1.
De x is draairichting 1 en de y draairichting 2.
Binair is zoals je boven kon zien, van rechts naar links dus 128 64 32 16 8 4 2 1
Wil je nu 1 motor laten draaien moet je dus 1 getal aansturen. 2 Motoren dan tel je de 2 getalen bij elkaar op 2+4=6. Stuur je 6 uit dan gaan 2 en 4 aan.
Dat getal binair of hex moet je in het register klokken.

Je geeft dan aan welke moter welke kant moet gaan draaien als je dat in klokt. Vervolgens gebeurt er niets omdat je niet aangeeft met welke snelheid de moter moet gaan draaien.
De PWM signalen moeten nog positief worden. Arduino D5 PWM0B voor moter 3, Arduino D6 PWM0A voor moter 4, Arduino D4 PWM2B voor moter 2 en als laatste D11 PWM2A voor moter 1.

Met de Arduino 9 PWM1A bedien je de servo2 en Arduino 10 PWM1B servo 1.

De praktijk

//**************************************************************
// Name : looplicht binair
// Author : Gérard Gooijer, ArtimesDIY
// Date : 9-3-2012
// Notes : code om de 74HC595 Shift Register
// : te laten tellen van 1 tot 8
// : Aangepast door P.Hogenstijn voor het DKshield
// : Elke moter aansluiting staat nu meteen hoog
// : Versie 2 laat moter langzaam op toeren komen en afremmen
//****************************************************************
// Voor 4 losse gelijkstroom motoren
int moter1A =8;
int moter1B =4;
int moter2A =16;
int moter2B =2;
int moter3A =128;
int moter3B =32;
int moter4A =64;
int moter4B =1;

//Pin aangesloten op ST_CP van 74HC595
int latchpin = 12;
//Pin aangesloten op SH_CP van 74HC595
int clockpin = 4;
//Pin aangesloten op DS van 74HC595
int datapin = 8;
//Pin aangesloten op DIR_EN van 74HC595
int enablepin = 7;
//Pin aangesloten op PWM van L293 M1
int pwm1pin = 10;
//Pin aangesloten op PWM van L293 M2
int pwm2pin = 4;
//Pin aangesloten op PWM van L293 M3
int pwm3pin = 5;
//Pin aangesloten op PWM van L293 M4
int pwm4pin = 6;
int teller;
void setup() {
//verander de pins naar OUTPUT
pinMode(latchpin, OUTPUT);
pinMode(clockpin, OUTPUT);
pinMode(datapin, OUTPUT);
pinMode(enablepin, OUTPUT);
Serial.begin(9600);
// alle moter snelheden alvast hoog
// deze regels 255 later veranderen in 0
analogWrite(pwm1pin,255);
analogWrite(pwm2pin,255);
analogWrite(pwm3pin,255);
analogWrite(pwm4pin,255);
}

void loop()
{
// moter 1A
//Door de Latchpin op lAAG zetten gaan de LEDs uit
digitalWrite(latchpin, LOW);
//Dan gebruiken we shiftOut om de biniar code door te geven moter 1 richting A
shiftOut(datapin, clockpin, MSBFIRST,moter1A);
//waarnaar we de Latchpin weer HOOG zetten gaan de LEDs weer aan
digitalWrite(latchpin, HIGH);

// moter 1B
delay(300);
//en dit herhalen we moter 1 richting B
digitalWrite(latchpin, LOW);
shiftOut(datapin, clockpin, MSBFIRST, moter1B);
digitalWrite(latchpin, HIGH);
delay(300);

// moter 2A
digitalWrite(latchpin, LOW);
shiftOut(datapin, clockpin, MSBFIRST, moter2A);
digitalWrite(latchpin, HIGH);
delay(300);

// moter 2B
digitalWrite(latchpin, LOW);
shiftOut(datapin, clockpin, MSBFIRST, moter2B);
digitalWrite(latchpin, HIGH);

delay(300);
// moter 3A
digitalWrite(latchpin, LOW);
shiftOut(datapin, clockpin, MSBFIRST, moter3A);
digitalWrite(latchpin, HIGH);

delay(300);
// moter 3 richting B
digitalWrite(latchpin, LOW);
shiftOut(datapin, clockpin, MSBFIRST, moter3B);
digitalWrite(latchpin, HIGH);
delay(300);

// moter 4 richting A
digitalWrite(latchpin, LOW);
shiftOut(datapin, clockpin, MSBFIRST, moter4A);
digitalWrite(latchpin, HIGH);
delay(300);

// moter 4 richting B
digitalWrite(latchpin, LOW);
shiftOut(datapin, clockpin, MSBFIRST, moter4B);
digitalWrite(latchpin, HIGH);
delay(300);
}

bronnen:

V2.0
mcuoneclipse.com/
learn.adafruit.com/adafruit-motor-shield
handleiding
V1.0
forums.adafruit.com/
instructables.com en library
data_sheet/74HC_HCT595.pdf
74hc595 uitleg
www.adafruit.com/product/81
original/mshieldv1-schem
jameco.com Pinout
Arduino en 74hct595