Category / Arduino

AtTiny serijos ir kitų AtMegų kontaktai pagal Arduino 2017.11.07 at 14:17

Radau Internete paveiksliuką, gal kada pravers.

Ir pačios Atmega 328:

Ir dar Atmega328P-AU versijos:

Arduino ATmegos fusai 2017.03.27 at 07:37

Kol kas neturiu ką įdomaus parašyti, tai rašau tai kas naudinga :). Kažkada labai reikėjo, tai pasidariau lentelę su Arduino UNO fusais. Arduino UNO naudoja ATmega 328P, nors man labiau patinka ATmega 328P-AU, nes mažiukas TQFP-32 korpusas ir turi papildomai du ADC. Programuoju per ICSP, visai naujus čipus, tai prisireikia supūsti ir fuse bitus. Pas ATmegas toks niuansas, truputį prieš žmonišką logiką – jeigu 1 tai išjungta, jeigu 0 tai įjungta. O štai ir lentelė:

Arba jeigu rašoma su eXreme Burner’iu – tuomet galima va taip:

Arduino Uno LCD skydas 2017.01.19 at 14:40

Noriu išmokti saugoti duomenis Atmegos pastovioje atmintyje, kad išjungus ir vėl įjungus nuskaitytų ir veiktų toliau. Tuo pačiu ir pasitreniruosiu „gaminti“ meniu. Pigiausiais sprendimas 0 2×16 LCD skydas iš eBay, kainavo apie 2,5 € su siuntimu. Atvažiavo toks pabraižytas, tai dar uždisputinau su pardavėju.

Kontaktai nesurašyti, bet turėtų būti taip:

Aprašymas toks, vadinamąja, Chinglish kalba:

Features:
This is a basic 16 character by 2 line display.
Utilizes the extremely common HD44780 parallel interface chipset.
Interface code is freely available.
Blue Backlight with white words.
uses 4 Bit Arduino LCD Library.

Size:8cm x 5.9cm - 3.15inch x 2.32inch.

Quantity:1pc
 
LCD Keypad Shield input and output expansion board with 2-line, 16-character LCD with contrast
 adjustment and backlight
Use an analog port will complete five key input, a reset button, the unused spare IO ports
 are extended out, take advantage of IO ports
Occupation digital ports: PIN4 (DB4), 5 (DB5), 6 (DB6), 7 (DB7), 8 (RS), 9 (E), 10 (backlight
 control), analog buttons port A0. Used in conjunction with the Arduino
Module debugging:
1.The LCD Keypad Shield Arduino controller plugged,Then you need to download LCD4Bit_mod.h 
library file to arduino-0015 \ hardware \ libraries in
2.Then compile the following test program will be downloaded to an Arduino in
3.Initial use LCD Keypad Shield, the first observation LCD has no display characters, 
characters may be displayed if there is no contrast is not correct, you can use the 
screwdriver adjust RP1 (clockwise rotation), characters can be transferred to emerge clearly.
Ranging code GP2D12:
#include <LCD4Bit_mod.h> 
LCD4Bit_mod lcd = LCD4Bit_mod(2); 
char GP2D12;
char a,b;
char str1[]="Renge:";
char str2[]=" Renge Over ";
char str3[]="cm"; 
void setup()
{
lcd.init();
lcd.clear();
lcd.printIn("GP2D12 testing..."); 
} 
void loop()
{
GP2D12=read_gp2d12_range(1);
if(GP2D12>80||GP2D12<10)
{
lcd.cursorTo(2,0); 
lcd.printIn(str2); 
}
else
{
a=0x30+GP2D12/10;
b=0x30+GP2D12%10; 
lcd.cursorTo(2, 3); 
lcd.printIn(str1); 
lcd.print(a); 
lcd.print(b);
lcd.printIn(str3); 
} 
delay(50);
}

float read_gp2d12_range(byte pin)
{
int tmp;
tmp = analogRead(pin);
if (tmp < 3)return -1; 
return (6787.0 /((float)tmp - 3.0)) - 4.0;

Reiks bandyt susigaudyt apie ką čia kalba eina :D. Iššifruoju pats sau, kad nepamirščiau ir nereiktų vėl iš naujo galvot:

LCD pajungimas: PIN4 (DB4), 5 (DB5), 6 (DB6), 7 (DB7), 8 (RS), 9 (E), 10 (backlight control)
Mygtukai: A0.

LCD, panašu, pajungtas pagal 4 bitų schemą, gerai, bus galima greitai sumesti programą su LiquidCrystal biblioteka. O mygtukas prijungti prie vieno kontakto… Iš pradžių nusistebėjau, nes nesimatė rezistorių. Paskui radau ir juos ;).

