Am achizitionat nu demult de la robofun doua module XBee S2.

Documentatia de fabrica e suficient de seaca, astfel incat reuseste sa puna pe ganduri pana si un profesionist. De aceea vin cu niste idei care, poate clarifica unele ciudatenii, sau eventual vor atarna in balanta in momentul deciziei de a utiliza asemenea module.

Modulele de comunicatie XBee au fost concepute pentru comunicatii de viteza mica pe distante scurte (100m), medii (3km) sau mari (40km) in retele de senzori. Utilizarea lor, evident, nu se limiteaza doar la senzori.

Functioneaza pe benzile de frecventa ISM, cu licenta libera: 2.4GHz, 868MHz.

Viteza maxima de comunicatie variaza intre 10kbiti/secunda (kbps) si 65Mbps in functie de distanta si banda utilizata.

Modulele comercializate de robofun sunt de doua tipuri:

1. S2 (2mW): cu antena chip sau cu antena baston – acestea intra in categoria modulelor pentru comunicatii la distante mici (120m), cu viteze de pana la 250kbps.
2. S2B PRO (50mW): cu bataie de pana la 1.5km si viteze de pana la 250kbps.

Varianta S2B PRO este evident mai scumpa.

Necesarul de putere pentru o buna functionare este de cca.132mW (40mA@3,3V) pentru S2 si cca.386mW (117mA@3,3V) pentru S2B.

Modulele se pot configura sa functioneze in retele de diverse topologii, dar cu doua module in traista un utilizator nu prea se poate aventura, decat la o comunicatie punct-la-punct.

In documentatia fabricantului cel mai tare mi-a placut fraza “No configuration necessary for out-of-box RF communication”, adica “Pentru o comunicatie RF din prima nu este necesara nici o configurare”. Adevarat, daca vorbim de o retea XBee existenta, dar total fals la o prima incercare. Iata de ce.

Reteua XBee a fost conceputa ca o retea cu mai multe noduri. Nodurile au rol bine determinat si pot fi de trei categorii:

1. coordonator
2. router
3. dispozitiv de capat

Intr-o retea XBee poate exista un singur nod coordonator, mai multe noduri de tip router, restul fiind dispozitive de capat: senzori, afisaje, echipamente de uz casnic, etc. dotate cu asemenea module.

Coordonatorul este raspunzator pentru “construirea” retelei: scaneaza in jurul sau frecventele alocate si se “aseaza” pe un canal liber, isi rezerva o adresa de retea (PAN ID) si aloca adrese celorlalte noduri, care i se vor atasa.

Routerele se pot atasa retelei folosindu-se de adresa retelei, iar dupa aceea se ocupa de rutarea datelor primite, respectiv de atasarea nodurilor tip dispozitiv.

Nodurile tip dispozitiv se pot “agata” de retea prin conectarea la un router.

Modulele comercializate de robofun se livreaza preconfigurate ca routere. In starea de fabrica adresele PAN ID sunt 0, adica nodul odata pornit se poate atasa la orice retea existenta. Aici apare problema incepatorului. Chiar cu doua module pe masa comunicatia nu apare! De ce oare? Pentru ca nu exista inca retea, la care aceste doua noduri sa se agate. Neavand retea, nu vor primi adrese proprii si nu vor functiona. Trebuie sa configuram modulele astfel, incat sa simulam existenta unei retele.

Pentru a configurare vom folosi programul X-CTU. Instalarea dureaza cateva minute bune, pentru ca pe parcursul instalarii se vor descarca si fisierele actualizate ale tuturor modulelor XBee recunoscute de program.

Dupa aceea trebuie sa ne conectam la un XBee de-al nostru. Eu am folosit un breadboard in care am conectat modulul XBee introdus in soclu adaptor, iar soclul l-am conectat la un port USB printr-un modul FTDI de 3,3V

Pentru verificare:

FTDI	XBee
RXI	3 (Tx)
TXO	4 (Rx)
3V3	2 (3V3)
GND	1 (GND)

Pornim programul X-CTU, si daca conexiunile sunt corecte, apare imaginea urmatoare:

Nu vom detalia toate functiile programului, acestea se pot citi la nevoie (!) in documentatie.

Trecem in schimb la ultimul tab: Modem Configuration.

Ecranul e mai mult gol, pentru ca modulul XBee inca nu a fost recunoscut. Apasam butonul Read si rezultatul va fi:

Pentru orientarea in hatisul de informatii vom explica doar cele necesare unei manevre de test, cum ne-am propus:

COD	Detaliere
(0) ID – PAN ID	Adresa retelei la care se doreste conectarea. (Personal Area Network ID). Valoarea 0 inseamna oricare retea accesibila.
(0) OP – Operating PAN ID	Adresa retelei la care s-a conectat. Valoarea 0 insemna nici o retea.
(FFFF) OI – Operating 16-bit PAN ID	Adresa de 16 biti a retelei la care s-a conectat. Valoarea FFFF insemna oricare retea.
(0) CH – Operating Channel	Canalul radio pe care s-a conectat. Valoarea 0 insemna nici un canal
(13A200) SH – Serial Number High	Numarul de serie al modulului (partea superioara a adresei). Valoare unica inscrisa de fabricant.
(407E7145) SL – Serial Number Low	Numarul de serie al modulului (partea inferioara a adresei). Valoare unica inscrisa de fabricant.
(FFFE) MY – 16-bit Network Address	Adresa de 16 biti a modulului in cadrul retelei. Valoarea FFFE inseamna neconectat la retea.
(0) DH – Destination Address High	Adresa de destinatie a datelor, partea superioara. Valoarea 0 = fara destinatie
(0) DL – Destination Address Low	Adresa de destinatie a datelor, partea inferioara. Valoarea 0 = fara destinatie

