Tinker Board: Un competitor de la Asus pentru Raspberry Pi

Raspberry Pi este lider în tot ceea ce înseamnă bricolaj cu un computer capabil să ruleze una dintre multele distribuții Linux. Asus încearcă aceeași piața cu un computer care pare a avea performanțe mai mari în raport cu Raspberry Pi 3.

Mai jos am făcut o listă cu diferențele majore dintre cele două plăci.

ASUS Tinker Board

ASUS Tinker Board

Dacă aș face o listă cu minusurile plăcii Tinker, acestea ar fi:

  • documentație – în acest moment pagina de documentație afișează “0 files found”.
  • o comunitate activă.
  • TinkerOS este un sistem de operare bazat pe Debian. Este un sistem de operare nou și vom avea de așteptat până vor apare aplicații care vor folosi la dezvoltări de aplicații cu Tinker.
  • suportă software pe 32 biți, Pi 3 suportă 64 de biți.
  • pentru o treime mai multă performanță, prețul este cu o treime mai mare comaprat cu Pi 3. Prețul pentru Tinker este de 59.99$, iar pentru un Pi 3 prețul este de 39.99$.

Plusuri:

  • un procesor mai performant comparat cu Raspberry Pi 3 (1.8GHz vs 1.2GHz).
  • mai multă memorie RAM (2GB de memorie DDR3).
  • capabilă să ruleze 4K video.

Cam acestea ar fi diferențele majore dintre cele două plăci. Majoritatea celorlalte specificații sunt comparative cu Raspberry Pi 3. Ambele au câte 40 de pini pentru intrări și ieșiri, dimensiunile diferă foarte puțin în favoarea plăcii Asus, ambele au conexiune WiFi, etc.

Tractobot: tractor robot care se conduce singur

Cum ar fi daca fermierii ar deveni operatori de calculator care doar supraveghează o trupă ordonată de roboţi capabili să lucreze pământul fără intervenţia tractoristului?

Roboţii capabili să facă activităţi autonome deja există şi sunt pregătiţi să preia o mare parte din responsabilitatea unui tractorist.

Tractobot este un proiect dezvoltat de Kyler Laird. Kyler a început să facă public tractorul autonom încă din 2016, iar primul lucru dezvoltat a fost un algoritm capabil să schimbe direcţia tractoului.

Proiectul a trecut prin multe etape de dezvoltare şi schimbări. Una dintre etapele care au dus la crearea unui tractor autonom a fost folosirea framework-ului ROS.

Tractobot este deja capabil să meargă în linie dreaptă, să întoarcă, şi să comande o seri întreagă de instrumente folosite la activităţile din agricultură.

Pe langă faptul ca proiectul în sine constă în transformarea unor tractoare normale în roboţi, costul total de transformare este destul de mic. Costurile totale sunt în jur de 2000 USD, ceea ce este foarte puţin pentur un astfel de proiect. Read more →

O platforma pentru roboţi de teren

Platforma Gears EdS are tot ce trebuie pentru a fi folosită în aplicaţii off-road. Partea de sus poate găzdui senzori, controlerul de motoare, bateriile, şi controlerul platformei. Chiar dacă preţul este destul de mare ($1,200.00 + $25.50 pentru transport) , senzorii, controlerele sau bateriile nu sunt incluse în kit.

Dacă tot am terminat de descris partea mai puţin frumoasă legată de costuri şi lipsurile kitului, există multe motive pentru care aş folosi platforma. Unul dintre ele ar fi şasiul. Şasiul are articulaţii care permite robotului să treacă peste obstacole. Roţile de 15 centimetrii ajută mult la traversarea obstacolelor înalte.

Motoarele de 12V au cutie de viteză cu o reducţie de 65.5:1. Deci viteză prea mare nu o să prindeţi cu robotul, însă oricum nu aceasta era ideea. Platforma trebuie să poată căra o greutate considerabilă pe teren accidentat. Deci un cuplu mare este necesar.

Dacă vreţi să experimentaţi noi roboţi pentru agricultură, inspecţie pe teren accidentat, sau cercetare în medii ostile, platforma Gears EdS este una dintre cele mai accesibile şi solide platforme din gama de experimentare.