LCD valdomas standartiniu HD44780 valdikliu, taigi, pravers jo aprašymas. Ypač – visokių ne standartinių simbolių „žemėlapis“:

Taigi, norint parašyti kokį nors ypatingesnį simbolį, tarkim juodą stačiakampį █ galima nupaišyti viena eilute – lcd.print(char(255));. Kodėl 255 ? Nes juodojo kvadrato adresas yra 1111 1111 (bin) = 255 (dec). Tas pats galiotų, pavyzdžiui, laipsnio simboliui lcd.print((char)223); – adresas 1101 1111 (bin) = 223 (dec). Galima sukrti ir savo simbolį, jeigu jo nėra lentelėje. Bet apie tai kada nors kitą kartą.

Toliau vat ir bandymas, nuskaitant ADC vertes.


Tai ir matom tokias paspaustų mygtukų ADC reikšmes:

Select – 722
Left – 480
Up – 131 (tuo pačiu dar ir šviesina LCD pašvietimą)
Down – 308 (tuo pačiu dar ir tamsina LCD pašvietimą)
Right – 0
Reset – reikšmės nėra, tiesiog perkrauna uCPU.

Toliau fantazijos reikalas, o šita programėlė štai:

 

#include <LiquidCrystal.h>               //Naudojama biblioteka

// Įėjimai

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);    //Inicializuojami prijungti LCD ekraniuko kontaktai
                                        //LiquidCrystal(rs, enable, d4, d5, d6, d7)
             //PIN4 (DB4), 5 (DB5), 6 (DB6), 7 (DB7), 8 (RS), 9 (E), 10 (backlight control)
const int mygtukai = A0;

// Išėjimai

// Kintamieji

int paspaustas = 0;
int i = 0;

void setup() {
  lcd.begin(16, 2);                     //Inicializuojamas LCD (irgi is bibliotekos default komandu)
  lcd.noCursor();                       // Nustatome, kad kursorius ekrane nebus rodomas
  pinMode(A0, INPUT);                   //Mygtukų įėjimas
  pinMode(10, OUTPUT);                  //Pinas ekrano pašvietimo ryškumui nustatyti (PWM)
  analogWrite(10, 0);                   //*********************************
  for (i = 0; i <= 255; i++) {          //* Užgesinam pašvietimą          *
    analogWrite(10, i);                 //* Nedidelis cikliukas           *
    delay (3);                          //* kad pašvietimas iš lėto       *
  }                                     //* užsidegtų iki pilno galingumo *
}                                       //*********************************

void loop() {
  lcd.setCursor(0, 0);                  //Perjungiam kursorių į pirmą eilutę (0 - stulpelis, 0 - eilutė)
  lcd.print("Mygt. indikacija");        //Pirmos eilutės tekstas

  paspaustas = (analogRead(mygtukai));  //Nuskaitom mygtuko reikšmę iš ADC ir priskiriam kintamajam

  if (paspaustas > 1010) {              //Nieko nepaspaudus ADC reikšmė 1023
    lcd.setCursor(0, 1);                //Antros eilutės adresas
    lcd.print("            ");          //Rašom tuščius simbolius info ištrynimui
  }
  if (paspaustas >= 710 && paspaustas <= 730) {
    lcd.setCursor(0, 1);                //Perjungiam kursorių į antrą eilutę (0 - stulpelis, 1 - eilutė)
    lcd.print (paspaustas);             //Nuskaitom ir rašom į ekraną A0 ADC reikšmę
    lcd.print(" - Select");             //Antros eilutės tekstas
  }
  if (paspaustas >= 470 && paspaustas <= 490) {
    lcd.setCursor(0, 1);                //Perjungiam kursorių į antrą eilutę (0 - stulpelis, 1 - eilutė)
    lcd.print (paspaustas);             //Nuskaitom ir rašom į ekraną A0 ADC reikšmę
    lcd.print(" - Left");               //Antros eilutės tekstas
  }
  if (paspaustas >= 120 && paspaustas <= 140) {
    lcd.setCursor(0, 1);                //Perjungiam kursorių į antrą eilutę (0 - stulpelis, 1 - eilutė)
    lcd.print (paspaustas);             //Nuskaitom ir rašom į ekraną A0 ADC reikšmę
    lcd.print(" - Up");                 //Antros eilutės tekstas
    if (i <= 250) {
      i = i + 1;
      analogWrite(10, i);
    }
  }
  if (paspaustas >= 300 && paspaustas <= 320) {
    lcd.setCursor(0, 1);                //Perjungiam kursorių į antrą eilutę (0 - stulpelis, 1 - eilutė)
    lcd.print (paspaustas);             //Nuskaitom ir rašom į ekraną A0 ADC reikšmę
    lcd.print(" - Down");               //Antros eilutės tekstas
    if (i >= 5) {
      i = i - 1;
      analogWrite(10, i);
    }
  }
  if (paspaustas <= 10) {
    lcd.setCursor(0, 1);                //Perjungiam kursorių į antrą eilutę (0 - stulpelis, 1 - eilutė)
    lcd.print (paspaustas);             //Nuskaitom ir rašom į ekraną A0 ADC reikšmę
    lcd.print(" - Right");              //Antros eilutės tekstas
  }
}