Observam ca, unele randuri in ecranul cu aceste date sunt marcate cu verde, altele cu negru. Cele verzi se pot modifica la nevoie , iar cele negre sunt doar informative, dar utile.

TOATE DATELE NUMERICE SUNT IN FORMAT HEXADECIMAL.

Avand doar doua module XBee la indemana vom proceda la construirea unei retele cu doua noduri. Ca orice retea XBee, va avea nevoie de adresa de retea, iar modulele odata conectate vor avea nevoie de niste adrese de destinatie pentru datele transmise, mai precis destinatia unui modul va fi adresa celuilalt modul si vice-versa. Sa vedem cum stam:

Numarul de serie al fiecarui modul se comporta in cadrul protocolului de comunicatie ZigBee ca o adresa. Daca “invatam” modulele cu adresa celuilalt, avem toate datele necesare ridicarii retelei cu doua noduri.

Cel mai simplu mod de a porni este sa configuram un nod ca un coordonator, acesta urmand sa se ocupe de restul treburilor.

Iata cum arata unul din modulele mele configurat ca si coordonator:

Se poate observa ca, adresa retelei am fortat-o la valoarea hexa 0×123456789ABCDEF, partile High (0×0013A200), respectiv Low (0×407E745) ale adresei de destinatie le-am luat de la modulul celalalt.

Coordonatorul s-a ocupat de construirea adresei de 16 biti (0×3808), de ocuparea canalului radio (0×0F) si de alocarea unei adrese proprii (0×0000). Coordonatorul totdeauna isi rezerva adresa 0×0000 intr-o retea.

Fiecarui nod i se poate atasa si un nume (NI – Node Identifier), care se poate folosi la o adresare mai usoara in cadrul unei retele mari. In exemplu am denumit coordonatorul ca “NODE A”.

Manevra de mai sus am repetat-o si pentru modulul B, cu mici diferente. Nu am modificat valoarea adresei de retea (PAN ID = 0×00), in schimb partile High (0×0013A200), respectiv Low (0×407E751) ale adresei de destinatie le-am luat de la modulul A, adica modulul coordonator.

Se observa ca adresa retelei proaspat construite se repeta si la acest modul, fara sa ne fi atins de aceasta. Mai mult, corespunde si adresa de 16 biti (0×3808), dar difera adresa nodului (0×9C38) in cadrul retelei.

Folosind intr-un nod un XBee cu adaptor + un modul FTDI/USB conectat la calculator, iar in celalalt nod un panou de test echipat cu un procesor mbed si cu al doilea modul XBee am testat comunicatia radio.

Procesorul mbed foloseste un port serial UART prin care preia datele de la XBee si le interpreteaza: daca soseste o cifra intre 1 si 4, atunci isi va comuta starile celor patru LEDuri proprii.

// Test comunicatii XBee cu mbed

#include "mbed.h"

Serial XBee(p9,p10); // configurare port serial

DigitalOut L1(LED1); // configurare iesiri pentru cele 4 LEDuri

DigitalOut L2(LED2);

DigitalOut L3(LED3);

DigitalOut L4(LED4);

unsigned char c; // buffer pentru simbolul citi de la UART

int main() {

   while(1) { // pana la infinit ...

      if (XBee.readable()) { // daca avem ceva pe portul serial

         c=XBee.getc(); // preluam un caracter

         XBee.putc(c);  // il trimitem inapoi drept confirmare

         switch (c) {   // si daca ...

            case '1': L1 = !L1; break; // e 1 -> comuta LED 1

            case '2': L2 = !L2; break; // e 2 -> comuta LED 2

            case '3': L3 = !L3; break; // s.a.m.d.

            case '4': L4 = !L4; break;

         } // switch

      } // if

   } //while

}

tutoriale Nici un comentariu

Aveam un cooler de o placa de baza GigaByte si ma gandeam ce pot face cu el. M-am gandit sa ma folosesc de pinii digitali cu PWM de pe Arduino UNO.
Uita-ti ce mi-a iesit:
Video

Codul:
/* MADE BY MIHAIM1980( alias MIHAI MACARIE)
Control ventilator cu PWM */
void setup() {
// declaram pinul 9 ca OUTPUT:
pinMode(9, OUTPUT);
} void loop() {
analogWrite(9,255); //viteza maxima
delay(5000);
analogWrite(9,191); //viteza 75%
delay(5000);
analogWrite(9,127); //viteza 50%
delay(5000);
analogWrite(9,64); //viteza 25%
delay(5000);
}

Mai multe despre PWM cu Arduino:
PWM ARDUINO

proiecte, tutoriale Nici un comentariu

La telefoanele Nokia nu se poate utiliza radioul fara casti. Facand niste mici experimente, am descoperit cum se poate pacali radioul.

Video

Am folosit:

