Rocky Rover:Robotic Vision System PixyCam &Arduino 101

Over dit project

Op Intel Arduino 101 gebaseerde Rover met PixyCam!

Hackster Live-evenementen zijn geweldig! Intel sponsorde ons Hackster Dallas-evenement en stuurde ons een aantal Intel Arduino 101 om Rovers te bouwen. Bedankt Intel, bedankt Arduino. Dit is de Rover die ik voor het evenement heb gebouwd.

Ik heb dit apparaat gebouwd volgens deze tutorial van Johnathan Hottell. Hij heeft enkele video's gemaakt om de BLE Rover te bouwen. En het is gemakkelijk te volgen! Bekijk het hier. Hier is de video van Johnathan Hottell.

Ik heb de Rover met 4 motoren, dus ik heb dit gevolgd.

Na het bouwen van de Rover en het verbinden met Blynk. Ik besloot de build te verbeteren en een PixyCam toe te voegen. Ik heb de batterijhouder naar voren verplaatst, zodat ik een pan/tilt-camera kan monteren.

PixyCam

PixyCam maakt Robotic vision gemakkelijk gemaakt. Pixy is een snelle vision-sensor voor doe-het-zelf-robotica, het is gemakkelijk om Pixy een object te leren door op een knop te drukken. Het kan honderden objecten tegelijk volgen en levert alleen de gegevens die het volgt.

Ik besloot een Orange Pumpkin te volgen.

Het verbaast me hoe gemakkelijk het is om het aan de gang te krijgen. Hier is de link voor de instructies voor het aansluiten van PixyCam op Arduino. Klik hier voor de montagehandleiding voor Pan/Tilt mechanisme. Ik ben blij dat het veel foto's heeft, heel gemakkelijk te volgen. Ik volgde de installatie- en bouwinstructies, hoe te integreren met Arduino. Ik heb hun voorbeelden getest.

Dit is wat ik te weten ben gekomen over de API.

PixyCam Arduino-API

Pixy gebruiken met Arduino is heel eenvoudig. U voegt gewoon de SPI- en Pixy-headers toe:

#include  #include   

En maak een globale instantie van Pixy door deze kleine man buiten je setup() te plaatsen en loop() functies:

Pixy pixy;  

De belangrijkste methode in de Arduino-bibliotheek is getBlocks() , die het aantal objecten retourneert die Pixy heeft gedetecteerd. Je kunt dan kijken in de pixy.blocks[] array voor informatie over elk gedetecteerd object (één arraylid voor elk gedetecteerd object.) Elk arraylid (i ) bevat de volgende velden:

• pixy.blocks[i].signature Het handtekeningnummer van het gedetecteerde object (1-7 voor normale handtekeningen)

• pixy.blocks[i].x De x-locatie van het midden van het gedetecteerde object (0 tot 319)

• pixy.blocks[i].y De y-locatie van het midden van het gedetecteerde object (0 tot 199)

• pixy.blocks[i].width De breedte van het gedetecteerde object (1 tot 320)

• pixy.blocks[i].height De hoogte van het gedetecteerde object (1 tot 200)

• pixy.blocks[i].angle De hoek van het door het object gedetecteerde object als het gedetecteerde object een kleurcode is.

• pixy.blocks[i].print() Een lidfunctie die de gedetecteerde objectinformatie naar de seriële poort afdrukt

Het is dus eenvoudig om met Pixy te praten met je Arduino! Ga hier voor meer informatie over de Arduino-bibliotheek en API. Hier is de code die wordt gebruikt voor de Rover. Ik heb de originele BLE-code gewijzigd en objecttracking toegevoegd. Tijdens het instellen:

void setup() { ..... pixy.init(); ....}  

Hoofdlus ziet er ongeveer zo uit:

void loop() { ...... // lees pixy-gegevens en krijg blokken statisch int i =0; intj; uint16_t blokken; char buf[32]; int32_t panError, tiltError; blokken =pixy.getBlocks(); // als er blokken zijn if (blokken) { panError =X_CENTER-pixy.blocks[0].x; tiltError =pixy.blocks[0].y-Y_CENTER; panLoop.updatePan(panError); tiltLoop.update (tiltError); pixy.setServos(panLoop.m_pos, tiltLoop.m_pos); i++; // frame zou de Arduino doen vastlopen als (i%10==0) {int trackedBlock =0; sprintf(buf, "%d:\n gedetecteerd", blokken); Serial.print(buf); lang maxSize =0; for (j=0; j maxSize) { trackedBlock =j; maxSize =nieuweSize; } } int32_t followError =RCS_CENTER_POS - panLoop.m_pos; // Grootte is het gebied van het object. // We houden een lopend gemiddelde van de laatste 8. size +=pixy.blocks[trackedBlock].width * pixy.blocks[trackedBlock].height; maat -=maat>> 3; int forwardSpeed ​​=constrain(400 - (size/256), -100, 400); int32_t differential =(followError + (followError * forwardSpeed))>>8; int leftSpeed ​​=constrain(forwardSpeed ​​+ differentieel, -400, 400); int rightSpeed ​​=constrain(forwardSpeed ​​- differentieel, -400, 400); motor1->setSpeed ​​(linksSnelheid); //links motor3->setSpeed ​​(linksSpeed); motor2->setSpeed ​​(rechtsSnelheid); //links motor4->setSpeed ​​(rightSpeed); dubbele breedte =pixy.blocks[trackedBlock].width; if (breedte <=5) { } else if (breedte <20 &&!running) { Serial.println("running"); motor1-> rennen (VOORUIT); motor3->Run (VOORUIT); motor2-> rennen (VOORUIT); motor4-> rennen (VOORUIT); rennen =waar; } else if (breedte> 80 &&!running) { Serial.println("running"); motor1->rennen (ACHTERUIT); motor3->rennen (ACHTERUIT); motor2-> rennen (ACHTERUIT); motor4-> rennen (ACHTERUIT); rennen =waar; } else if (breedte>=20 &&breedte <=80 &&running) { motor1->setSpeed(128); motor2->setSpeed(128); motor3->setSpeed(128); motor4->setSpeed(128); motor2->run(RELEASE); motor4->run (RELEASE); motor1->run(RELEASE); motor3->run (RELEASE); rennen =onwaar; } } } }  

Om de Blynk te laten werken zonder dat de PixyCam hem bestuurt, plaatst u de lensdop erop. Het zorgt ervoor dat PixyCam het besturen van de bot niet hindert. Als dit project je interesse heeft gewekt om in Arduino te programmeren of PixyCam in je volgende project te gebruiken, klik dan op de knop "Project respecteren" en volg mij.

Stel gerust vragen.