Analoginis laikrodis kitaip 2016.06.16 at 14:47

Pradžia kaip visada paprasta – tai nuo šio tai nuo to vis lieka kokių detalių, tai koks projektukas nepasiteisina ar tampa nebeaktualus ir lieka dar kas nors, tai patestuot veikimą reikia. Taip ir čia – liko vienas ampermetras, keletas RTC schemų, o pratestuoti reikia LMZ23605 iš Texas Instruments (DC-DC maitinimo šaltinis) ir µCPU mažame MLF korpuse. Idėja sugeneruota – sumontuoti viską kaip analoginį laikrodį. Toliau, kaip visada, užduoties sudėtinginimas. Chm, tikrai yra toks žodis ? Gal pasunkinimas :D? Taigi užduotis:

  1. Laikrodis turi rodyti valandas, minutes ir sekundes.
  2. Rodymas turi vykti analoginiuose rodykliniuose indikatoriuose.
  3. Laikas turi būti tikslus, t.y., neskubėti ir neatsilikti, nepriklausomai nuo rodyklinių indikatorių tikslumo.
  4. Maitinimas – pastoviam naudojimui iš 230VAC, laikinam iš baterijos/akumuliatoriaus.
  5. Laikas turi būti skaičiuojamas atjungus maitinimą.

Tai ir einam papunkčiui. Kad laikrodis rodytų valandas, minutes ir sekundes kaip ir natūralu, nors galima apseiti ir be sekundžių. Rodykliniai indikatoriai – paprasti, kinietiško „Hopesun“ PM-2. Lietuvoje juos stumdo „Lemona“. Atrodo va taip vat:

pm2

Nieko labai prašmatnaus, bet ir ne visai blogai. Tinka iš esmės bet koks, bet, kad mažiau būtų skaičiavimo ir vartotų mažiausiai srovės – čiupau DC ampermetrą su 50 µA pilno atlenkimo srove.

Laiko tikslumas yra geras dalykas, idealiu atveju reiktų sinchronizuoti su radio laiko sistema, arba GPS, bet paskui pagalvojau, kad čia būtų šaudymas į žvirblius iš patrankos, nes yra kitas puikus, ganėtinai tikslus ir labai seniai naudojamas būdas laiko skaičiavimui – RTC mikroschemos. Tuo dar išsispręstų ir laiko skaičiavimas atjungus maitinimą. Ankščiau, kitam projektukui (ok, ok, pasakysiu – Nixie laikrodžiui) buvau pasirinkęs DS3231SN mikroschemą, puikios galimybės už mažą kainą ir duomenų siuntimu per I²C, o dar ir moduliukai iš eBay, 5 vnt už kelis €. Atėjo jie jau seniai, tik nebuvo kaip išbandyt.

IMAG0494 IMAG0495

Maitinimas iš išorinio maitinimo blokelio arba baterijų/akumuliatorių, perjungimas turi būti automatiškas, bet tai realizuojama nesunkiai ir matysis schemoje. Taigi, schema:

laikr

Įtariu paveiksliuką norėsis pasididinti :). Pradedam. Maitinimo lizdukas baterijos pajungimui – dviejų kontaktų smeigiamas lizdas, anksčiau buvęs trumpikliu ant kompiuterio motininės plokštės. Šalia, kilmingas Wurth Electronics maitinimo lizdukas. Nu tikrai geras daikčiukas. Jis ir daro automatinį maitinimo nuo baterijos atjungimą. Kol kištukas neįkištas – 2 ir 3 kontaktai susijungę ir perduoda maitinimą iš baterijos lizdo, o kai kištukas įkištas, vietoj baterijos minuso lieka prijungtas kištuko minusas. Toliau, 5V maitinimo šaltinis. Kadangi mūsų prietaisas „srovinis“, t.y. parodymai priklauso nuo srovės, o ji, savo ruožtu, priklauso nuo maitinimo įtampos – čia reiktų stabilaus šaltinio. Arba galima būtų eliminuoti pokyčius programiškai (gal kada nors). Kol kas užtenka LMZ23605TZ arba jo giminaičių. Veikia stabiliai ir dar visokio gėrio pilnas. Toliau – pagrindinis darbinis arkliukas, ATMEGA328P, MLF korpuse, kurį ir norėjau išbandyti. Į kairę nuo Atmegos – perkrovimo (Reset) schema, mygtukas S1, rezistorius R16 ir diodas D6. Paspaudus mygtuką žemas lygis atitinkamame kontakte perkrauna procesorių. Toliau – kontaktai mygtukus, kurį paspaudus rodys temperatūrą (RTC čipas turi sensoriuką). Rezistorius R10 – pulldown’as. Tas pats ir su kalibravimo mygtuku S2. Jį paspaudus procesorius sukomanduoja rodyklėms maksimaliai atsilenkti, taip galima sureguliuoti maksimalaus atsilenkimo padėtį rezistoriais R6, R7 ir R8. Pastovūs rezistoriai R3, R4 ir R5 jau sukuria apie 54,94 µA srovę, o patenciometrais galima ją pakeisti iki 49,50 µA, taigi, turime maksimalaus atlenkimo reguliavimo ribas – 49,50..54,94 µA.

Lyrinis nukrypimas apie skaičiavimus, kadangi galima naudoti praktiškai bet kokius indikatorius, kurių žinoma maksimali atlenkimo srovė. Čia mums padės Omo dėsnis. Taigi, pirmiausia apsisprendžiame, kokia įtampa viskas bus maitinama. Mano atveju ta pačia įtampą valgo ir procesoriukas, taigi, 5V. Tuomet, žinant indikatoriaus maksimalaus atlenkimo srovę galima paskaičiuoti varžą, R[Ω] = U[V] /I[A].

R = 5V / 50 µA = 5V / 0,00005 A = 100000 Ω = 100 kΩ.

Taigi, dar paliekam „vietos“ pareguliavimui ir pasirenkam artimiausias vertes pagal gaminamus standartus.

JP1 – programavimo/diagnostinė jungtis (C6 jai padeda padaryti procesoriaus perkrovimą). Dar toje pusėje yra kontaktas pažymėtas „touch“. Čia turėtų būti jau seniau nagrinėtas talpuminis lietimo sensorius, su jam priklausančiais C1 ir R11. Pagal idėją, palietus turėtų uždegti rodyklinių indikatorių pašvietimą, tam panaudojant tris (arba vieną, o kiti darytų ką nors kitą) atskirus tranzistorius Q1, Q2 ir Q6 (be srovės ribojimo !). Ir paskutinė detalė – RTC schema, iš kurios nuskaitom laiką.

PCB, kaip visada, pagaminta pas kinus, iš seeedstudio.com ir atrodo va taip:

IMAG0492 IMAG0493

Jei kam reikia plikų PCB, kreipkitės, turiu dar 5 vnt. Sukompiliuotą failiuką įdėsiu straipsnelio pabaigoje, kartu su schema.

Originali ampermetrų skalė netinkama, bet po svaičiojimų apie naujos skalės gamybą lazeriuojant, šilkografuojant ir bandant pagaminti dar keletu mazochistinių būdų, nuėjau lengviausiu keliu – užsakiau pagaminti lipdukus su man tinkama skale. Ją pasibraižiau su AutoCADu, nors skalėms iš tikrųjų yra specializuotas softas.

IMAG0496

Toliau sudėtingiausia dalis – korpusas. Iš pradžių galvojau padaryti tokį „old school“ vaizdelį, montuojant visą elektroniką į seną, rusišką, ebonitinį korpusą, gal net su kokiom rankenėlėm ar užrašais, pavyzdžiui:

1866548583

Bet tokios dėžutės neturiu, o laikas eina… Šiaip, aišku aš neskubu, tai nusitempė tie korpuso parinkimai tikrai ilgam laikui, tuo labiau, kad darbiniai projektai visokie visą laiką suvalgo. Bet darbiniai projektai man pasufleriavo ir sprendimą – korpusą iš aliuminio kompozito. Sumontavimas toks truputį sunkokas, bet neskubant viskas sutilpo ir rezultatas gavosi toks:

Toliau – skalės apšvietimas. Čia jau teko paprasčiausiai priklijuoti SMD LEDus (OSM5DLS1C1A). Vaizdas štai toks:

IMAG0532 IMAG0533

Bandymai parodė, kad pašvietimas gražus ir tolygus. Spalva – šiltai balta. O štai kaip tai atrodo (dieną, maksimalus šviesumas):

IMAG0542

Darbinė srovė be apšvietimo prie 9,302V – 26,16 mA (0,2433 W), su apšvietimu 94,00 mA prie 8,95V (0,8413 W). Ir trumpas video kaip viskas veikia:

Čia yra viskas, ko reikia Eagle ir AutoCAD brėžiniai. Programa gali būti developinama, tai naujausią sukompiliuotą HEXą čia rasite atskirai.

Programos versija – V1:

  • Laikas nuskaitomas iš RTC ir parodomas indikatorių skalėse.
  • Paspaudus mygtuką (užtrumpinus SV4, bet mygtuko nedėjau) – minučių indikatoriuje būtų rodoma RTC temperatūra.
  • Jautrus lietimui korpusas, palietus lėtai uždegami pašvietimo LEDai, laikomi įjungti kol liečiamas korpusas, ir lėtai užgesinami nebeliečiant korpuso.
  • Visų trijų indikatorių LEDai (6 vnt.) valdomi trimis atskirais kanalais

Tolimesnių tobulinimų idėjos:

  • Žadintuvas, taimeris arba priminimas su garsu.
  • Mygtukai laiko nustatymui ir pirmo punkto sureguliavimui.
  • Praplėsti maksimalaus atlenkimo reguliavimo ribą (45-60 μA). Šiaip nebūtina, bet vienam iš 6 ampermetrų prisireikė daugiau srovės pilnam atlenkimui. Daugiau gal tokio užsispyrusio ir nepasitaikys…
  • RGB LEDai (tam ir turim tris kanalus valdymui)

Arduino ir talpuminis lietimo sensorius 2016.02.10 at 14:07

Vienam iš projektų reikia padaryti pašvietimą. Bet paprastai uždegti LEDą ar lemputę neįdomu. Taigi, užduotis tokia – palietus prietaiso metalinį korpusą (nesujungtas su GND), apšvietimas turi lėtai užsidegti, degti kol liečiamas korpusas ir lėtai užgesti kai jau neliečiamas. Su Capacitive Sensor V5 pagalba tas padaroma labai paprastai, tik pakoreguojant kodą pagal savo poreikius:

 

#include <CapacitiveSensor.h>

// Išėjimai

const int led = 3;                                      // LED išęjimas, 3 kontaktas, mokantis PWMinti.

int i = 0;                                              // Įsivedam vieną kntamąjį
CapacitiveSensor   sensorius = CapacitiveSensor(4, 2);  // Rezistorius tarp 4 ir 2 kontaktų, 2 sensorinis

void setup()
{
  pinMode (led, OUTPUT);                             // Nustatom 3 kontaktą kaip išėjimą
  digitalWrite (led, LOW);                           // Inicializuojam LEDą
  sensorius.set_CS_AutocaL_Millis(0xFFFFFFFF);       // Autokalibracijos išjungimas
}

void loop()
{
  long laikas =  sensorius.capacitiveSensor(60);     // Matavimų skaičius vidurkio skaičiavimui
  if (laikas > 600)                                  // Jeigu paskaičiuotas vidurkis daugiau 600 ms
  {
    while (i < 255)                                  // ************************
    {                                                // * Kai vidurkis daugiau *
      analogWrite (led, i);                          // * 600 ms lėtai uždega  *
      i++;                                           // * LEDą ir laiko, kol   *
      delay (8);                                     // * liečiamas sensorius  *
    }                                                // ************************
  }
  else
  {
    while (i >= 0)                                   // ************************
    {                                                // * Atvirščias procesas, *
    analogWrite (led, i);                            // * kai laikas < 200,    *
    i--;                                             // * lėtai užgesina LEDą  *
    delay (8);                                       // ************************
    }
    i = 0;                                           // Įnulinam kintamąjį, nes kitaip atsiranda
  }                                                  // neteisingas LED mirktelėjimas
}
O štai ir video:

Arduino ir 7 segmentų LED indikatorius 2015.11.25 at 11:56

Pats LED indikatorius ELF-512GWA išluptas seniai, iš kažkokio šroto, net pats nepamenu. Toks, nei panaudot, nei išmest, tai sugalvojau prijungt prie Arduino. Schema labai paprasta, bendri anodai/katodai prie A1, A2, A3 ir A4 (čia keturių skaičių indikatorius). O 7 segmentai prie 2, 3, 4, 5, 6, 7, 8, 9. Visa esmė čia programoje. Internete labai daug pavyzdžių, gerų ir nelabai. Pabandžiau keletą bibliotekų ir labiausiai patiko PrintTo7Seg. Programėlė:

#include "PrintTo7Seg.h"
// Įėjimai

//Išėjimai

byte numOfDigits = 4;                             // Kelių skaičių indikatorius
byte digPins[] = {A1, A2, A3, A4 };               // Bendri kontaktai (anodas arba katodas)
// segmentPins = Dp, A, B, C, D, E, F, G          // Segmentų pinų map'as
byte ledPins[] = {7, 8, 9, 2, 3, 4, 5, 6};        // Segmentų pajungimas

// Nustatymai

PrintTo7Seg Seg7(numOfDigits, digPins, ledPins, COMMON_CATHODE);  // Arba anodas, pagal indikatorių


void setup() { 
  Seg7.autoscroll();                               // Atomatinis kursoriaus pastūmimas
}                                                  // čia reikalingas, nes rašyti pradedu į
                                                   // paskutinį (4) LED indikatorių
void loop() {
  for (int skaicius = 0; skaicius <= 9999; skaicius++)
  {
  Seg7.clear();                                    // Išvalom seną informaciją
  Seg7.setCursor(3);                               // Nustatom kursorių į 4 indikatorių (0, 1, 2, 3)
  Seg7.print(skaicius);                            // Rašom einamąjį skaičių
  delay(10);                                       // Trumpa pauzė
  }
}

Dar papildomai yra keletas komandų:

setLed(location, led, state);
setDot(location, state);
setDigit(location, data);
getDigit(location);
setCursor(location);
autoscroll(void);
noAutoscroll(void);
clear(void);
home(void);
scrollDisplayLeft(void);
scrollDisplayRight(void);
Print();

DS18B20 prijungimas prie Arduino 2015.11.16 at 17:54

Taip taip, dedikuotas straipsnis kolegai Mindaugui. Trumpai apie davikli, tai – ankščiau buvusio Dallas Semiconductor o dabar Maxim Integrated sensoriukas DS18B20, mūsų atveju kukliam TO-92 korpuse. Beje, aprašymas vienas iš detaliausių kada nors mano matytų. Pajungimo schema paprasta, viskas taip, kaip parodyta aprašyme:

Programoje naudojamos dvi bibliotekos:

#include <OneWire.h>
#include <DallasTemperature.h>

Pirmoji yra čia, o antroji yra čia.

O čia vat ir programėlė, rašanti temperatūrą:

 

#include <OneWire.h>
#include <DallasTemperature.h>
// Įėjimai

OneWire pinas(2);           // Nustatom, kad duomenys vaikščios antru pinu

// Išėjimai



// Nustatymai

DallasTemperature sensoriai(&pinas); // Perduodam pino duomenis DallasT bibliotekai

void setup(void)
{
  Serial.begin(9600);
  sensoriai.begin();
}

void loop(void)

{
  sensoriai.requestTemperatures();                // Komanda, temperatūrų užklausimui
  Serial.println("Daviklio temperatura");
  Serial.print(sensoriai.getTempCByIndex(0));     // Daviklio temperatūra C
  Serial.println(" C");
  Serial.print(sensoriai.getTempFByIndex(0));     // Daviklio temperatūra F
  Serial.println(" F");
  Serial.print(sensoriai.getResolution());        // Gaunama daviklio rezoliucija (9, 10, 11, 12)
  Serial.println(" bit rezoliucija");             // temperaturos zingsniai 0.5°C, 0.25°C, 0.125°C ir 0.0625°C
  Serial.print(sensoriai.getDeviceCount(), DEC);  // Davikliu kiekis, dešimtainiu formatu
  Serial.println(" daviklis /-u");
  Serial.println(" ");
  delay (1000);
}


RGB LED valdymas trim potenciometrais 2015.11.12 at 18:08

Labai nesudėtinga programėlė, gavosi labai trumpa, nes norėjau prasisukti su kuo mažiau teksto, prisioptimizavau tiek, kad net jokio kintamojo nereikia :).

 

// Iejimai

const int raudonas_pot = A0;          // ********************************
const int zalias_pot = A1;            // * Nustatom potenciometru pinus *
const int melynas_pot = A2;           // ********************************

// Isejimai

const int raudonas_led = 3;           // ********************************
const int zalias_led = 5;             // * Nustatom PWM isejimus LEDams *
const int melynas_led = 6;            // ********************************

void setup() {
  pinMode (raudonas_led, OUTPUT);     // ***************************************
  pinMode (zalias_led, OUTPUT);       // * Nustatom, kad LEDu pinai - isejimai *
  pinMode (melynas_led, OUTPUT);      // ***************************************
  digitalWrite (raudonas_led, HIGH);  // ***************************************
  digitalWrite (zalias_led, HIGH);    // * Inicializuojam LEDus (isjungiam)    *
  digitalWrite (melynas_led, HIGH);   // ***************************************
}

void loop() {

  analogWrite (raudonas_led, map (analogRead (raudonas_pot), 0, 1023, 0, 255));
  analogWrite (zalias_led, map (analogRead (zalias_pot), 0, 1023, 0, 255));
  analogWrite (melynas_led, map (analogRead (melynas_pot), 0, 1023, 0, 255));
}

Pačios programos gavosi tik trys eilutės, po vieną kiekvienam LEDui. Logika tokia – rašom (analorWrite) į atitinkamo LEDo išėjimą (pvz, raudonas_led) reikšmę, kuri gaunama „pavertus“ (map)  nuskaitytą potenciometro vertę (analogRead (raudonas_pot)) į vertes nuo 0 iki 255 (0, 1023, 0, 255). Šito map’inimo reikia todėl, kad nuskaityto potenciometro reikšmės kinta nuo 0 iki 1023, o išėjimo PWM’as valdomas vertėm nuo 0 iki 255 (8 bitų PWM). Taigi, nenuMAPinus persipildys skaitliukas, ir nuo 0 iki 255 viskas bus OK, nuo 256 iki 512 (ir 513 – 768, ir 768 – 1023) vėl elgsis taip, lyg būtų nuo 0 iki 255, tai sukant potenciometrą bus net 4 zonos, kur LEDas nuo tamsaus keisis į maksimaliai degantį. Dar toks niuansas – Arduino Due ir Zero su defaultiniu 8 bitų PWMu gali būti nustatytas dirbti aukštesne 12 bitų rezoliucija, ir dirbti su reikšmėm nuo 0 iki 4095 (komanda analogWriteResolution(12)).

Ir trumpas video:

Patobulinimas – naudoti skaitmeninius potenciometrus, o ne tokius, analoginius/varžinius. Mano atveju RGB LEDas buvo su bendru anodu, jeigu kartais tektų pakeistį į LED su bendru katodu – truputį keičiasi ir programa. Iš esmės užtektų pakeisti tik čia:

digitalWrite (raudonas_led, LOW);
digitalWrite (zalias_led, LOW);
digitalWrite (melynas_led, LOW);

Stroboskopinis ir dimerinis mirksiukas 2015.10.28 at 10:58

Toks trumpas straipsniukas, atsiradęs dėl to, kad kolega užsimanė pamirksinti LEDus taip, kaip mirksi specialiųjų tarnybų stroboskopiniai mirksiukai (tipo police strobe). Pats greičiausias būdas – jamam Arduino Uno ir nesunkiai parašom tokią programėlę. Berašydamas, kaip visada sugalvojau patobulinti galutinį variantą ir finale turim ir stroboskopinį ir dimeruojantį variantą. Programėlė:

// Kintamieji:

int x = 0;
const int mirksejimo_kiekis = 10;
const int mirksejimo_trukme = 20;
const int laikas_tarp_pusiu = 150;
int sviesumas = 0;
int pokytis = 1;

// Isejimo pinai:

const int raudonas_led = 9;
const int melynas_led = 10;

// Iejimu pinai:

const int mygtukas = A0;

// Programa, keisti reiktu tik virsuje