Platforma robot Gears EdS

Platforma robot Gears EdS

Am reușit să fac kitul mBot Ranger să meargă autonom

Acum câteva săptămâni am scris o recenzie a kitului mBot Ranger. A fost pentru prima dată când m-am jucat cu un kit Makeblock, și da, am fost plăcut impresionat. Componente de calitate, o mulțime de opțiuni pentru extensii ulterioare, etc.

Experiența mea cu kitul mBot a continuat și am făcut robotul să funcționeze autonom.

După 30 de minute de lucru, am asamblat toate componentele hardware ale setului mBot într-un tanc robot. Mi-a plăcut foarte mult experiența de a construi ceva în stilul LEGO, cel puțin până am ajuns la partea de programare. Kitul poate fi programat folosind o aplicație de computer sau pentru dispozitive mobile.

Foarte curând am aflat că am probleme cu documentația, iar versiunea aplicației pentru smartphone nu era actualizată. Kitul nu era încă lansat când am facut recenzia.

Din fericire, am știut că robotul are un creier bazat pe Arduino Mega 2560. Fiind un fan Arduino, am știut că trebuie să încep să caut informații prin librăriile kitului.

După câteva minute de cercetare, am găsit pinii de care aveam nevoie pentru a controla cele două motoare de curent continuu. Lucrul cu senzorul cu ultrasunete a fost mult mai ușor. Folosesc biblioteca Makeblock pentru a citi distanța de la senzor.

Ideea era de a programa tancul robot pentru a detecta un obstacol, iar când senzorul detectează unul sau mai multe obstacole, robotul se întoarce până când senzorul nu mai detectează niciun obstacol.

Iată schița Arduino și rezultatul muncii mele cu kitul mBot Ranger.

Read more →

8 tutoriale pentru rezolvarea problemelor și îmbunătățirea performanței senzorului HC-SR04

A fost o perioadă, nu cu mult timp în urmă, când trebuia să plătiți sute de RON pentru un senzor capabil să detecteze obstacole. Acum, prețul mediu de vânzare a scăzut la doar câteva zeci de RON, iar senzorul ultrasonic HC-SR04 este cel mai bun exemplu.

Acest senzor ultrasonic poate fi achiziționat la un preț de aproximativ 6 RON pe robotesc.ro.

Senzorul oferă măsurători destul de precise la o distanță cuprinsă între 3 centimetrii și 4 metrii.

Din păcate senzorul mai întoarce rezultate eronate. Aceste rezultate eronate pot fi tratate într-un fel sau altul. Mai jos am făcut o listă de opt tutoriale care tratează cele mai frecvente probleme sau îmbunătățesc caracteristicile senzorului HC-SR04.

  1. Repair faulty HC-SR04 ultrasonic sensor (solve erratic no-readings problems)
    Uneori, acești senzori ieftini dau erori total aleatoriu, apoi lucrează din nou, și așa mai departe. În acest tutorial, veți învăța cum să le remediați prin adăugarea unui rezistor de 10K pe pinul de trimitere.
  2. Spread Spectrum Phased Array Sonar
    În acest tutorial, Graham Chow ne arată cum să modificăm doi senzori cu ultrasunete HC-SR04 pentru a construi un spectru larg de detectare.
  3. Making a better HC-SR04 Echo Locator
    Când senzorul HC-SR04 nu are obstacole în față sau când obstacolele sunt din material care nu reflectă undele ultrasonice, acesta returnează 0 sau rezultate eronate. Puteți afla din acest tutorial cum să corectați problemele de ecou fals și să faceți mai precis senzorul HC-SR04.
  4. Improve Ultrasonic Range Sensor Accuracy

    Precizia unui senzor ultrasonic depinde de temperatura mediului ambiant. Deci, dacă aveți nevoie de precizie, trebuie să aplicați principiul conform căruia sunetul se deplasează prin aer cu viteze diferite, în funcție de temperatură. Acest tutorial vă arată cum să aplicați acest principiu și să calculați distanța folosind temperatura ambientală.

  5. Hack an HC SR04 to a 3 pin sensor
    Senzorul HC-SR04 utilizează un pin pentru Trigger și unul pentru Echo. Deci, trebuie să utilizați doi pini ai microcontrolerului pentru a măsura distanța detectată de senzor. În acest tutorial, puteți afla cum să utilizați numai un singur pin al senzorului HC-SR04 pentru a calcula distanța detectată de senzor.
  6. Ultrasonic sensor comparison: HC-SR04, PING, Maxbotix
    Senzorul HC-SR04 nu este cel mai precis senzor ultrasonic de pe piață. Ei bine, este foarte departe de asta. Dar în acest articol, autorul îl compară cu alți doi senzori ultrasonici și oferă o scurtă trecere în revistă a diferențelor și cum ar trebui să arate programul care citește valori pentru senzori.
  7. Long Range Ultrasonic Distance Sensor
    Senzorul HC-SR04 face măsurători între 2 cm și 400 cm. Aveți cel puțin o opțiune de a crește raza de măsurare a senzorului. Metoda care mărește raza de măsurare folosește o tigaie de gătit pentru a reduce “câmpul vizual” (FOV) al senzorului. În acest experiment sa obținut o distanță măsurată de 9,24 metri.
  8. Arduino Radar Project
    Puteți construi sute de proiecte folosind senzorul HC-SR04. Acest radar DIY este unul dintre ele.

