Salutare! Numele meu este Valentin Popescu si sunt absolvent al Facultatii de Matematica-Informatica din cadrul UVT. In facultate am devenit din ce in ce mai pasionat de electronica si in cele din urma am decis ca e momentul sa-mi cumpar o placa Arduino dupa ce lucrasem cu una in cadrul unui proiect. Multumesc domnului Viorel Spinu pentru tot suportul oferit.

Unul dintre proiectele pe care le-am realizat este un etulotest pe care l-am facut folosind un senzor MQ-3 care poate fi achizitionat de la RoboFUN

De ce ai nevoie?

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

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.

Salutare

In cele ce urmeaza va voi prezenta constructia robotului SWIRL cu care am participat la concursul Search & Rescue propus de Gabi (Ro-Bot-X) pe site-ul LMR.

Regulamentul prevede ca fiecare robot participant la concurs sa navigheze in mod autonom printr-un labirint cu latimea minima a culoarelor de 12 inch, sa gaseasca o jucarie plasata in labirint, sa o ia printr-o metoda oarecare (nu exista restrictii) si sa o scoata din labirint. Dimensiunea robotului trebuie sa fie mai mica de 12 inch.

Pana la locul in care se gaseste jucaria, robotul trebuie sa faca cel putin 4 curbe iar jucaria nu are voie sa aiba nici un element care sa o faca mai usor detectabila, balize, elemente reflectorizante, etc. De asemenea robotul nu are voie sa “vada” peste ziduri.

Labirintul l-am facut din carton de 1mm, iar inaltimea peretilor este de 17 cm. Din cauza grosimii foarte mici a peretilor, 1 mm, am avut ceva probleme la intoarcerile de 180 de grade, deoarece senzorii pierdeau foarte usor peretele din raza de detectie. Pentru a elimina aceasta problema am lipit cate o fasie de carton de 3-4cm pe capetele libere ale peretilor pentru a le “da grosime”.

Constructia partii hardware a robotului a fost destul de simpla si a durat 2-3 zile.

Partea de procesare si control este asigurata de un Arduino Uno plus un shield facut de mine cu scopul de-a conecta mai usor servomecanisme. Partea de deplasare este asigurata de 2 servouri standard, modificate pentru rotatie continua, fiecare servo avand atasata cate o roata cu diametrul de 70mm. In spatele robotului se afla o roata cu miscare libera.

Pentru detectia peretilor si a obstacolelor pe lateralele robotului am folosit 2 senzori Sharp iar pentru detectia obstacolelor si peretilor din fata robotului am folosit un senzor homemade format din 4 LED-uri ultrabright si 3 fotorezistoare.

Pentru prinderea “tintei” am proiectat un ansamblu cu un cleste actionat de un servo care la randul sau era deplasat sus-jos de un al doilea servo.  Aceasta solutie nu a ajuns sa fie folosita datorita dificultatilor pe care le voi descrie in continuare.

Alimentarea am realizat-o cu ajutorul unui acumulator LiPo 7,4V – 1200mA si a unui stabilizator de tensiune de 5V.

Prima abordare a fost de a programa robotul sa detecteze jucaria cu ajutorul senzorului frontal amintit mai sus, sa o apuce cu gripperul (cleste) iar apoi sa se intoarca la intrarea/iesirea din labirint optimizand daca era posibil traseul de intoarcere. Simplu, nu?  Nici vorba

Una dintre cele mai mari probleme este detectia obiectului plasat in labirint. Daca detectia unui obiect izolat nu este foarte complicata, treaba se schimba radical in cazul unui obiect plasat in apropierea unui perete.

Evidentierea caracteristicilor unui obiect de mici dimensiuni (cativa cm) aflat pe fondul altui obiect s-ar putea realiza probabil cu ajutorul unei camere video + procesarea aferenta sau un senzor de mare rezolutie (laser?)+procesarea aferenta. Din pacate senzorul meu cu fotorezistente nu este nici una nici cealalta, asa ca dupa numeroase teste si incercari acesta metoda a esuat si a fost abandonata

De la metoda “detecteaza si apuca” am trecut la metoda “apuca ce poti si da-ti seama ca ai facut-o” ?!?!?!

Treaba e mai simpla decat pare. In locul ansamblului cu clestele, am  montat un cerc facut dintr-o banda de plastic pe care am prins o banda de velcro (scai) care este rotit continuu de servoul care ar fi trebuit sa ridice clestele.  Pe jucarie (o zana , nu am gasit altceva mai potrivit in cei 1,5 metri cubi de jucarii ai junioarei mele) este montata cealalta jumatate de scai.