void setup() {
  pinMode(raudonas_led, OUTPUT);
  pinMode(melynas_led, OUTPUT);
  pinMode(mygtukas, INPUT);
}
void loop() {
  if (digitalRead(mygtukas) == HIGH)
  {
    mirksejimas();
  }
  else
  {
    dimeris();
  }
}
//-------------------- Mirksejimo programele ------------------------
int mirksejimas() {
  for (x = 0; x <= mirksejimo_kiekis; x++)
  {
    analogWrite(raudonas_led, HIGH);
    delay(mirksejimo_trukme);
    analogWrite(raudonas_led, LOW);
    delay(mirksejimo_trukme);
  }
  delay (laikas_tarp_pusiu);
  for (x = 0; x <= mirksejimo_kiekis; x++)
  {
    analogWrite(melynas_led, HIGH);
    delay(mirksejimo_trukme);
    analogWrite(melynas_led, LOW);
    delay(mirksejimo_trukme);
  }
  delay (laikas_tarp_pusiu);
}
//-------------------- Dimeriavimo programele ------------------------
int dimeris() {
   analogWrite(raudonas_led, sviesumas);
   analogWrite(melynas_led, -sviesumas);
   sviesumas = sviesumas + pokytis;
   if (sviesumas == 0 || sviesumas == 255) {
     pokytis = -pokytis ;
   }
   delay(2);
}

Viskas čia paprasta, plius įdėjau ir keletą komentarų, bet visgi jei bus klausimų – prašom, komentaruose bandysiu atsakyti. Mėlynas ir raudonas 1W galios LEDai jau važiuoja, taigi, ne už ilgo turėtų būti ir veikimo video :).

2015.11.03

štai ir video… Nors stroboskopo efektas nelabai gražiai įsirašė:

 

Arduino 2 laidų LCD skydas 2015.03.30 at 14:06

Angliškai tas dalykas vadintųsi Arduino two wire LCD shield. Šitas truputį geresnis už tą, siūlomą Internete – vietoj paprasto diodo su varža čia įmontavau tikrą IR loginį elementą, bet naudoja tą pačią ShiftRegLCD123 biblioteką. Viskas veikia, raudonas LED rodo, kad yra maitinimas. Visi pinai „perkelti“ specialiom šukom ir gali būti naudojami taip, lyg jungimas būtų tiesiai prie Arduino. Išskyrus 7 ir 8 piną – šitie panaudoti duomenų šėrimui į LCD skydą. Kol dar turiu PCB, kam patinka – plika PCB 6 €, surinkta 25 €, neskaitant siuntimo išlaidų (PCB Kaune). Keletas paveiksliukų:

IMAG1467IMAG1470IMAG1471IMAG1472IMAG1473IMAG1474IMAG1475IMAG1476IMAG1477IMAG1478IMAG1479PCB yra čia, o programa labai paprasta, tik parodyti, kad šitas stebuklas veikia:

 

#include <ShiftRegLCD123.h>

long int laikas = 0;       // Laiko kintamasis
const int dataPin  = 8;    // Data signalas iš Arduino 8 kontakto
const int clockPin = 7;    // Clock signalas iš Arduino 7 kontakto


ShiftRegLCD123 lcd(dataPin, clockPin, SRLCD123);

void setup()
{
  pinMode(13, OUTPUT);        // Inicializiejam 13 kontaktą LEDo uždegimui
  lcd.begin(16,2);            // Inicializuojam LCD ekraną (16x2 konfigūracija)
  lcd.noCursor();             // Nustatome, kad kursorius ekrane nebus rodomas
}

void loop()
{
  laikas = millis()/1000;            // skaiciuojam laiką nuo starto
  lcd.print("Laikas nuo strt:");     // parašom teksta

  lcd.setCursor (0,1);               // Nustatom kursorių į antros eilutės 1 langelį
  lcd.print (laikas);                // Rašom tekstą
  lcd.setCursor (7,1);               // Nustatom kursorių į antros eilutės 7 langelį (pirmas būtų 0)
  lcd.print("sekundziu");            // parašom teksta
  digitalWrite(13, HIGH);            // uždegam LEDą
  delay (500);                       // Laukiam 500 ms, kad pamatyti tekstą ekrane
  digitalWrite(13, LOW);             // Gesinam LEDą
  lcd.clear ();                      // Išvalom ekraną kiekvieno LOOP ciklo pabaigoje
}