ROS funcţionează si cu jucării

Unul dintre utilizatorii ROS a lansat un driver ROS pentru robotul jucărie Anki Cozmo. Pentru cine nu știe, Cozmo este un robot de jucărie programat să exprime emoții, să vorbeasca, sau să fie un partener de joacă.

OTL, pentru că despre el este vorba, a reușit să folosească ROS pentru a controla de la distanță robotul, și chiar să acceseze camera pentru a detecta obiecte. Prin SDK-ul Cozmo, driverul ROS poate accesa senzorii, starea bateriei, sau poate mișca părților mobile ale robotului. În concluzie, cu driverul ROS aveți acces la funcționalitățile Cozmo.

Dacă aveţi deja un Cozmo şi sunteţi unul dintre utilizatorii ROS, puteţi descărca driverul ROS pentru a dezvolta noi funcţionalităţi ale jucăriei.

Testarea funcționlităților Cozmo cu ROS:

Au şi albinele înlocuitorul lor

Există o problema globală cu reducerea numărului de albine. Cauzele sunt naturale sau mai puţin naturale.

Schimbările de climă şi pesticidele folosite în agricultură au dus la reducerea numărului de albine. Efectul este global. Fermierii sunt direct afectaţi şi conştientizează cel mai bine efectul reducerii populaţiei de albine. Consumatorii sunt de asemenea afectaţi.

Japonezii au luat măsură şi au produs un robot albină capabil să polenizeze. Planul este de a folosi astfel de drone în agricultură pentru polenizarea culturilor.

Ideea nu este nouă. Undeva prin 2013 cercetătorii de la Harvard şi Northeastern plănuiau sa producă albine robot.

Robotul albină este o dronă de 4 centimetrii şi o greutate de 15 grame. Drona are ataşată o bandă impregnată cu un gel special conceput pentru a fixa granulele de polen.

Mai jos puteţi vedea robotul abină în acţiune:

HMAC – un șasiu pentru roboți de teren

HMAC Robot Kit

HMAC Robot Kit

Nu multe șasiuri de roboți pot fi folosite acolo unde poate fi folosit HMAC.

Unu: șasiul este metalic și are articulații
Doi: roțile mari sunt proiectate pentru a merge pe teren accidentat
Trei: motoarele de 12V sunt puternice și transmit puterea la roată folosind lanțuri
Patru: este scump (aprox. 750$ fără taxe vamale), al naibii de scump având în vedere că avem nevoie și de un driver de motoare, un controler și poate niște senzori
Cinci: față de acest kit, HMAC este cel puțin o generație peste

Un tutorial care te învață cum să implementezi un algoritm PID pentru un robot care urmărește o linie

Algoritm PID

