Archive for Návody

Merkurino a ultrazvukový dálkoměr HC-SC04

Jak měřit vzdálenost 3,5cm až 3,5metru?
Jednoduché a poměrně přesné a spolehlivé řešení je s ultrazvukovým dálkoměrem HC-SC04.

Potřebné díly:

    • Merkurino 01 s USB kabelem
    • ultrazvukový dálkoměr HC-SC04
    • kablíky(vodiče) s dutinkami na obou koncích F-F

Merkurino propojíme s modulem HC-SC04 pomocí kablíků a dáme si pozor na správné zapojení.

Pro funkci potřebujeme pouze 2 datové piny a 2 napájecí.
Echopin zapojíme na D9, Trigpin na D10 a napájecí Vcc na libovolných +5V a Gnd na zem(gnd).

Vzdálenost je vypisována přes USB port do terminalu Arduina: Ctrl+Shift+m

Mimo měřící rozsah je vypisována 0.

Příklad programu:

#define ECHOPIN 9        // Echo pin z HC-SC04 na pin 9
#define TRIGPIN 10        // Trig pin z HC-SC04 na pin 10

void setup()
{
//Nastaví sériovou komunikaci
Serial.begin(9600);
//Nastaví pin 2 jako vstupní
pinMode(ECHOPIN, INPUT);
//Nastaví pin 3 jako výstupní
pinMode(TRIGPIN, OUTPUT); 
}

void loop()
{
 // Vyšle impuls do modulu HC-SR04
  digitalWrite(TRIGPIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGPIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGPIN, LOW);
  
  // Spočítá vzdálenost
  float distance = pulseIn(ECHOPIN, HIGH);
  distance = distance*0.017315f;
  
  // odešle informace na sérivý port
  Serial.print(distance);
  Serial.print("cm\n");
  
  //počká 1 sekundu
  delay(1000);  
}

 

Merkurino 01 a krokový motor s A4988

Dnes si povíme něco o ovládání krokových motorů pomocí Arduina/Merkurina 01.

Co k tomu potřebujete:

  • Merkurino 01
  • unipolární krokový motor („ten se 4 dráty“)
  • modul pro ovládání krokových motorů – driver A4988 step+dir
  • propojovací vodiče
  • napájecí zdroj

Jak to funguje:

Určitě jste si všimli, že příklady v Arduinu obsahují návody Stepper – speed control a další.
To je určeno pro zapojení, kdy je motor zapojen přes dvojitý můstek (H-bridge) a procesor řídí taktování jednotlivých cívek přímo.

Na internetu najdete nejčastěji nabídku můstku s obvodem L298, který však přes ujišťování prodejců není vhodný pro motory typu Nema17, protože nemá zpětnou vazbu pro snímání proudu. Důsledkem je velká tepelná ztráta na chladiči a motoru a velký příkon.

Moderní zapojení využívá obvody se zpětnou vazbou, které se řídí pouze dvěmi signálními vodiči – step a dir. Dobře dostupný je obvod A4988 na malé desce s 2×8 piny vhodnými na pokusy v nepájivém poli.

Step je krok, Dir je směr. Takže stačí jen dokola posílat LOW a HIGH na vstup Step a pomocí Dir přepínat směr.

Schema zapojení:

Arduino + modul A4988

Arduino + modul A4988

Příklad zapojení:

Merkurino + a4988

Merkurino + a4988

Merkurino + a4988 1

Merkurino + a4988 1

Program, který jednou otočí tam a vrátí se do stejné pozice:

//základní zapojení Arduino/Merkurino 01 a modulu s A4988: 
//spojit dohromady reset a sleep 
//spojit VDD k Arduino 3.3v nebo 5v 
//spojit GND k Arduino GND (GND near VDD) 
//spojit 1A a 1B k stepper cívce 1 (nutno ověřit, jinak dojde ke zničení A4988)
//spojit 2A a 2B k stepper cívce 2 
//spojit VMOT k napájení ( +8 až +35V ) 
//spojit GRD k GND - zemi ( 0V ) 
 
//Jednoduché použití LiquidCrystal knihovny
#include <LiquidCrystal.h> 
// použité piny pro Merkurino 01 LCD panel
LiquidCrystal lcd(13, 12, 8, 7, 4, 2);
// definice proměnných 
 
int stp = 3; // 13;  // spojit pin 13 k step 
int dir = 5; // 12;  // spojit pin 12 k dir 
int a = 99;     //  čítač kroků 
int pauza = 10;   // pauza mezi kroky motoru [ms]
int pauza1 = 2000;   // pauza mezi otočením směru [ms]

 
void setup() 
{               
  pinMode(stp, OUTPUT); //
  pinMode(dir, OUTPUT);       
  digitalWrite(dir, LOW); 
  lcd.begin(16, 2); // start LCD library
}  
 