• un jack audio de 3,5mm
• 3 fire
• letcon si consumabilele aferente (sacaz + alcool etilic)

 

Instructiuni:
1.Se ia o mufa jack de 3,5mm si se desface (daca e luata de la magazin).
2.Se ung contactele din inauntrul mufei cu solutie de sacaz(sacaz ras fin + alcool etilic)
3.Se iau firele si lipesc fiecare pe cate un contact.
4.Se monteaza la loc mufa si se introduce in intrarea audio a telefonului.
5.Intram in radio si activam difuzoarele.
6.Introduceti frecventa postului de radio sau dati o scanare
7.Daca e totul in regula ar trebui sa auziti postul preferat.

Pentru acest proiect am folosit telefonul Nokia 5228. Antena este compatibila cu toate telefoanele Nokia care au intrare audio jack. Se mai poate face cu casti de la magazine ,,chinezesti,,. Se taie difuzoarele si aveti gata antena.

proiecte, tutoriale 3 comentarii

Salut Tehnorama.ro, salut prieteni !

Ma numesc Tarida Lucian si sunt proaspat absolvent al facultatii de Inginerie Mecanica si Electrica, specializarea Automatica din cadrul Universitatii Petrol-Gaze din Ploiesti.

Scurt intro: Asa cum era normal, a venit momentul in care a trebuit sa-mi aleg o tema de licenta pentru a incheia cei 4 ani de studiu. Asadar, pe la sfarsitul lunii octombrie 2010 m-am hotarat: “vreau sa fac un robot mobil pentru ca, intotdeauna, mi-au placut robotii si sistemele automate”. La scurt timp, mi-am ales tema proiectului de licenta, si anume “Sistem de conducere a unui robot mobil pe baza retelelor neuronale artificiale” si un profesor care sa-mi supervizeze munca, Dl. Conf. Dr. Ing. Adrian Moise. Am inceput sa ma informez din diverse manuale de specialitate, articole, de pe internet, iar apoi a venit momentul in care a trebuit sa-mi achizitionez componentele robotului. Am apelat cu incredere la Robofun.ro, unde am avut placerea sa-l cunosc pe Dl. Viorel caruia ii multumesc pe aceasta cale pentru amabilitatea de care a dat dovada.

Astfel, mi-am achizitionat aproape toate componentele robotului ROBOTL de la Robofun.ro:

• Arduino Uno
• Shield ArduMoto
• Senzori de reflectanta (linie)
• Cutia de viteze Tamiya
• Roti + Ball Caster
• Fire de conexiune si altele..
• Sasiu robot
• Leduri, componente electronice(rezistori, condensatori, tranzistori) si altele…

Schema bloc de functionare a robotului ROBOTL

Functionare

ROBOTL (a se citi Robotel) este un robot mobil urmaritor de linie (line follower) ce se deplaseaza conform unui traseu reprezentat de o linie neagra pe un fundal alb. Linia neagra se traseaza cu o banda izoliera pe o bucata de carton duplex.

Citirea traiectoriei dupa care se deplaseaza robotul se face cu ajutorul senzorului analogic QRE1113 format dintr-un led cu infrarosu si un fototranzistor sensibil la lumina infrarosie. Am folosit 3 astfel de senzori ce alcatuiesc sistemul senzorial al robotului ROBOTL.

Semnalele provenite de la senzori sunt trimise spre procesare Unitatii Centrale reprezentata de Platforma de dezvoltare Arduino Uno ce contine microcontroller-ul ATmega328 de la ATMEL. Platforma de dezvoltare Arduino Uno reprezinta sistemul de comanda al robotului si contine 14 pini digitali de intrare-iesire si 6 pini analogici. Pentru ROBOTL s-au folosit urmatorii pini: analogici: A0, A1, A2 conectati fiecare la pinul de iesire al fiecarui senzor de linie si digitali: D3(PWM), D11(PWM), D12, D13 folositi pentru controlul motoarelor de curent continuu, D4, D5, D6, D8, D9, D10 pentru controlul ledurilor, pinul D2 pentru circuitul buzzer ce ofera sunetul de final de linie.

Semnalele procesate sunt apoi transmise catre shield-ul ArduMoto ce comanda, conform principiului unei punti H, cele doua motoare electrice de curent continuu ale robotului. Motoarele sunt incluse in cutia de viteze Tamiya impreuna ca angrenajele aferente ce confera drept rapoarte de transfer 58:1, respectiv 203:1. ROBOTL functioneaza in configuratia 58:1 drept raport de transfer.

Implementarea Retelei Neuronale Artificiale (RNA)

În cadrul acestui proiect, am folosit o rețea neuronala tip perceptron multistrat ce este formată dintr-un strat de intrare, un strat ascuns și unul de ieșire. Stratul de intrare cuprinde trei neuroni ce au drept intrări cele trei valori codificate în binar ale semnalelor provenite de la cei trei senzori de reflectanță. Stratul ascuns este alcătuit din patru neuroni, numărul lor fiind ales în mod arbitrar, totodată fiind suficient pentru implementarea rețelei neuronale pe baza căreia funcționează robotul ROBOTL. Stratul de ieșire conține doi neuroni ce furnizează la ieșire sensul de rotație al celor două motoare electrice de curent continuu ale robotului ROBOTL. Pentru implementarea retelei s-au folosit urmatoarele codificari: tensiune de iesire senzor >= 4V (valoare determinata experimental) => (i=1) altfel (i=0) ; sensul de rotatie a motoarelor – inainte(1), stop(0), inapoi(-1). In figura alaturata este reprezentata RNA pe baza careia functioneaza robotul ROBOTL.