Algoritm PID

PID este un acronim care vine de la Proportional-Integral-Derivative (PID). Ideea este de a lucra cu trei coeficienți astfel încât robotul să acționeze în modul cel mai optim posibil. Coeficienții sunt: proporțional, integral și derivativ.

Algorthmii PID sunt foarte des întâlniți în industrie pentru controlul roboților.

În acest tutorial, autorul descrie cum poate fi implementat un algorithm PID pentru controlul unui robot programat să urmărească o linie.

PID Algorithm Implementation: PID Line Following PIC Microcontroller Code

Am construit acest robot autonom pentru a detecta și a evita obstacolele. Codul este inclus în articol.

Acesta este un robot autonom capabil să detecteze și să evite obstacolele din calea sa. Platforma este ieftină și poate fi găsită la orice magazin de roboți.

Proiectul include o platformă cu patru roți, un Arduino UNO, și un senzor ultrasonic HC-SR04.

Robotul este programat să meargă înainte până întâlnește un obstacol. Dacă este detectat un obstacol, servo motorul rotește senzorul ultrasonic la stânga și la dreapta. Programul compara valorile returnate de senzor și pe baza unor calcule decide noua direcție de mers.

Acesta este codul Arduino:

/**
 * @file         Robot autonom cu Arduino UNO
 * @author       Calin Dragos pentru calinezu.ro
 * @version      V1.0
 * @date         13.10.2016
 * @description  Acesta este un sketch Arduino pentru un robot autonom capabil să detecteze și să ocolească obstacole*/
 

 
#include 
#include  
#include 

Servo myservo;

int ENABLE_A = 6;
int PIN_A1 = 3;
int PIN_A2 = 2;

int ENABLE_B = 11;
int PIN_B1 = 5;
int PIN_B2 = 4;

int SENSOR_DISTANCE;
int LEFT_SENSOR_DISTANCE;
int RIGHT_SENSOR_DISTANCE;
int SNZ_DISTANCE_L;
int SNZ_DISTANCE_R;
int LFT_SNZ_DIS;
int RGT_SNZ_DIS;

#define TRIG_PIN 7
#define ECHO_PIN 8
#define MIN_DISTANCE 40
#define MAX_DISTANCE 200
#define INTERVAL 200


NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DISTANCE);
  
void setup() {
  
   Serial.begin(9600);
   
  //pin mode for the DC motors
   pinMode (ENABLE_A, OUTPUT);
   pinMode (PIN_A1, OUTPUT);
   pinMode (PIN_A2, OUTPUT);

   pinMode (ENABLE_B, OUTPUT);
   pinMode (PIN_B1, OUTPUT);
   pinMode (PIN_B2, OUTPUT); 

   //pin mode for the ultrasonic sensor
   pinMode(TRIG_PIN, OUTPUT);
   pinMode(ECHO_PIN, INPUT);

   //for servo motor
   myservo.attach(9);

  //set the ultrasonic sensor to center   
   sensorCenter(); 
      
  //stop the motors
   stopMotors();   
}


void loop() {
     
    SENSOR_DISTANCE=sensorDistance();
    Serial.print("Front sensor distance is: ");
    Serial.println(SENSOR_DISTANCE);

    if(SENSOR_DISTANCE >= MIN_DISTANCE || SENSOR_DISTANCE==0)
      {
      goForward();
      Serial.println("Go forward");
        }
      else {
        
      //stop the motors
      stopMotors();

      LFT_SNZ_DIS=toTheLeft(); 
      RGT_SNZ_DIS=toTheRight();

          if(LFT_SNZ_DIS >= MIN_DISTANCE && LFT_SNZ_DIS >= RGT_SNZ_DIS) 
           {
            int NEW_SNZ_DIS_LFT;
             //try three times to escape
             for(int i=1;i<=3;i++){
              goLeft();
              Serial.println("Go left");
              delay(300);
              //stop the motors
              stopMotors();
               NEW_SNZ_DIS_LFT=sensorDistance();
               if(NEW_SNZ_DIS_LFT >=MIN_DISTANCE)
                  {
                break;
                }
              
             }
              sensorCenter();
              
          } 
            else if(RGT_SNZ_DIS >= MIN_DISTANCE && RGT_SNZ_DIS >= LFT_SNZ_DIS)
            {
             int NEW_SNZ_DIS_RGT;
             //try three times to escape  
             for(int j=1;j<=3;j++){
              goRight();
              Serial.println("Go right");
              delay(300);
              //stop the motors
              stopMotors();
              NEW_SNZ_DIS_RGT=sensorDistance();
              if(NEW_SNZ_DIS_RGT >=MIN_DISTANCE)
                  {
                break;
                }
              
             }
              sensorCenter(); 
          }
         else 
            {
              goBackward();
              Serial.println("Go backward");
              delay(500);      
              //stop the motors
              stopMotors();
              sensorCenter();
            }
      }

} 


