Archive for Elektronika

Merkurino a vlastní znaky na LCD

Merkurino / Arduino může jednoduše ovládat nastavení znakové sady na znakovém LCD  displeji.
Každý znak je definován maticí bodů 8 řádků x 5 sloupců.
Základní tabulku anglických znaků – malá a VELKÁ písmena bez diakritiky a číslice má displej uložen v paměti, proto ho stačí jen zavolat. Pokud chceme vlastní znaky, musíme si je nadefinovat sami.

Vlastní znaky

Vlastní znaky

Příklad kódu je zde:

#include <LiquidCrystal.h>
// upravil: L. Vohralík, 2014, MerkurRobot.cz
LiquidCrystal lcd(13, 12, 8, 7, 4, 2);

byte smiley[8] = {  //definice znaku smiley
  B00000,           // jednička svítí
  B10001,           // nula nesvítí
  B00000,
  B00000,
  B10001,
  B01110,
  B00000,
};
byte r_hacek[8] = {  //definice znaku r s háčkem = ř
  B01010,           // jednička svítí
  B00100,           // nula nesvítí
  B01110,
  B01001,
  B01000,
  B01000,
  B00000,
};
byte mezera[8] = {  //definice znaku mezera
  0, 0, 0, 0, 0, 0, 0,
};

void setup() {
  lcd.createChar(0, smiley);   //odeslání definice 1. znaku (znak 0)
  lcd.createChar(1, r_hacek);   //odeslání definice 2. znaku
  lcd.createChar(2, mezera);   //odeslání definice 3. znaku
  lcd.begin(16, 2);            //inicializace displeje
  lcd.write(byte(0));    //zobrazí smajlík (znak 0)
  lcd.write(byte(1));    //zobrazí ř (znak 1)
  lcd.write(byte(0));    //zobrazí smajlík (znak 0)
  lcd.write(byte(2));     //zobrazí mezeru (znak 2)
  lcd.write("ahoj");     //zobrazí text
  
}

void loop() {}

Merkurino 01 a hodiny RTC

Jak si naprogramovat budík? Jak spouštět čerpadlo jen v určitý čas podle změřené teploty?

K Merkurinu (Arduinu) stačí připojit modul s obvodem reálného času (DS1307) do konektoru pro seriovou komunikaci zvanou I2C.

modul RTC na i2c

modul RTC na i2c

Zapojení je jednoduché, stačí 4 vodiče nebo piny.
0V (Gnd),
+5V (Vcc),
data (Sda) na vstup A4 a
hodiny (Scl) na vstup A5.

Zobrazení reálného času

Zobrazení reálného času

připojení modulu

Připojení modulu

Příklad nastavení a čtení času:

// popis Merkurino 01: www.MerkurRobot.cz
// rtc modul na i2c - jen čtení času s ds1307
#include "Wire.h" // knihovna pro i2c komunikaci
#define DS1307_ADDRESS 0x68
byte zero = 0x00; //workaround for issue #527

#include <LiquidCrystal.h>
LiquidCrystal lcd(13, 12, 8, 7, 4, 2);
// definice proměnných
int lcd_key = 0;
int adc_key_in = 0;

char cas[8]; //pole znaků pro čas
char datum[10]; //pole znaků pro datum

void setup(){   // procedura setup ----------------------------
  Wire.begin();
  Serial.begin(9600);
  //setDateTime(); //MUST CONFIGURE IN FUNCTION
         //pokud chceme nastavit čas v hodinách,
         //zrušit lomítka a nastavit ve funkci přesný čas.
         //Po nastavení opět zapoznámkovat
  lcd.begin(16, 2); // start LCD library
  lcd.setCursor(0,0); // nastavení pozice kurzoru
  lcd.print("Nyni");  
  lcd.setCursor(0,1); //
  lcd.print("je:");                  
} // konec procedura setup ----------------------------

//----------------------------------------------------------
void loop(){  // procedura loop ----------------------------
  printDate();
  lcd.setCursor(8,0); // nastavení pozice kurzoru
  lcd.print(cas);
  lcd.setCursor(6,1); // nastavení pozice kurzoru
  lcd.print(datum);
  delay(1000);
} // konec procedura loop ----------------------------------
//----------------------------------------------------------

// procedury pro nastavení a čtení času v hodinách ds1307 -------
void setDateTime(){ 
  byte second =00; //0-59
  byte minute =53; //0-59
  byte hour =14; //0-23
  byte weekDay = 0; //1-7 (0-6, neděle – sobota
  byte monthDay =19; //1-31
  byte month = 9; //1-12
  byte year= 14; //0-99 (msd’s 4-digit year ignored
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero); //stop Oscillator
  Wire.write(decToBcd(second));
  Wire.write(decToBcd(minute));
  Wire.write(decToBcd(hour));
  Wire.write(decToBcd(weekDay));
  //DS1307 RTC Libraries And Examples V2.1.Docx 11
  Wire.write(decToBcd(monthDay));
  Wire.write(decToBcd(month));
  Wire.write(decToBcd(year));
  Wire.write(zero); //start
  Wire.endTransmission();
}
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 printDate(){
  // Reset the register pointer
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_ADDRESS, 7);
  int second = bcdToDec(Wire.read());
  int minute = bcdToDec(Wire.read());
  int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
  int weekDay = bcdToDec(Wire.read()); //0-6 -> sunday -Saturday
  int monthDay = bcdToDec(Wire.read());
  int month = bcdToDec(Wire.read());
  int year = bcdToDec(Wire.read());
  //print the date EG 23.01.2011 23:59:59
  sprintf(cas,"%02d:%02d:%02d",hour,minute,second);
  sprintf(datum,"%02d.%02d.20%02d",monthDay,month,year);
  Serial.print(datum); Serial.print(" "); Serial.print(cas);
  Serial.println();
  
}
// konec procedur pro nastavení a čtení času v hodinách ds1307 -------

Merkurino 01 – Arduino nano pro roboty

Řešili jste někdy, jak jednoduše ovládat nějaký stroj s motory a několika senzory? Abyste se zároven nemuseli moc zabývat kabeláží a kam a jak namontovat různé moduly? Podívejte se na projekt Merkurino:

Základem je standardní procesor AVR Mega328 s programováním v prostředí Arduino, standardní modul Arduino Nano r3. To má 8 analogových vstupů a 14 digitálních výstupů, a samozřejmě se všechny dají přenastavit jak vstupní, tak výstupní.

Základní sestava obsahuje:

  • Arduino Nano rev.3
  • LCD 16×2,
  • 6x HW PWM výstup
  • samostatný 3x H-můstek 500mA, 9V
  • 6x analogové tlačítko pro ovládání na pinu A0
  • 3x dvojité analogové tlačítko piny A5-A7
  • 4x plné vstupy A1-A4, třípin
  • napájení: 5V z Arduino Nano nebo lépe externí 7-15V DC (7805)

 

Pohled ze strany displeje:
DSCN0028

Pohled ze strany arduina a konektorů, zde je zapojen na I²C modul reálného času:
DSCN0030

Schema zapojení v1.3:
merkurino_01-v1.3-f

Schema zapojení v1.4.4:

merkurino01_sch_v1-4-4

Rozměry desky:
merkurino_01-v1.3-f-dokumentace – rozmery

Rozmístění konektorů v.1.3.f:

Merkurino 01 – rozmístění konektorů

Rozmístění konektorů v.1.4.4:

merkurino01_con_v1-4-4

Dokumentace ke stažení : merkurino-01-datasheet.pdf

Merkurino 01 – displej LCD a klávesnice

Jak použít LCD displej 16×2 na Merkurinu – Arduinu Nano.

Jediná změna oproti standardnímu použití u Arduina jsou použité piny.

Kód je zde:

/**********************************************************************
Tento program otestuje Merkurino 01 s displejem a klávesnicí
MerkurRobot.cz 2014
**********************************************************************/
//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 lcd_key = 0;
int adc_key_in = 0;
#define btnRIGHT 0
#define btnUP 1
#define btnDOWN 2
#define btnLEFT 3
#define btnENTER 4
#define btnESC 5
#define btnNONE 6

int read_LCD_buttons() // procedura čtení tlačítek  --------------------------
{
  adc_key_in = analogRead(0); // čtení "napětí" na vstupu A0
  //lcd.setCursor(12,1);lcd.print(adc_key_in); lcd.print("   ");
  if (adc_key_in > 1000) return btnNONE; // žádné tlačítko není stisknuto
  // pro Merkurino 01 plati tyto hodnoty:
  if (adc_key_in < 40) return btnESC; 
  if (adc_key_in < 110) return btnLEFT;
  if (adc_key_in < 300) return btnDOWN;
  if (adc_key_in < 450) return btnUP;
  if (adc_key_in < 700) return btnRIGHT;
  if (adc_key_in < 850) return btnENTER;
  
  return btnNONE; // žádné tlačítko není stisknuto// konec procedura čtení tlačítek  --------------------------
void setup()  //--- procedura setup --------------------------
{
  lcd.begin(16, 2); // start the library
  lcd.setCursor(0,0);
  lcd.print("Stiskni tlacitko"); // print a simple message
}  //--- konec procedura setup --------------------------
void loop() //--- začátek nekonečné smyčky --------------------------
{
  lcd.setCursor(8,1); // přemístí kursor na 2. řádek (1) a 9. pozici
  lcd.print(millis()/1000); // zobrazí vteřiny od zapnutí 
  lcd.setCursor(0,1); // přemístí kursor na začátek 2. řádku
  lcd_key = read_LCD_buttons(); // zavolej čtení tlačítka
  switch (lcd_key) // vyvolej akci podle stisknutého tlačítka
  {
    case btnRIGHT:
    {
      lcd.print("vpravo  ");
      break;
    }
    case btnLEFT:
    {
      lcd.print("vlevo   ");
      break;
    }
    case btnUP:
    {
      lcd.print("nahoru     ");
      break;
    }
    case btnDOWN:
    {
      lcd.print("dolu   ");
      break;
    }
    case btnENTER:
    {
      lcd.print("potvrd ");
      break;
    }
    case btnESC:
    {
      lcd.print("zpet    ");
      break;
    }
    case btnNONE:
    {
      lcd.print("nic   ");
      break;
    }
  }
} //--- konec nekonečné smyčky --------------------------

Letujeme horkovzduchem smd

Někteří z nás se setkali s potřebou vyměnit mnohanohou součástku smd.
Buď můžeme nožičky opatrně odříznout nebo odštípat a pak jednu po druhé páječkou odendavat, nebo opatrně použít zdroj horkého vzduchu.

Narazil jsem na pěkné video, které hezky ukazuje celý postup.

Nejdříve odstraníme původní součástku. Zde je použita pro uchopení součástky podtlaková přísavka. Já mám docela dobré zkušenosti s tvrdou ostrou ohnutou „jehlou“ ze sady nástrojů, které prodávají třeba v GMe. Musí se s ní pracovat velmi opatrně, protože pokud zapáčíte a nemáte nožičky ( součástku ) dostatečně prohřáté, můžete lehce utrhnout pad na plošňáku  a je zaděláno na velký problém.

Další doporučení je natrénovat si teplotu a množství vzduchu. Když ho přeženete, tak horký proud vám odfoukne malé odpory a jako „bonus“ přidá rozfoukané malé kuličky cínu do míst, která nejsou vidět a mohou způsobit zkrat, třeba až za několik měsíců. Nejlepší je si natrénovat na starých deskách ze šrotu.

To je ta jednodušší část.

Ve videu ukázané letování pájecí pasty je mnohem obtížnější na cvik a trpělivost, ale jak je vidět, když dostatečně natrénujete, tak výsledek se dostaví a je čím se chlubit 🙂

Udělej si (3) – skutečné hodiny RTC

Tak to vám jednou se probudím, a ono tma. Že bych si nastavil budík? To raději jako správný kutil si ho musím udělat. Opravdový kutil začne přesýpačkami, ale nenašel jsem správné skleničky, tak mi zbylo zas jen Arduino.

Co budete potřebovat:

  • 1x Arduino (Uno, Duemilanova, Due, Leonardo)
  • 1x nepájivé pole
  • dráty jako propojovací vodiče
  • 1x integrovaný obvod DS1307
  • 1x krystal 32,768 kHz
  • 2x rezistor 2k2
  • 1x baterii 3 až 3,6V

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

Jak zapojit:

RTC - i2c - DS1307

Jak vidíte, zapojení je velmi jednoduché.
Rezistory (= odpory) mohou být 1k5 – 10k.
Zde zobrazená baterie může být nahrazena jakoukoliv nenabíjecí, jen si ohlídejte napětí a polaritu.
Komunikace mezi Arduinem a DS1307 je přes AnalogIn piny A4 a A5.

Pro spuštění ještě musíte nahrát knihovnu RTC s DS1307 a „Sketch -> Import Library“

Knihovnu stáhněte zde: RTClib-ds1307

a rozbalte do adresáře ..arduino-0018libraries

Vyzkoušeno ve verzi 0018, 0022 a 1.0

Ukázka programu 4.1 – hodiny reálného času RTC:

// Funkce data a času DS1307 RTC zapojenému přes I2C a knihovnu Wire
#include <Wire.h>
#include "RTClib.h"

RTC_DS1307 RTC;

void setup () {

 Serial.begin(57600);
 Wire.begin();
 RTC.begin();

 if (! RTC.isrunning()) {
 Serial.println("RTC is NOT running!");
 // následující řádka nastaví RTC datum a čas po zkompilování podle počítače
 RTC.adjust(DateTime(__DATE__, __TIME__ ));
 }
}

void loop () {
 DateTime now = RTC.now();

 // příkaz Serial.print() pošle data přes USB do počítače,
 // kde je zobrazíme v terminálu - Ctrl+Shift+M.

 Serial.print(now.year(), DEC);
 Serial.print('/');
 Serial.print(now.month(), DEC);
 Serial.print('/');
 Serial.print(now.day(), DEC);
 Serial.print(' ');
 Serial.print(now.hour(), DEC);
 Serial.print(':');
 Serial.print(now.minute(), DEC);
 Serial.print(':');
 Serial.print(now.second(), DEC);
 Serial.println();

 Serial.print(" since midnight 1/1/1970 = ");
 Serial.print(now.unixtime());
 Serial.print("s = ");
 Serial.print(now.unixtime() / 86400);
 Serial.println("d");

 // chceme-li přičíst ke stávajícímu datu a času 7 dní a 30 sekund
 DateTime future (now.unixtime() + 7 * 86400L + 30);

 Serial.print(" now + 7d + 30s: ");
 Serial.print(future.year(), DEC);
 Serial.print('/');
 Serial.print(future.month(), DEC);
 Serial.print('/');
 Serial.print(future.day(), DEC);
 Serial.print(' ');
 Serial.print(future.hour(), DEC);
 Serial.print(':');
 Serial.print(future.minute(), DEC);
 Serial.print(':');
 Serial.print(future.second(), DEC);
 Serial.println();

 Serial.println();
 delay(1000);

} //------ konec ------------

Příště si povíme, jak připojit LCD display a hodiny budou svítit do tmy 🙂

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.

Zakázkové díly pro Merkur

Často slýcháme stesky po specializovaných dílech, které by vám pomohly vyřešit někdy velice komplikované konstrukční zádrhele.

Nalezl jsem katalog dílů, které jsou sice v jiných rozměrech, ale není problém je přizpůsobit.

Pokud byste měli zájem, napište, o vás zajímá a obratem obdržíte cenu a termín.

Katalog v němčině s obrázky je zde:

http://www.metallus.de/index.php?&page=einzelteile

Pište na info@stavebnice.com