In timp ce robotul se deplaseaza prin labirint, cercul se roteste continuu. In momentul in care jucaria este atinsa, cele 2 jumatati de scai se lipesc iar zana este transportata spre spatele robotului unde agata parghia unui intrerupator si inchide un contact.

In momentul in care se inchide contactul, rotorul nu se mai…roteste iar robotul face stanga-imprejur si porneste spre iesire.

Aici aveti cateva poze cu robotul:

Iar aici una dintre parcurgerile labirintului si salvarea zanei – http://www.vimeo.com/29541322.

Iar aici puteti vedea personalitatea si hotararea care i-au caracterizat inceputul carierei precum si viziunea unica asupra aspectului pe care ar trebui sa-l aiba un labirint – http://www.vimeo.com/29601814.

-=Seba=-

Ceea ce se poate observa din filmuletul de pe YouTube este un proiect de licenta la Universitarea din Petrosani, specializarea Automatica, anul acesta, elaborat de  Matei Paul  si coordonat de Bogdan Sochirca.

Este doar prima faza dintr-un proiect care sper sa continue in viitor. In caz ca va place da-ti va rugam un LIKE pe YouTube. Toate componentele sunt cumparate de pe www.robofun.ro.

S-au folosit 5 “bending sensor” pentru manusa, un arduino si 5 servo motoare.

Au fost mai multe incercari “esuate” care au dus la final la cea ce se poate observa .

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

Creat de echipa HackerSpace Bucuresti (Liana Marinescu, Andrei Iusan, Adrian Stratulat, Razvan Craciun, Ionut Cotoi).

Kit-ul pentru contructie este disponibil la Robofun.

Sa dorit crearea unui “Radar” mai rudimentar, radar ce se poate monta pe o platforma mobilă sau pe un robot. Ideea este destul de simplu de pus in practică, mai greu este integrarea acesteia într-un sistem de genu un roboţel care sa iasa dintr-un labirint, sau realizarea unei harti a unui plan mult mai mare decât raza senzorului folosit, sau poate chiar şi alte aplicaţii.

Programele realizate suportă extraordinar de multe îmbunătăţiri, vreau sa precizez de la început că este primul meu program scris în Processing şi al doilea pentru Arduino.

Materiale necesare (totul gasiţi pe www.robofun.ro, mai puţin sursa de laborator pe care o folosesc, dar se poate înlocui cu orice fel de sursă):

-placă de dezvoltare de tip Arduino (UNO în cazul meu)

-servo motor (Nu cu rotaţie completă)

-senzor de distanţă cu infraroşu (Sharp GP2Y0A21YK (10cm – 80cm) am folosit)

-sursă de laborator (trebuie să folosiţi o sursă separată de curent (baterie, sau alt tip de alimentare) deoarece senzorul de distantă este destul de sensibil la variaţiile de tensiune care apar în timpul mişcării servomotorului)

-softul în care s-a realizat partea grafică (http://www.processing.org/, este gratis şi arată exact ca cel în care programăm arduino)

Comanda motorului servo se va face din cât în câte grade dorim. In prima figură se observă rezultatul pentru un salt in 3 in 3 grade (pe o jumatate de rotatie 180 grave vom avea 60 de citiri)

Fig. 1. Citire din 3 in 3 grade

Am putea spune ca putem obţine informaţii mai detaliate legate de corpurile ce se află în jurul senzorului.

Un alt exemplu se poate observa in figura de mai jos daca optăm pentru un salt din 10 în 10 grade

Fig.2. Citire din 10 în 10 grade

Comanda servomotorului se realizează de pe pinul 9 iar citirea distanţei de pe pinul A0, după cum se poate observa şi în figura de mai jos

Fig.3. Conexiunile plăcii

Unde    -firul rosu este comanda servomotorului

-firul negru e pentru a uni masele sursei de alimentare cu a lui Arduino

-firul alb este pentru citirea datelor de la senzor

Senzorul se montează pe servomotor (cel mai simplu cu bandă dubluadezivă). Colegii spun că seamănă cu Wally

Fig.4. Senzorul şi servomotorul

În figura 5 putem observa o imagine de ansamblu.

Fig.5. Imagine de ansamblu

În Processing se poate urmării inclusiv datele primite de la serial

Fig.6. Captură din Processing

Codul sursă cu explicaţiile aferente

Cod sursa Arduino

#include <Servo.h>  // bibliotecă pentru comanda servo motorului

const int analogInPin = A0;   // pe pinul A0 recepţionez date de la senzor

int a=200;

int b=222;                   // a, b 2 variabile folosite pe post de indentificatori ca să

//stiu ce trimit programului processing şi cum sa le interpretez

Servo myservo;

int distance=0;              //distanta pana la obiect

int pos = 0;                   // cate grade ma misc

void setup() {

myservo.attach(9);       // atasam comanda servomotorului pe pinul 9

Serial.begin(9600);     // setăm portul serial

}

void loop() {

for (int i=0; i<180; i=i+10)  // i este folosit pentru a şti din cîte în cîte grade mă misc

{

myservo.write(i);

float distance = 12343.85*pow(analogRead(0), -1.15);

// convertim ce citesc de la senzor în distanţă

if (distance<10) distance=10;

if (distance>80) distance=80; // elimin ce ar fi sub 10 si peste 80 cm,

Serial.write(a); delay(50);    // trimit date pe serial prima data val lui a adica 200

Serial.write(i);delay(50);        // trimit pozitia unde se afla servomotorul

Serial.write(b);delay(50);       // trimit val lui b adica 222

Serial.write(distance);            // trimit distanta

delay(50);

}

myservo.write(0);                     // a ajuns servo la 180 de grade si il aducem iara la inceput

delay(1000);               // asteptam 1 secunda pt ca să parcurga 180 de grade

}

Cod sursa Processing

import processing.serial.*;

Serial myPort;

int val;

int aux=0;

int a=0;

int v1=0;

int v2=0;

int v3=0;

int v4=0;

int ung=180;

void setup()

{

size(200, 200);

size(600, 400);

myPort = new Serial(this, “COM5″);   // trebuie modificat pentru ce com este arduino

background(255);

}

void draw()

{

fill(100);

if ( myPort.available() > 0) {  // If data is available,

aux=val;    val = myPort.readChar();  // citim datele care sunt trimise pe serial

if (aux != val) {

if (a==3) {v4=val; a=a+1;}    // îmi aranjey datele primite astfel ca sa stiu

if (a==2) {v3=val; a=a+1;}   // care este distanta si care este unghiul

if (a==1) {v2=val; a=a+1;}

if (a==0) {v1=val; a=a+1;}

if (a==4) a=0;

}

if( v1==200 && a==0)

{

println(“unghiul= ” + v2);

println(“valoare= ” + v4);

arc(300,400,v4*7,v4*7, radians(ung),radians(ung+10));

// trasăm arcul corespunzator distantei

redraw();

ung=ung+10;

if (ung==360){ ung=180; background(255);}

}

delay(20);

}

}

Sugestii şi discuţii cu mare plăcere pe forum:

30.03.2011                                                                  Sochirca Bogdan

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:

Bluetooth Mate Gold - imagine vectorială generată pentru Fritzing. Componentele pentru proiecte Fritzing sunt incluse în subsolul articolului.

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.

Conectarea pinilor dispozitivului Bluetooth Mate Gold în montajul cu senzorul de temperatură tmp102 așa cum se observă pe un dispozitiv fizic. Culorile conectorilor (firelor) corespund culorilor utilizate în proiectul fizic. Compară cu imaginea vectorială de mai sus, a convertorului logic.

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:

Logic convertor - imagine vectorială generată pentru Fritzing. Componentele pentru proiecte Fritzing sunt incluse în subsolul articolului.

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:

Conectarea pinilor logic level convertor-ului în montajul cu senzorul de temperatură tmp102 așa cum se observă pe un dispozitiv fizic. Culorile conectorilor (firelor) corespund culorilor utilizate în proiectul fizic. Compară cu imaginea vectorială de mai sus, a convertorului logic.

• 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:

Montarea mini-breadboard-ului în carcasă. Acesta se potrivește perfect în spațiul rezervat bateriei.

Mini-breadboard-ul montat în carcasă.

Montarea plăcii Arduino Uno și conectoarele pentru Bluetooth (sus), alimentare (firele roșii la 3,3 și 5 Vcc), masă (firul negru) și bus-ul I2C (dreapta jos).

Montarea dispozitivului Bluetooth și a Logic Convertor-ului direct pe mini-breadboard.

Conectarea terminalelor Logic Convertor-ului.

Dispozitivul Bluetooth și Logic Convertor-ul montate pe mini-breadboard văzute din partea opusă, acolo unde se vor monta firele de legătură în breadboard.

Conectarea firelor de legătură pentru Bluetooth, direct în breadboard.

Conectarea firelor de legătură: alimentarea și traseele de masă.

Arduino, Bluetooth și Logic Converter-ul văzute de deasupra.

Arduino, Bluetooth și Logic Converter-ul văzute de deasupra.

Arduino, Bluetooth și Logic Converter-ul văzute de deasupra. Finalizare.

Conectarea senzorului de temperatură tmp102, în afara carcasei.

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:

Aplicația, așa cum apare în bara de status pe un laptop MacBook cu SO OS X 1.0.6.6. În dreapta este prezentată localizarea în limba română.

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.

Vreau sa controlez un robot dupa o telecomanda, cu  infrarosu.