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?

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

Salut Tehnorama, salut tuturor.

Astazi o sa va prezint cel mai mare proiect realizat de mine pana acum, un robot de tip Delta, bazat pe platforma Arduino.

Scurt intro: pasionat de robotica/electronica etc. Am descoperit conceptul de delta robot undeva in iarna si am luat destul de rapid decizia ca trebuie sa construiesc si eu unul. Aveam deja achizitionat un Arduino MEGA2560 si un LCD 20×4 Serial cumparate de pe Robofun.

A urmat conceperea planului de lucru. Acesta a fost destul de anevoios, pentru ca nu am gasit practic nici o metoda de aproximare a suprafetei de lucru a robotului (matematic vorbind). Asa ca a fost nevoie de teste. Multe teste. Dar nu insist tare mult pe acest aspect.

Componentele robotului:

• structura: platforma superioara si suprafata de lucru interconectate prin 3 brate. Toate elementele sunt din lemn, bratele au fost si chituite si vopsite negru mat.
• elemente mobile: brate superioare (plexiglass), articulatii sferice (otel), brate inferioare (tija carbon), platforma inferioara, mobila (plexiglass)
• controller: construit din plexiglass, cuprinde un Arduino MEGA2560, un LCD 20×4 Serial, si o placuta cu alte elemente: 2 led-uri RGB, un receiver infrarosu si un buton.
• servo-motoare: 3 servo-motoare towerPro 946r, cu specificatii interesante, dar pe care NU le recomand.

In ce consta cinematica robotului? Conversia translatiilor verticale a 3 servo-motoare in miscarea unui punct in spatiu (XYZ).
Dar sa trecem peste partea asta si sa vedem ce poate face.

Din pacate, versiunea de wordpress instalata pe tehnorama nu permite embed-ul de videoclipuri de pe Vimeo, asa ca o sa includ un link catre un album cu mai multe clipuri – video robot delta.

Cateva cuvinte despre clipuri. Cel mai dezbatut din ele este cel in care demonstrez modul de incrementare manual al acestuia. Multi au comentat cu privire la faptul ca platforma inferioara tremura. Da tremura, dar tremura dintr-un motiv bine definit, este vorba de printarea seriala. Ideea e ca printez pe ecranul serial la fiecare pas coordonatele xyz si unghiurile servo-urilor. Aceasta printare induce acel jitter. La minutul 1:30 dezactivez aceasta printare, si se remarca reducerea dramatica a jitter-ului. Nu e inca perfect, inca lucrez la remedierea completa.

Cam atat despre robotul meu, nu vreau sa intru prea mult in detalii, decat daca va fi cineva chiar interesat de acest subiect. Cei care doresc mai multe informatii pot parcurge aceasta prezentare, iar in cazul in care aveti si alte intrebari astept comentarii.

Va multumesc,
Bogdan.

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

De ceva vreme pe site-ul Arduino eram anuntati ca “ni se pregateste ceva”. Asteptarea a luat sfarsit… iata noul Arduino UNO!

Specificatiile le gasim aici. Diferenta principala fata de restul de placi Arduino consta in faptul ca nu mai foloseste “FTDI USB to serial” ci un Atmega8 cu un firmware special pentru conectarea pe USB la calculator. Au fost schimbate si etichetele I/O de pe placa, in scopul usurarii identificarii functiilor lor.

Este anuntata si viitoarea aparitie a versiunii 1.0 (de unde si numele UNO) a mediului de programare Arduino.

Cei de la Adafruit i-au luat zilele trecute un lung interviu lui Tom Igoe despre aceasta noua aparitie in universul Arduino. Merita urmarit aici.

Salutare !

Valkyrie CNC este o masina de debitare cu trei axe, controlata de calculator, ce foloseste o freza pentru a decupa in material forme, concepute cu ajutorul unui program CAD/CAM.

Intro

Inspiratia pentru acest proiect mi-a venit dand intr-o zi peste proiectul RepRap (www.reprap.org) o imprimata 3D cu trei axe controlata de un Arduino. Din acel moment am hotarat ca imi trebuie si mie asa ceva, asa ca am studiat in deataliu problema si am ajuns la concluzia ca imi va fi enorm de greu sa fac rost de componentele printate in plastic si de curelele dintate, restul nu ar fi fost o problema prea mare. Sa cumpar un kit nu s-a pus problema de la inceput din cauze de $$. Asa ca am cautat o alternativa in genul celor prezentate pe siteul RepRap sub denumirea de RepStrap, o masina intermediara care ar putea ajuta la construirea celei finale prin printarea componentelor necesare in house.