void loop() //loop-----------------------------
{ 
   otvirat();
   delay(pauza1);
   zavirat();
   delay(pauza1);
} //konec loop--------------------------- 

void otvirat() // otvirat ----------------------
{
   digitalWrite(dir, HIGH); //nastavení směru otáčení
    for ( a = 100; a < 300; a++)
    {
      digitalWrite(stp, HIGH); 
      delay(pauza);               
      digitalWrite(stp, LOW); 
      delay(pauza); 
      lcd.setCursor(0,0);
      lcd.print(a);lcd.print("+");
    }
} //konec otvirat----------------------
void zavirat() // zavirat ----------------------
{
   digitalWrite(dir, LOW); //nastavení obráceného směru otáčení
    for (int a = 300; a>100; a--)
    {
      digitalWrite(stp, HIGH); 
      delay(pauza);               
      digitalWrite(stp, LOW); 
      delay(pauza); 
      lcd.setCursor(0,0);
      lcd.print(a);lcd.print("-"); 
    }
  
} //konec zavirat----------------------

Udělej si (2) – posuvný registr

Kurz pro začátečníky – Jak zvětšit počet výstupů arduina pomocí posuvných registrů, angl. Shift Register

Co budete potřebovat:

1x Arduino (Uno, Duemilanova, Due, Leonardo)
1x integrovaný obvod 74HC595N
8x Led dioda (na barvě nezáleží)
8x rezistor 220 až 330 Ohm
1x nepájivé pole
dráty jako propojovací vodiče

Součástky a  materiál koupíte např. zde: Stavebnice.com/eshop

Jak zapojit:


Posuvný registr 74hc595



Na obrázku jsou zobrazena dvě nepájivá pole z důvodu přehlednosti. Zapojení lze samozřejmě zrealizovat na jednom.

LED diody mají obvykle jednu nožičku delší – ta se připojuje na plus. Nebo v tomto zapojení k odporu.

Ukázka programu 2.1 – světélka se hýbou:

//Pin zapojen do ST_CP of 74HC595
int latchPin = 8;
//Pin zapojen do SH_CP of 74HC595
int clockPin = 12;
//Pin zapojen do DS of 74HC595
int dataPin = 11;

void setup() {
 //nastaveni pinu jako vystupnich pro ovladani posuvneho registru
 pinMode(latchPin, OUTPUT);
 pinMode(clockPin, OUTPUT);
 pinMode(dataPin, OUTPUT);
}

void loop() {
 // pocita od 0 do 255 a zobrazi cislo na LEDky
 // 255 v dekadicky se zobrazi binarne 0b11111111
 for (int numberToDisplay = 0; numberToDisplay < 0b11111111; numberToDisplay++) {
 // nastav latchPin na LOW
 digitalWrite(latchPin, LOW);
 // a zacni posilat data po osmi bitech (protoze pouzivame 8 vystupu):
 shiftOut(dataPin, clockPin, MSBFIRST, numberToDisplay);  

 //kdyz zmenime latchPin z LOW do HIGH, tak se nam zobrazi data na vystupech:
 digitalWrite(latchPin, HIGH);
 // pauza pro cteni dalsich dat:
 delay(150);
 //digitalWrite(latchPin, LOW);
 //shiftOut(dataPin, clockPin, MSBFIRST, 0b01011011);
 //digitalWrite(latchPin, HIGH);
 //delay(550);
 }
}

Ukázka programu 2.2 – jak posílat data jednotlivě:

//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;

void setup() {
 //set pins to output so you can control the shift register
 pinMode(latchPin, OUTPUT);
 pinMode(clockPin, OUTPUT);
 pinMode(dataPin, OUTPUT);
}

void loop() {
 digitalWrite(latchPin, LOW);
 shiftOut(dataPin, clockPin, MSBFIRST, 0b00000000);
 digitalWrite(latchPin, HIGH);
 delay(150);
 digitalWrite(latchPin, LOW);
 shiftOut(dataPin, clockPin, MSBFIRST, 0b00011000);
 digitalWrite(latchPin, HIGH);
 delay(150);
 digitalWrite(latchPin, LOW);
 shiftOut(dataPin, clockPin, MSBFIRST, 0b00111100);
 digitalWrite(latchPin, HIGH);
 delay(150);
 digitalWrite(latchPin, LOW);
 shiftOut(dataPin, clockPin, MSBFIRST, 0b01111110);
 digitalWrite(latchPin, HIGH);
 delay(150);
 digitalWrite(latchPin, LOW);
 shiftOut(dataPin, clockPin, MSBFIRST, 0b11111111);
 digitalWrite(latchPin, HIGH);
 delay(150);
 }

Příště si povíme, jak rozšířit počet výstupů násobným připojením dalších posuvných registrů.


Udělej si (1) – doplnění o použití 6xPWM

Arduino umožňuje použít přímo až 6 PWM výstupů.

Příklad programu:

// program pro ovladani 6x PWM
// napr. 3x H-mustek
// plati pro Arduino s ATmega168 a ATmega328, to jsou běžná Arduina
// vystup pouze na piny 3, 5, 6, 9, 10 a 11
// potenciometr 5 až 50kOhm na analogovém vstupu 0 

int Ledpin11=11; //definice vystupnich pinu
int Ledpin10=10;
int Ledpin9=9;
int Ledpin6=6;
int Ledpin5=5;
int Ledpin3=3;

int analogpin=0;  // definice vstupu
int value=0;      // hodnota potenciometru
int x;

void setup()
 {
 Serial.begin(9600);
 pinMode(Ledpin11, OUTPUT);
 pinMode(Ledpin10, OUTPUT);
 pinMode(Ledpin9, OUTPUT);
 pinMode(Ledpin6, OUTPUT);
 pinMode(Ledpin5, OUTPUT);
 pinMode(Ledpin3, OUTPUT);
 }

void loop()
 {
 value=analogRead(analogpin);
 x=map(value,0,1023,0,255);
 analogWrite(Ledpin11,x);
 analogWrite(Ledpin10,255-x);
 analogWrite(Ledpin9,x);
 analogWrite(Ledpin6,255-x);
 analogWrite(Ledpin5,x);
 analogWrite(Ledpin3,255-x);
 Serial.println(x);
 delay(100);
 }

Udělej si (1) – Arduino – jak ovládat „napětí“

Kurz pro začátečníky – Jak ovládat napětí pomocí mikroprocesoru a potenciometru

Co budete potřebovat:

1x Arduino (Uno, Duemilanova, Due, Leonardo)
1x Led dioda (na barvě nezáleží)
1x rezistor 330 Ohm
1x potenciometr 5 kOhm
1x nepájivé pole
1x dráty jako propojovací vodiče

Součástky a  materiál koupíte např. zde: Stavebnice.com/eshop

Jak to bude vypadat pečlivě zapojené:


PWM - potenciometr a Ledka


Poznámka:

dejte pozor na zapojení, aby se v případě zkratu nepoškodil usb port na počítači.

Výpis programu:

int Ledpin=9;                  //vystup na LED
 int analogpin=0;              //vstup potenciometru
 int value=0;                  //promenna pro hodnotu potenciometru
 int x;                        //prevedena hodnota z 0..1023 na 0..255
void setup()
 {
 Serial.begin(9600);           //inicializace terminalu
 pinMode(Ledpin, OUTPUT);      //nastaveni digitalniho vystupu
 }
void loop()                    //hlavni smycka
 {
 value=analogRead(analogpin);  //precist potenciometr
 x=map(value,0,1023,0,255);    //prevod hodnot z potenciometru na PWM rozsah
 analogWrite(Ledpin,x);        //vystup PWM
 Serial.println(x);            //vystup na terminal
 delay(100);                   //pauza
 }

Jak to vlastně funguje:

Celé ovládání „napětí“ je založeno na takzvaném principu PWM – pulzně-šířkové modulaci.

Když zapneme vypínačem napětí do žárovky (motoru, ledky, odporu), dodáváme tím 100% elektrické energie.

Předpokládejme, že žárovka má spotřebu 10 Wattů.
Když ji rozsvítíme na 1 hodinu, má spotřebu 10 Wh (10 watt-hodin = 10 Wattů za hodinu).
Když ji rozsvítíme na půl hodiny a půl hodiny bude zhasnutá, bude mít celkovou spotřebu 5 Wh.
Když toto rozsvěcení a zhasínání budeme dělat hodně rychle, alespoň 50x za vteřinu, bude se zdát, že žárovka svítí zhruba polovičním svitem.

A toto je celé tajemství „napěťové“ regulace v digitálním světě 🙂

Pro názornost a konkrétní aplikaci pro arduino je tento obrázek:



PWM plnění



Příští týden si vyzkoušíme pasivní regulaci otáček stejnosměrného motoru pomocí tranzistoru a h-můstku.

Jeřáb č. 1

Model bude velikostně vhodný například pro vláčky velikosti „0“.
Na co se můžete těšit:

– tři velké motory na 12V
– stabilní patní ložisko, zaručující hladké otáčení
– několik nových designových dílů
– uložení důležitých hřídelí do průmyslových ložisek
– integrované ovládání
– navijáky lan
– a další…
– termín dokončení – do konce letošního roku s plnou motorizací.

Jeřáb

Jeřáb detail 1

Jeřáb detail2

Klec motorů pro jeřáb

Navrhl jsem klec pro 2 motory GM37.

Zatím jen virtuálně v Google Sketchup 8, ale jak budou speciální držáky pro motory vyrobeny fyzicky, tak bude k prodeji (do konce listopadu).

Návrh je schválně bez šroubků, aby byl model „rychlejší“ i na starších počítačích a zároveň je lépe vidět lícování děr.

Model je ke stažení ve formátu .skp zde