Caracteristicile RNA:

• Arhitectura retelei : Perceptron multistrat (multilayer perceptron) cu un strat ascuns
• Functia de activare : Sigmoid pentru stratul ascuns si activare liniara pentru stratul de iesire
• Algoritmul de invatare (antrenare) : Algoritmul de propagare inversa a erorii (backpropagation)

Soft educational – Antrenare Retea Neuronala Artificiala

Pentru a antrena reteaua neuronala prezentata mai sus, am dezvoltat o aplicatie in C++ Builder ce poate fi folosita cu incredere si in scop didactic, fiind un soft educational. Astfel, oricine doreste sa antreneze o retea neuronala artificiala de tip perceptron multistrat (cu un singur strat ascuns) si conform algoritmului de propagare inversa a erorii poate folosi acest soft. Softul ofera ponderile retelei la fiecare epoca in cadrul fisierului out.txt ce se deschide dupa antrenare si graficul evolutiei erorii patratice medii. Se pot efectua 5 astfel de reprezentari grafice iar utilizatorul o alege pe cea in care eroarea patratica tinde mai rapid spre 0 (zero). Interfata softului este prezentata in imaginea de mai jos.

Imagini ROBOTL :

Ponderile obtinute in urma antrenarii retelei neuronale artificiale cu ajutorul softului educational mai sus mentionat au fost utilizate la conducerea robotului mobil ROBOTL pe baza RNA. Iata codul programului din memoria microcontroller-ului ATmega328 cu ajutorul caruia functioneaza robotul ROBOTL:

/*
  07-04-2011
  Tarida Lucian Constantin

  Contact:
    * E-MAIL: lucian_ctin08@yahoo.com
*/
//----------Pini motoare si senzori----------------
int pwm_a = 3;
int pwm_b = 11;
int dir_a = 12;
int dir_b = 13;
int IRpins= 0;  // pin pentru senzor stanga
int IRpind = 1;  // pin pentru senzor dreapta
int IRpinm = 2; // pin pentru senzor centru
//--------------------------------------------------

//------led pins--------
long previousMillis = 0;
long interval = 75;
const int ledPin4 =  4;
const int ledPin5 =  5;
const int ledPin6 =  6;
const int ledPin8 =  8;
const int ledPin9 =  9;
const int ledPin10 =  10;
//-----------------------

//--------Note Muzicale--------
#define NOTE_G4  392
#define NOTE_A4  440
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_D5  587
#define NOTE_E5  659

int melody[] = {
  NOTE_C5, NOTE_G4, NOTE_G4, 0, NOTE_C5, 0 ,NOTE_A4, NOTE_A4, NOTE_A4,
  NOTE_B4, NOTE_C5, NOTE_D5, NOTE_B4, NOTE_C5, NOTE_E5, NOTE_C5};
int noteDurations[] = {4,8,4,16,4,16,4,8,2,4,8,4,4,4,8,2};
int looop=0;  // variabila utilizata la executarea sunetului o sg. data
//------------------------------

//---------------Retea Neuronala---------------------------
// Ponderile Retelei Neuronale
const double
w11 = -6.390470,
w12 = 3.475753,
w13 = -1.168266,
w21 = 4.685940,
w22 = -4.834824,
w23 = -4.389631,
w31 = 0.926425,
w32 = -4.021020,
w33 = -3.097896,
w41 = -3.659724,
w42 = -4.280046,
w43 = 0.800755,
v11 = 1.067345,
v12 = 2.492497,
v13 = -4.892565,
v14 = 1.341395,
v21 = 1.122284,
v22 = 2.182859,
v23 = -1.559597,
v24 = -1.766479;
// Variabile ale Retelei Neuronale
double neth1,neth2,neth3,neth4,oh1,oh2,oh3,oh4,o1,o2;
int i1,i2,i3; //intrarile RN
//-----------------------------------------------------------

void setup()
{
  pinMode(pwm_a, OUTPUT);
  pinMode(pwm_b, OUTPUT);
  pinMode(dir_a, OUTPUT);
  pinMode(dir_b, OUTPUT);
  pinMode(ledPin4, OUTPUT);
  pinMode(ledPin5, OUTPUT);
  pinMode(ledPin6, OUTPUT);
  pinMode(ledPin8, OUTPUT);
  pinMode(ledPin9, OUTPUT);
  pinMode(ledPin10, OUTPUT);

  Serial.begin(9600);

}
void loop()
{
// Citire si Afisare Valoare Senzori
    float senzor_centru = analogRead(IRpinm)*((float) 5 / 1024) ;
    float senzor_stanga = analogRead(IRpins)*((float) 5 / 1024) ;
    float senzor_dreapta = analogRead(IRpind)*((float) 5 / 1024) ;
    if(senzor_stanga>=4) i1=1; else i1=0;
    if(senzor_centru>=4) i2=1; else i2=0;
    if(senzor_dreapta>=4) i3=1; else i3=0;

 // Parcurgerea Inainte a Retelei Neuronale
    neth1=i1*w11+i2*w12+i3*w13;
    neth2=i1*w21+i2*w22+i3*w23;
    neth3=i1*w31+i2*w32+i3*w33;
    neth4=i1*w41+i2*w42+i3*w43;
    oh1=1/(1+ exp(-neth1));
    oh2=1/(1+ exp(-neth2));
    oh3=1/(1+ exp(-neth3));
    oh4=1/(1+ exp(-neth4));
    o1=oh1*v11+oh2*v12+oh3*v13+oh4*v14;  //iesirile RN: o1 si o2
    o2=oh1*v21+oh2*v22+oh3*v23+oh4*v24;

 // Inainte
 if (round(o1)==1 && round(o2)==1)
   {
   digitalWrite(dir_a, HIGH);
   digitalWrite(dir_b, HIGH);  

   analogWrite(pwm_a, 90);
   analogWrite(pwm_b, 90);
   leduri(1);
   }  

 // Viraj catre stanga
 if (round(o1)==-1 && round(o2)==1)
   {
   digitalWrite(dir_a, LOW);
   digitalWrite(dir_b, HIGH);  

   analogWrite(pwm_a, 40);
   analogWrite(pwm_b, 60);
   leduri(1);
    }  

 // Viraj catre dreapta
 if (round(o1)==1 && round(o2)==-1)
    {
    digitalWrite(dir_a, HIGH);
    digitalWrite(dir_b, LOW);  

    analogWrite(pwm_a, 60);
    analogWrite(pwm_b, 40);
    leduri(1);
    }  

 // Stop
 if (round(o1)==0 && round(o2)==0)
   {
   digitalWrite(dir_a, HIGH);
   digitalWrite(dir_b, HIGH);  

   analogWrite(pwm_a, 0);
   analogWrite(pwm_b, 0);
   leduri(0);
   }

 // Sunet
  if (i1==1 && i2==1 && i3==1 && looop==0)
  {  for (int thisNote = 0; thisNote < 16; thisNote++) {
    int noteDuration = 1000/noteDurations[thisNote];
    tone(2, melody[thisNote],noteDuration);
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(2);
    looop+=1; }
  }
}

 // Leduri
 void leduri(int x)
 {
  if(x==1)
  {
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > interval*6) {
      previousMillis = currentMillis;
    digitalWrite(ledPin10, HIGH);
    digitalWrite(ledPin9, LOW);
   }

  else   if(currentMillis - previousMillis > interval*5) {
    digitalWrite(ledPin9, HIGH);
    digitalWrite(ledPin8, LOW);
   }

 else  if(currentMillis - previousMillis > interval*4) {
    digitalWrite(ledPin8, HIGH);
    digitalWrite(ledPin6, LOW);
   }

 else  if(currentMillis - previousMillis > interval*3) {
    digitalWrite(ledPin6, HIGH);
    digitalWrite(ledPin5, LOW);
   }

 else if(currentMillis - previousMillis > interval*2) {
    digitalWrite(ledPin5, HIGH);
    digitalWrite(ledPin4, LOW);
   }

  else  if(currentMillis - previousMillis > interval) {
    digitalWrite(ledPin4, HIGH);
    digitalWrite(ledPin10, LOW);
   }
  }
  if(x==0)
  {
    digitalWrite(ledPin4, LOW);
    digitalWrite(ledPin5, LOW);
    digitalWrite(ledPin6, LOW);
    digitalWrite(ledPin8, LOW);
    digitalWrite(ledPin9, LOW);
    digitalWrite(ledPin10, LOW);
  }
 }

Cam atat despre robotul meu. Cei interesati de alte informatii ma pot contacta la adresa de e-mail: lucian_ctin08@yahoo.com.

In incheiere, as vrea sa multumesc Dl. Conf. Dr. Ing. Adrian Moise, Dl. Viorel de la Robofun si, nu in ultimul rand, prietenului meu Florea Mihai.

Cu respect,
Tarida Lucian

general, proiecte, tutoriale 45 comentarii

ATtiny85 este un chip interesant, mai mic si mai ieftin decat obisnuitul ATmega328P. Printre altele are (extras de pe pagina oficiala):

The high-performance, low-power Atmel 8-bit AVR RISC-based microcontroller combines 8KB ISP flash memory, 512B EEPROM, 512-Byte SRAM, 6 general purpose I/O lines, 32 general purpose working registers, one 8-bit timer/counter with compare modes, one 8-bit high speed timer/counter, USI, internal and external Interrupts, 4-channel 10-bit A/D converter, programmable watchdog timer with internal oscillator, three software selectable power saving modes, and debugWIRE for on-chip debugging. The device achieves a throughput of 20 MIPS at 20 MHz and operates between 2.7-5.5 volts.

Poate fi programat cu Arduino

Am gasit un tutorial la HLT pentru programarea cu Arduino folosind un breadboard. Tutorialul este bun, dar omite sa precizeze un mic amanunt fara de care nu merge, cel putin pe Duemilanove… Pentru a evita auto-reset la Arduino trebuie sa procedam ca aici (o rezistenta de 120 ohm intre pinii Reset si 5V de pe Arduino)

Daca avem mai des nevoie sa scriem ATtiny85 putem face un “shield”. In schema de mai jos am pus si un LED pentru a verifica chipul dupa scriere.

O prima “tentativa de shield” arata cam asa (cu doua rezistente de 220 ohm puse in paralel in loc de cea de 120 si cu inca doua LED-uri si rezistentele de 1K aferente – ca semnale pentru ISP)

Tot ce mai ramne de facut este sa descarcam de la HLT arhiva zip cu placile pentru ATtiny45 si 85, sa o dezarhivam in folderul pe care-l avem la preferinte la Arduino in “Sketchbook location”, intr-un sub-folder “hardware” (daca nu-l avem, il facem).

Dupa ce incarcam pe placa Arduino, din exemple, sketch-ul ArduinoISP putem trece la programarea ATtiny85. Alegem placa ca mai jos:

Am modificat sketch-ul “Blink” din exemple pentru a utiliza in loc de pinul 13 pinul 3 si l-am incarcat. Putem ignora erorile… programul merge

tutoriale 3 comentarii

In acest tutorial va voi arata cum sa conectati un accelerometru Adxl335 la Arduino .

Adxl335 este un accelerometru analogic pe 3 axe . Fiind un accelerometru analogic este foarte simplu de utilizat . Pentru citirea acceleratiilor  se conecteaza porturile aferente fiecarei axe la  porturile analogice ale placii Arduino. In princiu asta este toata magia . Mai sunt cateva artificii dar in mare asta este tot .

Acum sa trecem la treaba.

tutoriale 1 comentariu

Acest proiect descrie utilizarea modulului Ethernet pentru a realiza implementarea unui server web care ruleaza pe platforma Arduino.

La finalul tutorialului vei avea o platforma Arduino care ruleaza un server web. Vei putea sa te conectezi din browser la adresa IP a serverul web de pe platforma Arduino ca sa vezi diverse valori citite de senzori sau sa setezi diversi parametri ai programului care ruleaza pe platforma.

In acest proiect, ca sa facem lucrurile un pic mai interesante, vom conecta un potentiometru la Arduino si vom citi pozitia acestuia in browser prin conectarea la  serverul web instalat pe Arduino.

tutoriale Nici un comentariu

Evident, cu Arduino

Principiul de baza este simplu, chiar foarte simplu. Doar fire conductoare introduse in pamanul din ghiveci formeaza un rezistor variabil, a carui rezistenta variaza in functie de umiditatea pamantului. Acest rezistor variabil este conectat intr-o configuratie de divizor de tensiune, iar Arduino culege o tensiune proportionala cu rezistenta dintre fire, si implicit cu umiditatea din ghivechi. Mai departe, sky is the limit

Eu am folosit doar un simplu led care se aprinde, ca sa ilustrez principiul, dar se pot imagina o multitudine de interactiuni in zona asta. Doar cateva exemple ar fi un SMS (“Iar ai uitat sa ma uzi dimineata, idiotule !” – semnat “Floricica”), un email primit tot de la “Floricica”, sau chiar apel de voce folosind un shield GSM.

Am inceput prin a taia o bucata de PCB dublu strat (fiecare strat de cupru reprezinta un conductor, corect ?), pe care am lipit doua fire (cate un fir pe fiecare parte de cablaj), l-am infipt in pamantul din ghiveci si i-am masurat rezistenta cu pamantul ud si cu pamantul uscat (asta ca sa imi dau seama de ce rezistor am nevoie pentru a realiza divizorul de tensiune). Am gasit valori intre 10 KiloOhm si 100 de KiloOhm, asa ca m-am hotarat ca un rezistor de 30 de KiloOhm ar fi bun pentru ceea ce am nevoie.

Schema montajului este cea de mai jos. Cuprinde un Arduino, un rezistor fix de 30 KOhm, un rezistor variabil (format din placa de PCB introdusa in ghiveci), si un led.

Codul sursa este si el foarte simplu. Atunci cand rezistenta masurata intre cele doua fire introduse in ghiveci scade sub o anumita valoarea (pe care o stabilesti tu prin teste repetate, in functie de distanta intre fire si de cata umiditate are nevoie planta), led-ul se aprinde.

const int VAL_PROBE = 0; // Analog pin 0
const int UMIDITATE_NIVEL = 250; // Valoarea dupa care se "declanseaza" led-ul 

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

void LedState(int state) {
  	digitalWrite(13, state);
}

void loop() {
	int umiditate = analogRead(VAL_PROBE);

	Serial.println(umiditate);

	if(umiditate > UMIDITATE_NIVEL) {
		LedState(HIGH);
	} else   {
	    LedState(LOW);
	}
  	delay(100);
}

tutoriale 3 comentarii

Intro

În urmă cu câteva săptămâni mi-am propus să găsesc o metodă simplă de a controla modul în care îmi ud florile din balcon. Am un program foarte încărcat și, de mult ori, uit să ud plantele lucru care nu prea le priește. Mi-am luat un cititor de umiditate pentru sol, dar problema e că uit și de acela, luat fie de treburile casnice, fie de alte lucruri pe care trebuie să le rezolv serile. Singura activitate cavsi-constantă care mi-ar fi permis o monitorizare mai atentă este lucrul pe computer, serile mă conectez și lucrez câteva ore la diverse proiecte, fie de dezvoltare, fie articole pentru care am termene de predare la diverse reviste. Așadar, m-am gândit că ar fi minunat să am un mod de notificare instalat pe laptop care să mă atenționeze atunci când trebuie… să ud anumită plantă. Mi-am imaginat că pe web trebuie să existe sute de proiecte de automatizare, dar am căutat ceva simplu, fără pompe și dispozitive automate de udat. Ceva care doar să citească valorile din sol (umiditate) din aer (umiditate, temperatură) și să le trimită wireless unei aplicații tip utility (care rulează în fundal) și care avertizează vizual – prin câteva elemente de interfață – atunci când este necesar să îngrijesc o anumită plantă. Deci ce face omul când nu are treabă ? Își face de lucru. Habar nu aveam că acest proiect al meu îmi va trezi amintiri din copilărie-adolescență (vezi de pildă aici), din perioada în care electronica era una dintre marile mele pasiuni. Astfel am descoperit Arduino și am ajuns să-i cunosc pe pasionații de la RoboFun cărora le mulțumesc încă o dată pentru sprijin.

Scop și obiective

Înainte de a mă arunca într-un proiect complicat și având în vedere că sunt primii pași pe care i-am făcut în lumea microcontroller-elor, mi-am propus câteva obiective simple pentru proiectul pe care încerc să-l descriu în acest tutorial:

1. Să conectez un senzor de temperatură bazat pe breakboard-ul tmp102 de la SparkFun la o platformă Arduino Uno;
2. Să conectez și să învăț cum funcționează un breakboard BlueTooth; am ales dispozitivul Bluetooth Mate Gold bazat pe un modul de clasa 1 RN-41, simplu de utilizat și cu documentație excelentă.
3. Să realizez primul meu program funcțional în soft-ul de la Arduino.
4. Programul Arduino să permită
   • citirea temperaturii de la senzor;
   • trimiterea valorilor temperaturii componentei bluetooth;
5. Conectarea componentei Bluetooth cu laptop-ul;
6. Realizarea unui program pentru un Apple MacBook care primește informațiile prin bluetooth și le afișează în bara de meniu; programul să funcționeze în fundal, tip “utility”.
7. Cam atât.

Am numit pompos aplicația “stație meteo“, de fapt un termomentru wireless integrat cu laptop-ul, dar intenționez dezvoltarea acestui proiect prin adăugarea unui senzor de presiune și a unuia de umiditate care pot furniza, împreună, mai multe informații necesare unei “stații meteo” reale.

Realizare

Conectarea breakboard-ului bluetooth; Conectarea cu laptop-ul se face prin intermediul unei interfețe Bluetooth. Am ales dispozitivul Bluetooth Mate Gold comercializat de Robofun aici:

Nu voi prezenta aici informații suplimentare referitoare la setarea dispozitivului Bluetooth, acestea putând fi găsite în documentația componentei. Oricum, intenționez să tratez acest subiect într-un post separat.

Conectarea dispozitivului Bluetooth la placa Arduino se face conform diagramei de mai jos.

Motivul pentru care am ales pinii 4 și 5 digital (PWM~) și nu pinii 0 și 1 este unul pur didactic: am vrut să testez interconectarea plăcii Arduino cu mai mulți pini digitali procedând la modificările de rigoare în codul Arduino.

Conectarea senzorului de temperatură; Senzorul de temperatură Tmp102 trebuie utilizat cu un convertizor de nivel logic deoarece senzorul de temperatură funcționează la 3.3V_cc și trebuie conectat la bus-ul I²C al platformei Arduino. Mai multe informații despre bus-ul I²C puteți citi aici (un tutorial extrem de interesant), oricum, important de reținut, comunicarea serială pe I²C se face pe 5V_cc nivel logic deci potențialul trebuie convertit la valorile utilizate (3.3V_cc) de senzorul de temperatură. În acest scop se utilizează convertizorul de nivel logic:

Convertizorul de nivel logic este foarte ușor de folosit. Trebuie alimentat de la două surse de tensiune (voltaj mare – HV – 5Vcc și voltaj mic – LV – 3.3Vcc) pe care le folosește platforma de dezvoltare: Pinul “HV” se conectează la 5Vcc, iar pinul “LV” la 3.3Vcc; pinul “GND” se conectează la masa platformei de dezvoltare.

Pinii sunt etichetati ca intrari (Inputs) si iesiri (Outputs). Acestea sunt relative la placa. Unul digital mergand la pinul RXI pe partea cu 5V va aparea la pinul RXO pe partea cu 3,3V, drept 3,3V. Unul digital mergand la pinul TXI pe partea cu 3,3V va aparea la pinul TXO pe partea cu 5V, drept 5V. Secțiunea marcată “HV” a convertizorului se conectează la paltforma Arduino, iar secțiunea marcată “LV” la senzorul de temperatură, în felul următor:

• Pinii “TXO” la pinii 4 și 5 ai platformei Arduino;
• Pinul “HV” la pinul de +5Vcc al plăcii Arduino;
• Pinul “GND” la masă;
• Pinii “TXI” la pinii SCL și SDA; nu este important CARE dintre cei doi pini TXI, dar este important să se păstreze corespondența; astfel, pinul SCL al senzorului să fie interconectat cu platforma Arduino prin intermediul convertizorului la pinul 5 analogic al plăcii Arduino, iar pinul “SDA” al senzorului să fie interconectat cu platforma Arduino prin intermediul convertizorului la pinul 4 analogic al plăcii Arduino; vezi imaginea de mai jos:

• Pinul “LV” al convertizorului se conectează la pinul 3,3Vcc al plăcii Arduino, iar al doilea pin “GND” tot la masă.

Elemente de montaj; imaginile de mai jos ilustrează pas cu pas montarea prototipului într-o carcasă de plastic, utilizând și un mini breadboard pentru conectarea firelor. Mini breadboard-ul se potrivește la fix în spațiul rezervat bateriei, din interiorul carcasei de plastic:

Codul Arduino; Pentru colectarea informațiilor generate de senzorul de temperatură, procesarea și transmiterea către interfața Bluetooth am utilizat următorul cod-sursă în aplicația Arduino:

#include
#include
#define TMP102_I2C_ADDRESS 72

byte firstbyte, secondbyte; //bytes pentru intreg si fractie
int val; //integer pentru temperatura

#define btRxPin 4 //definire pin rx bluetooth
#define btTxPin 5 //definire pin tx bluetooth

NewSoftSerial BlueTooth(btRxPin,btTxPin); //obiect pentru conexiune seriala

void setup()
{
  Serial.begin(115200);     //setare baud pentru serial
  BlueTooth.begin(115200);  //setare baud pentru bluetooth
  Wire.begin();

  pinMode(btRxPin, INPUT);  //setare intrare digitala
  pinMode(btTxPin, OUTPUT); //setare iesire digitala

  BlueTooth.println("Conectare BlueTooth reusita..."); //daca se conecteaza disp
                                                       //bluetooth anunta succesul
  delay(1000);
}

void getTemp102() {
    Wire.beginTransmission(TMP102_I2C_ADDRESS);
    Wire.send(0x00);
    Wire.endTransmission();
    Wire.requestFrom(TMP102_I2C_ADDRESS, 2);
    Wire.endTransmission();

    firstbyte = Wire.receive(); /* valori intregi */
    secondbyte = Wire.receive(); /* valori fractionale */

    float convertedTemp;
    float correctedTemp;

    val = ((firstbyte) << 4);  //concateneaza valoarea - step 1
    val |= (secondbyte >> 4);  //step 2

    Serial.println((float)val*0.0625); //verifica temp la terminal

    convertedTemp = float(val) * 0.0625; //converteste la float
    correctedTemp = convertedTemp - 5; //corecteaza eroarea
  /* verifica primul byte la terminalul serial */
    Serial.print("primul byte este ");
    Serial.print("\t");
    Serial.println(firstbyte,BIN);
  /* verifica al doilea byte la terminalul serial */
    Serial.print("al doilea byte este ");
    Serial.print("\t");
    Serial.println(secondbyte,BIN);
  /* verifica string-ul serial final la terminalul serial */
    Serial.print("concatenated byte is ");
    Serial.print("\t");
    Serial.println(val,BIN);
  /* verifica temperatura la terminalul serial */
    Serial.print("Converted temp is ");
    Serial.print("\t");
    Serial.println(convertedTemp);
  /* verifica temperatura corectata la terminalul serial */
    Serial.print("Corrected temp is ");
    Serial.print("\t");
    Serial.println(correctedTemp);

    BlueTooth.println(correctedTemp); //trimite la dispozitivul Bluetooth
}

/* intra in executie */
void loop() {
  getTemp102();
  delay(5000);
}

/* end */

Rezultate – integrarea cu Mac OS X; Nu voi intra în detalii de programare deoarece acestea depășesc scopul prezentului articol. Cine este interesat poate posta un comentariu și voi da detaliile cerute.

Aplicația este dezvoltată pe o platformă Mac OS X 10.6.6 și este extrem de simplă, de tip “utility”, care funcționeaă în fundal și afișează temperatura curentă în bara de status. Afișarea se modifică doar la modificarea temperaturii:

Concluzii

Proiectul discutat aici pe scurt este un prototip de stație meteo. Pentru simplitate am redus scopul la integrarea cu un singur senzor de temperatură deoarece am urmărit în principal un obiectiv didactic – acela de a învăța primii pași în universul microcontroller-elor.

Continuarea este dezvoltarea conceptului prin includerea mai multor senzori (presiune și umiditate), cuplarea cu o interfață ethernet (pentru accesarea informațiilor prin web) și dezvoltarea conceptului la un al doilea proiect, acela de controller de umiditate pentru solul plantelor din balcon.

Arduino & Mac OSX, proiecte, tutoriale 4 comentarii

In acest tutorial voi prezenta un exemplu de apel HTTP ( GET HTTP ) utilizat shield-ul Wifly

Wifly este un shield produs de Sparkfun care permite placii Arduino sa se conecteze la o retea wifi.

Cel mai simplu mod de a utiliza placa este sa folosim biblioteca creata de Sparkfun

Scopul acestui tutorial este sa construim un program care face o cautare pe google.ro folosind o retea wifi.

general, tutoriale Nici un comentariu

arduino assembler atingere atmega168 atmega328 bootloader brick buton buzzer CNC debug DHCP DNS Ethernet fire gsm/gprs http infrarosu Internet joystick lcd led lumina microcontroller microfon post potentiometru R-Dev-Ino releu rgb roboduino robot robot majordom senzor senzor PIR serial server servo shield space sunet telecomanda IR temperatura umiditate weather clock