Tot cautand,  am dat peste siteul acestui tip: www.buildyourcnc.com, care pe langa faptul ca produce o gama de kituri de CNC-uri de vanzare, a postat pe site o gramada de filmulete in diverse etape ale asamblarii. Urmarind-ule mi-am facut o idee despre cum ar trebui facuta partea mecanica si am folosit ideeile prezentate acolo in constructia mea.

Intr-un final am decis ca este mai interesanta o constructie a unui CNC decat a unui RepRap, deoarece CNC-ul poate fi adaptat pentru a face acelasi lucru, marele plus fiind ca poate fi folosit si pentru a taia in material, ceea ce cu un RepRap este destul de greu datorita modului in care este conceput.

Asa a luat nastere Valkyrie CNC la care lucrez de aproximativ 1 an si jumatate.

Dupa cum spuneam in unul din articolele anterioare, am instalat pe MiniEric un shield cu ecran LCD color de tip Nokia. Scopul acestui ecran color este de a afisa harta cu pozitia robotului pe ea si obiectele intalnite in raza de detectie, si, ulterior, suprapunerea acestei harti de puncte cu harta reala a incaperii in care se afla robotul. O alta functie a ecranului va fi de a afisa obiectele detectate cu ajutorul camerei AVRcam. Acest proiect este inspirat de proiectul LoMoR.

ARDUINO QUADRAPOD - Prima parte

Componente  :

1  *  Arduino Duemilanove

8 *  SG-90 Nano

4  *  Suporturi pentru servo confectionate manual din o placa de plastic moale

4  *  Picioruse din fibra optica recuperata

1  *  Sasiu din 2 placute pentru cablaj imprimat

1  *  Mini-shield pentru conectarea servourilor

1  *  Baterie 4.8 v 1100 mAh

C1RM este al 2-lea robot al meu (primul robot a fost construit din curiozitate, urmarea o linie).  Menirea finala a acestui robot este aceea de a patrula fie pe un anumit traseu fie aleatoriu si sa stranga date despre temperatura, umiditate, concentratia de CO2 si de gaz. In cazul in care detecteaza o valoare peste un anumit nivel critic acesta va trimite un mesaj de avertizare pe un telefon sau va declansa un dispozitiv de alerta specific pentru fiecare conditie in parte.

Pentru realizarea acestui robot folosesc o placuta Arduino Duemilanove pe care vreau sa o inlocuiesc cu o placuta Arduino Mega. Momentan robotul se deplaseaza aleatoriu ocolind obstacolele din jurul lui. Pentru asta se foloseste de un sensor sharp, montat pe un servomotor, care vreau sa il inlocuiesc cu un sensor Ping. Folosesc un sensor de lumina care atunci cand este intuneric aprinde 2 LED-uri. Pentru controlul motoarelor folosesc L293D. Urmeaza sa ii montez un LCD 2×16 pe care va afisa activitatea din momentul respectiv, iar mai tarziu va afisa si valorile temperaturii, umiditatii, concentratiei de gaz si CO2 din zona respectiva. Momentan robotul nu face mare lucru si este simplu, sper ca de curand sa il pot aduce la forma sa finala pentru care a fost conceput. Programul robotului este doar pentru deplasare momentan.

Datorita faptului ca robotul meu foloseste mai multe servomotoare, am ales sa construiesc un modul dedicat pentru controlul lor. Desigur, este mai simplu sa cumperi unul gata facut, care are deja toate functiile definite si perfectionate, dar eu am vrut sa aibe aceasi forma cu restul modulelor si sa invat si eu cate ceva din programarea functiilor de control. Pe de alta parte, deja aveam portiunea de invatare a unei noi miscari cu ajutorul telecomenzii si stocare in EEPROM pe care vroiam sa le pastrez. Si bineinteles, aveam nevoie de comunicare prin I2C si nu serial, cum mai toate controlerele functioneaza.