void stopMotors(){
  analogWrite (ENABLE_A, 0);
  analogWrite (ENABLE_B, 0);
  digitalWrite (PIN_A1, LOW);
  digitalWrite (PIN_A2, LOW);
  digitalWrite (PIN_B1, LOW);
  digitalWrite (PIN_B2, LOW); 
  }
 
int sensorDistance(){
  int distance;
  int uS = sonar.ping();
  distance = uS / US_ROUNDTRIP_CM;
  if(distance !=0){
  return distance;
  delay(300);
    }
  }

void goForward(){
  analogWrite (ENABLE_A, 255);
  digitalWrite (PIN_A1, HIGH);
  digitalWrite (PIN_A2, LOW);
  analogWrite (ENABLE_B, 255);
  digitalWrite (PIN_B1, HIGH);
  digitalWrite (PIN_B2, LOW);
  }

void goBackward(){
  analogWrite (ENABLE_A, 180);
  digitalWrite (PIN_A1, LOW);
  digitalWrite (PIN_A2, HIGH);
  analogWrite (ENABLE_B, 180);
  digitalWrite (PIN_B1, LOW);
  digitalWrite (PIN_B2, HIGH);
  }


void goLeft(){
  analogWrite (ENABLE_A, 180);
  digitalWrite (PIN_A1, HIGH);
  digitalWrite (PIN_A2, LOW);
  analogWrite (ENABLE_B, 180);
  digitalWrite (PIN_B1, LOW);
  digitalWrite (PIN_B2, HIGH);
}


void goRight(){
  analogWrite (ENABLE_A, 180);
  digitalWrite (PIN_A1, LOW);
  digitalWrite (PIN_A2, HIGH);
  analogWrite (ENABLE_B, 180);
  digitalWrite (PIN_B1, HIGH);
  digitalWrite (PIN_B2, LOW);
}

void sensorCenter(){
  myservo.write(90);
  delay(500);
 }
 
void turnSensorLeft(){
  myservo.write(120);
  delay(500);
 }

void turnSensorRight(){
  myservo.write(60);
  delay(500);
 }
 
int leftSensorDistance(){
    int LEFT_SENSOR_DISTANCE;
    LEFT_SENSOR_DISTANCE=sensorDistance();
    return LEFT_SENSOR_DISTANCE;
  }

int rightSensorDistance(){
    int RIGHT_SENSOR_DISTANCE;
    RIGHT_SENSOR_DISTANCE=sensorDistance();
    return RIGHT_SENSOR_DISTANCE;
  }
    
int toTheLeft(){
    int LEFT_SENSOR_DISTANCE;
    turnSensorLeft();
    LEFT_SENSOR_DISTANCE=leftSensorDistance();
    Serial.print("Left sensor distance is: ");
    Serial.println(LEFT_SENSOR_DISTANCE);
    return LEFT_SENSOR_DISTANCE;
 }  

int toTheRight(){
    int RIGHT_SENSOR_DISTANCE;
    turnSensorRight();
    RIGHT_SENSOR_DISTANCE=rightSensorDistance();
    Serial.print("Right sensor distance is: ");
    Serial.println(RIGHT_SENSOR_DISTANCE);
    return RIGHT_SENSOR_DISTANCE;
 }  

Am testat navigarea autonomă: