HobbyElectro

Petrescu Cristian . Un produs Blogger.

luni, 26 decembrie 2016

OHMMETRU CU ARDUINO SI ADC ADS 1115

0 comentarii | Read more...
Salutare tuturor !


     Iata ca printre toate problemele pe care le-am avut in ultima parte a acestui an am gasit ragazul sa mai adaug un articol pe blog. Urmatoarul proiect izvoraste mai mult dintr-o necesitate aparuta la locul de munca. 
    Asadar ohmmetrul prezentat in cele urmeaza va fi folosit pentru testarea la rece a unor tablouri electrice utilizate in cadrul automatizarilor navale. Bineinteles ca va veti intreba (si asta pe buna dreptate) de ce nu este protivita utlizarea unui ohmmetru obisnuit. Raspunsul este simplu: datorita numarului mare de conexiuni care trebuie testate nu este timp pentru a citi de fiecare data indicatia instrumentului de masura, asa ca beeper-ul este cel care dicteaza corectitudinea unui traseu. Aparatul de masura "piuie" pentru o rezistenta in intrvalul 0-100 ohmi. Cum avem componente a caror impedanta de intrare este de ordinul zecilor de ohmi, uneori se poate ca "piuitul" sa nu indice corect continuitatea unui traseu.

Ce a iesit se poate vedea mai jos:













////



Schema electrica...

Pentru proiectul in cauza am decis sa utilizez un Arduino Uno (ma rog o clona...) si 2 componente cheie:
  • LM317 - ca  generator de curent constant;
  • ADS 1115 - convertor analog digital cu interafata I2C.
Mai jos se poate vedea schema electrica:


Am decis sa folosesc doua domenii de masura : 0-100 ohmi si 100-1M. Selectia domeniilor se face cu ajutorul comutatorlui dublu SW1, iar conectarea in circuit a rezistentei ce e doresete a fi masurata se face prin intermediul conectorului J6. Functonarea va fi prezentata in randurile de mai jos:
  • Cand SW1 este in prima pozitie, se utilizeaza primul domeniu de masura. LM317 este alimentat la 5V si datorita configuratiei de generator de curent constant va incerca sa debiteze aproximativ 12.5 mA (1.25V cadere de tensiune constanta pe R1). Intrarea anologica A0 a lui ADS1115 citeste caderea ce tensiune pe rezistenta necunoscuta iar A1 citeste tensiunea pe care o da la iesire LM-ul. In urma catorva calcule simple (legea divizorului de tensiune) se determina rezistenta necunoscuta.
  • Cand SW2 este in cea de-a doua pozitie se alimenteaza cu 5V rezistorul R2 (10k). Intrarea analogica A2 a lui ADS1115 citeste tensiunea de alimentare (NU ESTE 5V FIX - NICIODATA!!!)  iar A0 citeste caderea de tensiune pe rezistenta necunoscuta. Si in acest caz se utilizeaza legea divizorului de tensiune pentru determiarea rezistorului necunoscut.
  • In colectorul tranzistorului Q1 se conecteaza un buzzer care va "piui" numai daca rezistenta este mai mica de 3 ohmi.
  • Afisarea datelor este facuta pe un LCD cu doua randuri si 16 coloane care utilizeaza o iterfata I2C. Daca timp de 15 secunde nu se face nici o citire atunci backlight-ul LCD-ului se va inchide automat, pentru economisirea bateriei.
De ce nu am utlizat ADC-ul lui Arduino?

Adc-ul pe care il ofera Arduino este bun numai pentru estimari aproximative. In general nu este stabil pentru tensiunea de referinta nu este stabila. Daca nu ma credeti masurati... Tensiunea de 5V variaza in limite destul de mari ceea ce face imposibila determinarea cu exactitate a cuantei. Este mult de discutat vis-a-vis de acest subiect foarte interesat si poate o data va face obiectul unui articol.

Incepand cu acest proiect am decis sa "imi produc" singur shieldurile pentru Arduino. Cablajul este prezentat in imaginea de mai jos:

Bineinteles ca LCD-ul si comutatorul dublu cu doua pozitii vor fi montate pe carcasa.

Codul pentru Arduino...

In mare nu este ceva foarte complicat. Nu am facut altceva decat sa transpun in cod legea divizorului de tensiune:


  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
#include <Wire.h>
#include <Adafruit_ADS1015.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2); 

Adafruit_ADS1115 ads(0x48);

unsigned long t;
boolean check=true;
byte ohm[] = {
  B00000,
  B01110,
  B10001,
  B10001,
  B01010,
  B01010,
  B11011,
  B00000
};
String empty="                "; 
float Vo = 0.0;//voltage in
float Vref = 0.0;//voltage drop on unknown resitor
int domain = 7; //digitalRead() of domain
int buzz=9;// buzzer 
float crt;// current flowing through resitor
float res; //unknown resitor
String sres; //string casting of unknown reistor
String s; // string of domain

void setup(void)
{
  pinMode(buzz, OUTPUT);
  pinMode(domain, INPUT);
  Serial.begin(9600);
  ads.begin();
  lcd.init();
  lcd.createChar(0, ohm);
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("DIGITAL OHMMETER");
  lcd.setCursor(2,1);
  lcd.print("hobbyelectro");
  delay(2000);
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Firmware 1.0");
  lcd.setCursor(2,1);
  
  
}
boolean getDomain() {
  if (digitalRead(domain)) {
    return true;
  }
  return false;
}
void printData() {
  /*Serial.print("DOMENIU-->");
  Serial.print(s);
  Serial.print("\tVo: ");
  Serial.print(Vo, 9);
  Serial.print("\tVref: ");
  Serial.print(Vref, 9);
  Serial.print("\tCurrent: ");
  Serial.print(crt, 9);
  Serial.print("\t");
  Serial.print("\tResistor: ");
  Serial.println(sres);*/
}

void printLcd(){
  lcd.backlight();
  lcd.setCursor(0,0);
  String data=s+" "+"R="+sres;
  lcd.print(data);
  int len =data.length();
  lcd.setCursor(len,0);
  lcd.write(byte(0));
  lcd.setCursor(len+1,0);
  lcd.print(empty);
  lcd.setCursor(0,1);
  String v="Vo="+String(Vo)+"V"+" "+"Vd="+String(Vref)+"V"+empty;
  lcd.print(v);
  check=true;
  t=millis();
  }

void lcdOut(){
  //lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Out of range..."+empty);
  lcd.setCursor(0,1);
  lcd.print(empty);
  }

void checkData(boolean d) {
  if(res<1.00){
    sres="0.00";
    }
  if (d) {
    if (res < 120) {
      printData();
      printLcd();
      if(res<3.00){
        analogWrite(buzz,1);
        delay(100);
        analogWrite(buzz,5);
        delay(100);
        analogWrite(buzz,20);
        delay(100);
        analogWrite(buzz,5);
        delay(100);
        analogWrite(buzz,1);
        delay(100);
        analogWrite(buzz,0);
        }
    }
    else {
      Serial.println("OUT OF RANGE ...");
      lcdOut();
    }
  }
  else {
    if (res>120 && res < 1000000) {
      printData();
      printLcd();
    }
    else {
      Serial.println("OUT OF RANGE ...");
      lcdOut();
    }
  }
}

void getResistor() {
  int16_t adc0 = ads.readADC_SingleEnded(0); //get adc for voltage drop on unknown resitor
  Vref = (adc0 * 0.1875) / 1000;
  int16_t adc1;//get adc for supply voltage from LM317
  int16_t adc2;//get adc for supply voltage for 10k resistor
  int16_t divider;
  delay(50);
  boolean d = getDomain();
  if (d) {
    adc1 = ads.readADC_SingleEnded(1);
    delay(50);
    Vo = (adc1 * 0.1875) / 1000;
    divider = 100.5;
    s = "D1 ";
  }
  else {
    adc2 = ads.readADC_SingleEnded(2);
    delay(50);
    Vo = (adc2 * 0.1875) / 1000;
    divider = 10000;
    s = "D2 ";
  }
  if (Vo > Vref) {
    crt = (Vo - Vref) / divider;
    res = abs((Vref / crt) - 0.3);
    if (res > 999) {
      sres = String(res / 1000) + "k";
    }
    else {
      sres = String(res);
    }
    checkData(d);
  }
  else {
    Serial.println("OUT OF RANGE...");
    lcdOut();
  }
}

void loop(void)
{
  if(check){
    t=millis();
    check=false;
    }
  getResistor();
  if((millis()-t)>15000){
    lcd.clear();
    lcd.noBacklight();
    }
  delay(1000);
}


Cam atat pentru articolul de azi.

Cum sfarsitul de an se apropie, va urez pentru 2017 sanatate, bucurii si la cat mai multe proiecte de electronica finalizate!

Sa auzim de bine!


luni, 3 octombrie 2016

Server senzori cu NodeMcu

0 comentarii | Read more...

Salutare tuturor!

La rugamintea unui prieten (Salut Silviu !) am decis sa ma reintorc, pret de un articol, la NodeMcu. 
Dupa cum bine stiti nu sunt cel mai mare fan al acstui controller insa, uneori, pentru aplicatii simple care nu necesita un numar mare de clienti "jucaria" poate oferi rezultate mai mult decat multumitoare.

Pentru toate celelalte exista Raspberry Pi :)

Asadar, s-a dorit un sistem care sa permita manipularea iesirilor digitale, capabil sa citeasca starea unor senzori si care sa afiseze datele intr-o interfata prietenoasa in browser.

Ce a iesit se poate vedea in clipul de mai jos:



Pagina HTML...

Pentru ca mi s-a deschis apetitul de JQuery, nu veti gasi prea mult cod html in pagina. Am vrut ca pagina sa poate fi modificata usor, pentru a putea servi necesitatilor in functie de fiecare caz in parte.
Nu voi zabovi prea mult in a explica cum functioneaza ci mai mult in a explica cum se utilizeaza:




Dupa cum se vede in poza de mai sus, au fost definite doua variabile: dateOutput si dateSenzori.
Variabila dateOutput este responsabila pentru generarea tabelului care contine iesirile digitale, iar variabila dateSenzori este responsabila pentru generarea tabelului care contine starea senzorilor.

Tot ce trebuie facut pentru a crea o aplicatie particulara este modificarea parametrilor subliniati. Atat!
Mai jos se poate vedea cum arata pagina html generata cu datele din figura anterioara: 




Pentru transmiterea datelor catre server am folosit Ajax. Requestul trimis catre server arata in felul urmator:


Programul rezident in NodeMcu va analiza requestul si va actiona in consecinta. Nimic iesit in comun. Poate doar pentru requestul care schimba starea unui buton? Sa vedem ce reprezinta fiecare sir de caractere din request:

GET /change?change=btn_out_0*tabControl*0*.

  1. change - ii "spune" lui NodeMcu ca se doreste schimbarea starii unui buton;
  2. btn_out_0 - id-ul butonului;
  3. tabControl - numele tabelului din care face parte butonul;
  4. 0 - numarul de ordine al butonului din tabel;
  5. * - separator intre date pentru a putea fi manipulate cu usurinta de NodeMcu.
NodeMcu...


Ca de obicei codul html se incarca in SPIFFS (ce este si cu ce se mananca gasiti in articolele anteriorare dedicate lui NodeMcu). In rest nimic special: in functie de request este apelata functia dedicata.

Pentru exemplificare s-a folosit un senzor de temperatura DS18B20, doua switch-uri - pentru a simula intrairile digitale, si un potentiometru - pentru a citi o valoare analogica.



Ca de obicei codul sursa se poate descarca de aici.

Sa auzim de bine ! 

PS:
Pentru orice nelamurire, ma puteti contacta !

duminică, 18 septembrie 2016

Monitorizare parametrii computer cu Arduino

0 comentarii | Read more...
Salutare prieteni!

Dupa o vara lunga si incarcata, iata ca am gasit ragazul sa public un nou proiect. 

     Ceea ce va voi prezenta in continuare are la baza "un pitic" rezident in materia cenusie care ma tot indemna sa monitorizez cumva parametrii PC-ului. 

Prin parametrii ise inteleg: 

  • date despre procesor (grad de incarcare si temperatura);
  • date despre RAM (procent ocupat, memorie libera/ocupata);
  • date despre placa video (temperatura, turatie ventilator);
  • date despre HDD (temperatura).
   Cum piticul devenise din ce in ce mai insistent m-am gandit sa pun un pic mintea la treaba si sa realizez proiectul  a carui functionare se poate vedea mai jos:



   Nu voi intra in prea multe detalii tehnice, insa merita sa zabovim putin asupra modului de functionare. 

     In esenta se utilizeaza programul OpenHardwareMonitor care, pe langa multele lucruri bune pe care le face, are bunul obicei sa creeze un fisier csv in care salveaza parametrii de functionare ai pc-ului. Acum daca tot am primit mura in gura fisierul m-am gandit sa-l exploatez putin cu Python, adica sa citesc ce scrie OHM in el, dupa care sa trimit datele prin portul serial catre Arduino. Adaugand un LCD (pe I2C - sunt satul de fire) se pot citii in timp real parametrii pc-ului.











     Pentru cei interesati de codul sursa, ca de obicei se poate descarca de aici

Sa auzim e bine !

marți, 28 iunie 2016

WEB SERVER CU PYTHON SI ARDUINO - DIGITAL IN/OUT

0 comentarii | Read more...
Preambul...

     Daca in articolul anterior am vazut cum se poate realiza conexiunea intre un server Flask si Arduino, propun ca in articolul de  astazi sa ridicam un pic stacheta si sa vedem cum se pot manipula intrarile/iesirile lui Arduino.

     Ca si data trecuta intregul sistem se compune din : 
  • partea de interfata grafica (jQuery, HTML, Javascript, CSS), 
  • partea de comanda (Python cu server Flask) ,
  • partea periferica - Arduino.
Nota: se vor utiliza aceleasi librari ca si in articolul precedent. Codurile pentru server si Arduino se pot descarca de aici.

Ce a iesit se poate vedea in clipul de mai jos.



Sistemul...

     Intregul proiect a fost gandit initial pentru Raspberry Pi (ii vine si lui randul) insa pe parcurs am desoperit Flask-ul si l-am adaptat pentru Arduino. In esenta avem un ULN 2003 ca driver pentru leduri si relee, si un micro switch cu rezistente "pull -up" ca simulator pentru intrari:




    Ceea ce am adus nou este o librarie scrisa in Javascript cu ajutorul careia se pot modifica foarte simplu (vezi in filmulet) atat numarul de intrari cat si cel de iesiri.


Din lipsa de timp nu voi detalia prea mult proiectul in cadrul acestui articol. Pentru cei interesati pot oferi mai multe detalii pe facebook sau ca raspuns la comentariile voastre.

Sa auzim de bine !

duminică, 12 iunie 2016

Server de temperatura cu Python si Arduino

1 comentarii | Read more...
Pentru inceput...

     Daca in articolul trecut ne-am familiarizat cu capabilitatile NodeMcu-ului in cele ce urmeaza voi incerca sa prezint o noua abordare a modului de integrare in Internet of Things (IOT). 

     Desi NodeMcu ofera o oarecare libertate si simplitate in proiecatrea sistemelor integrate in IOT, datorita limitarilor impuse de catre arhitectura,  posibilitatile de dezvoltare sunt relativ reduse. 
     Se poate considera, de exemplu, cazul in care serverul (NodeMcu) ar trebui sa trimita clientului niste fotografii, sau niste scripturi mai complexe. In fiecare din cele doua cazuri enumerate mai sus sunt necesare  artificii suplimentare: gazduirea fotografiilor pe un server extern sau lucrul cu memoria ROM a controller-ului. In plus numarul de conexiuni (clienti) este realtiv  limitat.

     Avand in vedere cele enumerate mai sus, am inceput sa ma gandesc la un sistem in care controller-ul sa fie comadat de catre computer si care  totodata sa joace  si  rolul de  web-server. Tot scotocind am descoperit Python-ul, un limbaj de programare interpretat, usor de invatat si de utilizat,  cu o groaza de librarii printre care si "Flask" - un excelent server web. 
  Cu problema serverului odata rezolvata, mai ramane doar problema comunicatiei seriale cu Arduino. Si aici popularitatea Python-ului si-a spus cuvantul, deoarece fara prea mare dificultate am gasit libraria "pySerial", exact ce trebuie pentru a stabilii conexiunea cu Arduino.
    Cu un pic de HTML si jQuery si utilizand ca senzor "batranul" DS18B20 am injghebat un mic server de temperatura:
   


Toate puse cap la cap...

     Pentru oricine este interesat de realizarea practica a acestui proiect pasii de urmat sunt urmatorii:

  1. Se instaleaza Python 3 un bun ghid de instalare pentru Windows se poate gasi aici. Va recomand sa instalati limbajul e programare intr-un loc cat mai usor de accesat cu putiinta, de exemplu "C:\Pyhton3";
  2. Se instaleaza rand pe rand urmatoarele librarii: FlaskpySerial, colorama, termocolor;
  3. Deoarece instalarea librariilor in Python poate da unui incepator destule batai de cap va propun o alterantiva de instalare mai simpla, utilizand PIP (un manager care instaleaza automat  pachete si librarii pentru Python). Daca ati instalat Python3, atunci acest manager este deja disponibil. Tot ceea ce trebuie sa faceti este sa navigati pana in folderul in care ati instalat Python3 sa dati click pe bara de adrese (cea care contine locatia in care va aflati) si sa copiati adresa locatiei. Deschideti o noua fereastra "CMD", tastati "cd" urmat de spatiu, click dreapta alegeti "Paste" dupa care tastati "Enter". Din acest moment tot ce aveti de facut este sa tastati "pip3 install" urmat de numele librariei dorite. In cazul meu Flask era deja instalat, in cazul vostru libraria se va instala fara prea mari dureri de cap.                                                                                                                                                                    

     
     
  4. Se descarca arhiva cu codul sursa de aici.

Cum functioneaza...

    Simplu :) . Pe langa libraria ce serveste comunicatiei seriale am scris o clasa care ajuta la conectarea cu Arduino. Aceasta clasa se gaseste in fisierul arduinoSerial.py si  este apelata inainte de prima conectare a clientului la server:


Cand clientul incearca sa se conecteze in fereastra deschisa de server va trebui introdus numarul portului la care este conectat Arduino. In cazul meu portul este 7. Serverul se va conecta la Arduino iar clientul isi va primi pagina:


     Pagina este "relativ" simpla. Practic sunt prezentate 3 indicatoare analogice, unul cu minimul temperaturii inregistrate, altul cu temperatura curenta si in fine cel de-al treilea cu temperatura maxima inregistrata de-a lungul masuratorilor. Pentru reprezentarea indicatoarelor a fost utilizata libraria pentru javascript "justGage".

     Cheia intregului sistem este codul pentru server:




  
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import arduinoSerial
import time
import atexit
from flask import Flask,request, redirect, url_for, send_from_directory
app = Flask(__name__,static_url_path='')

@app.before_first_request
def setupSerial():
 global arduino
 arduino=arduinoSerial.Arduino(57600,'*',0)
  
@app.route("/")
def page():
 if arduino.getConnStatus()==True:
  return app.send_static_file('temp.html')
 
@app.route('/state') 
def getState():
 arduino.serWrite('get')
 a=arduino.serRead()
 print(a)
 return a

@atexit.register
def disconnect():
 arduino.closePort()
 print('Port closed !!!')
 
@app.route('/')
def sendPage():
 return app.send_static_file('temp.html')
 
if __name__ == "__main__":
 app.run(debug=True,host='192.168.0.39')


      Fiecarei actiuni pe care serverul trebuie sa o execute ii este ascociata o functie. De exemplu inainte de prima conectare se apeleaza functia setupSerial(). Aceasta functie practic face posibila conectarea cu Arduino. Obiectul "arduino" este creat utilizand constructorul clasei arduinoSerial si are ca parametrii baudrate-ul, caracterul pana la care Arduino citeste sirul e caractere trimis de server si daca se doreste (1) sau nu (0) conectarea automata.
       Browserul web va trimite un 'request' catre server la fiecare doua secunde, utilizand Ajax. Prin request se va cere '/state'. Cand serverul a primit aceasta comanda va solicita la randul lui temperatura catre Arduino. Arduino ii va da server-ului un sir de caractere separat prin ":" care va contine temperatura curenta, cea mimina si maxima. Serverul va trimite clientului sirul primit. Clientul (browser-ul), dupa ce va prelucra sirul de caractere va afisa temperatura pe pagina web.

Pheeeeeeewwwww :)!!!

Acum sa aruncam un ochi si pe codul pentru Arduino (care a fost scris compilat si upload-at utilizand Arduino Create, al carui betatester fericit sunt):



 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <OneWire.h>
#include <DallasTemperature.h>
 
// Data wire is plugged into pin 12 on the Arduino
#define ONE_WIRE_BUS 12
 
// Setup a oneWire instance to communicate with any OneWire devices 
// (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
 
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
float current;
float min;
float max;
boolean firstRead=true;

void setup(void)
{
  // start serial port
  Serial.begin(57600);
  // Start up the library
  sensors.begin();
}
void sendData(){
    String g="";
    g=String(current)+':'+String(min)+":"+String(max)+":";
    
    Serial.println(g);
} 
 
void loop(void)
{
  sensors.requestTemperatures();
  current=sensors.getTempCByIndex(0);
  if(firstRead){
    min=current;
    max=current;
    firstRead=false;
      
  }
  else{
    if(current<min){
        min=current;
    }
    if(current>max){
        max=current;
    }
  }
  delay(100);
  if(Serial.available()>0){
      String g=Serial.readStringUntil('*');
      if(g.indexOf("get")!=-1){
         sendData(); 
      }
  }
}

Dupa cum se observa nu este nimic special. Arduino va citi tot ceea ce primeste pe portul serial pana cand va primi caracterul "*". Apoi daca primeste comanda "get" va trimite datele inapoi catre server despartite intre ele prin caracterul ":".

Epilog...

Metoda descrisa mi se pare foarte avantajoasa. Oricine dispune de un computer mai vechi  poate realiza un server permanent ce indeplineste functii complexe, Arduino devinind practic un periferic al acestuia.

Pana data viitoare sa auzim de bine. Daca doriti mai multe detalii nu va sfiiti sa ma contactati!

Succes!


duminică, 27 martie 2016

AFISAJ 6 DIGITI CU ARDUINO

0 comentarii | Read more...
Motivul...



      De ceva vreme mi-am dorit sa experimentez cate ceva cu display-uri cu digiti. Ca orice om normal am comndat un driver specializat MAX7219. Din motive pe care nu le cunosc, magazinul online la care am plasat comanda, nu s-a sinchisit sa ma anunte ca nu au pe stoc integratul mai sus amintit.
Cum weekend-ul batea la usa si nu aveam nimic in lucru m-am decis sa imi construiesc singur un driver pentru 6 digiti. Am pus mana pe Proteus si am injgehbat o schema si un cablaj, asa cum se pot vedea mai jos:










     Apoi am scris o librarie (prima :) ) pentru Arduino cu ajutorul careia am reusit sa controlez afisajul. In esenta, cu ajutorul librariei, se pot realiza urmatoarele:
  1. se pot afisa ore, minute, secunde - in format decimal sau binar (un pitic mai vechi de-al meu);
  2. texte (in limita oferita de digit);
  3. se pot derula texte cu viteza setabila;
  4. se pot aafisa texte cu efect de clipire.
     Cum nu aveam material de test am mai facut un pcb pe care am fixat un RTC DS1307 si un sezor de temperatura DS18B20:



Concluzie...

Desi sunt multumit de functionalitate marimea lasa totusi de dorit. Cred ca mai comand o data MAX 7219 si miniaturizez tot sistemul.

Cele bune!!


PS: Daca e cineva interesat pot oferi cablajul si libraria.




vineri, 4 martie 2016

Triplu stecher controlat prin internet (Partea II)

3 comentarii | Read more...


Schema...


Este gata! Am reusit sa finalizez si montajul care va comanda consumatorii alimentati la 220V.





Schema arata cam in halul de mai jos:



     Nimic complicat. Trei relee, a caror bobina este alimentata direct la 220V, sunt comandate de catre NodeMCU prin intermediul unor optocuploare (OMR351B) produse de catre Omron. Partea interesanta cu aceste optocuploare (tehnologie MOSFET) este ca pot alimenta (in limita a 50mA) sarcini direct de la retea (220V). Fiind optocuplor se intelege faptul ca exista izolare galvanica intre partea "de comanda" si cea "de forta".
     Deoarece nu am gasit o informatie clara vis a vis de curentul maxim pe care il poate debita pe un pin NodeMcu V1.0, am gasit de cuviinta sa folosesc 3 tranzsitoare BC547 ca drivere. 

Cablajul...

     Pentru cablaj a fost necesar sa realizez un fel de adaptor care sa imi permita scoaterea din circuit a controller-ului si utilizarea lui in alte proiecte. Asa ca am facut un soi de shield in care am "infipt" NodeMcu-ul. In rest nimic deosebit. Ce a iesit vedeti mai jos:






 

Carcasa...

     Carcasa nu este altceva decat o cutie de jonctiuni, care a fost taiata si chinuita pentru a se putea monta 3 prize modulare, releele si mataraia de cabluri :)
     Cablul de alimentare al controller-ului a fost lasat mai lung pentru a putea servi la nevoie si pentru programare.



Cam asta este. Multe multumiri lui Alex, pentru ajutorul dat la editarea video, si lui George pentru ajutorul dat la cablarea releelor.

Sa auzim de bine




Totalul afișărilor de pagină

Despre

Blog cu si despre electronica !