Braccio (besturen 1)

De Braccio is op verschillende manieren te besturen. In dit artikel wordt beschreven hoe de braccio te besturen is met een versnellingsmeter en gyroscoop.

Accelerometer en gyroscoop

MPU 6050 is een IMU-sensor. Inertial Measurement Units (IMU’s) is een op zichzelf staand systeem dat lineaire en hoekbewegingen meet, meestal met een drietal gyroscopen en een drietal versnellingsmeters. Een IMU kan cardanisch of vastgemaakt worden, waarbij de integrerende hoeveelheden hoeksnelheid en versnelling in het sensor- / carrosserieframe worden uitgevoerd. Ze worden in de literatuur gewoonlijk de snelheidsintegrerende gyroscopen en versnellingsmeters genoemd.

IMU-sensoren bestaan meestal uit twee of meer onderdelen. Als u ze op prioriteit vermeldt, zijn dit de versnellingsmeter, gyroscoop, magnetometer en hoogtemeter. De MPU 6050 is een 6 DOF (vrijheidsgraden) of een zesassige IMU-sensor, wat betekent dat hij zes waarden als output geeft: drie waarden van de accelerometer en drie van de gyroscoop. De MPU 6050 is een sensor gebaseerd op MEMS-technologie (micro-elektromechanische systemen). Zowel de versnellingsmeter als de gyroscoop zijn ingebed in een enkele chip. Deze chip gebruikt het I2C- protocol (Inter-Integrated Circuit) voor communicatie.

Hoe werkt een versnellingsmeter?

Een accelerometer werkt volgens het principe van het piëzo-elektrische effect. Stel je een kubusvormige doos voor met een kleine bal erin, zoals op de afbeelding hierboven. De wanden van deze doos zijn gemaakt met piëzo-elektrische kristallen. Telkens wanneer u de doos kantelt, wordt de bal door de zwaartekracht gedwongen in de richting van de helling te bewegen. De muur waar de bal tegenaan botst, creëert kleine piëzo-elektrische stroompjes. Er zijn drie paar tegenoverliggende muren in een balk. Elk paar komt overeen met een as in de 3D-ruimte: X-, Y- en Z-assen. Afhankelijk van de stroom die door de piëzo-elektrische wanden wordt geproduceerd, kunnen we de hellingsrichting en de grootte ervan bepalen.

Hoe werkt een gyroscoop?

Gyroscopen werken volgens het principe van Coriolis-versnelling. Stel je voor dat er een vorkachtige structuur is die constant heen en weer beweegt. Het wordt op zijn plaats gehouden met behulp van piëzo-elektrische kristallen. Telkens wanneer u deze opstelling probeert te kantelen, ervaren de kristallen een kracht in de richting van de hellingshoek. Dit wordt veroorzaakt door de traagheid van de bewegende vork. De kristallen produceren dus een stroom in overeenstemming met het piëzo-elektrische effect, en deze stroom wordt versterkt. De waarden worden vervolgens verfijnd door de host-microcontroller. Bekijk deze korte video waarin wordt uitgelegd hoe een MEMS-gyroscoop werkt.

Het volgende is de pinout-configuratie om MPU6050 aan te sluiten op Arduino.

Het volgende is de pinout-configuratie om MPU6050 aan te sluiten op Arduino.

De MPU6050 testen met Processing

Deze test is om de beweging van de sensor in MPU6050 te controleren. Om de grafische interface van de beweging te bekijken, moeten we Processing gebruiken. De verwerking kan hier worden gedownload.

https://processing.org/

Er zijn bepaalde bibliotheken voor Arduino en Processing die moeten worden gedownload voordat we beginnen.

Voor Arduino:

https://github.com/jrowberg/i2cdevlib

Installeren

Om te verwerken;

http://toxiclibs.org/downloads/

Installeren

Programmeren

Eerst moeten we Arduino gebruiken om de MPU6050 te programmeren en vervolgens verwerken om naar de GUI te kijken. Zodra de MPU6050-bibliotheken zijn geladen, zal er een voorbeeldprogramma zijn met de naam MPU6050_DMP6. Het is te vinden in:

-> Voorbeelden. Open vervolgens het voorbeeldprogramma via Bestand -> Voorbeelden -> MPU6050 -> Voorbeelden -> MPU6050_DMP6.

MPU6050 DMP6

Het programma geüpload naar Arduino, maar onthoud dat de gebruikte poort en de bandbreedte moeten worden gewijzigd in 115200. Zodra het programma is geüpload, opent u de seriële monitor en wordt u gevraagd om een willekeurig teken in te voeren.

Seriële monitor

De monitor zal de waarden van de sensor weergeven.

Ga nu verder met Processing. MPUteapot is een programma dat voor dit proces moet worden gebruikt. Het programma kan worden gedownload van hier

MPU Theepot-test

Zodra het programma is geopend en de bibliotheken aanwezig zijn, moeten bepaalde waarden worden bewerkt.

Verander waarden

De waarden van de com-poort en bandbreedte moeten worden bewerkt volgens de instellingen in Arduino. Zodra de waarden zijn bewerkt, drukt u op Uitvoeren. De volgende video is het resultaat van mijn experimenten met MPU6050

MPU-theepottest

Bron:https://maker.pro/arduino/tutorial/how-to-interface-arduino-and-the-mpu-6050-sensor

Programmeren van de arm

Zoals ik al eerder zei, wordt Braccio geleverd met bepaalde bibliotheken en de codering daarvoor is heel anders.

Code Verklaring

Het volgende is de kalibratiecode en zoals getoond verwijst de waarde 20 naar de snelheid van de armbeweging en dan zijn de volgende waarden de hoeken van de servo. In dit geval is alles 90 behalve de laatste, aangezien dit de grijperwaarde is.

Dit is anders dan post naar de gebruikelijke Arduino-code, omdat we meestal de servo zouden definiëren en de servo moeten schrijven. Deze taal van de programmering moest worden gevolgd wanneer het braccio-schild wordt gebruikt. De uitdaging is om de code aan te passen aan onze behoeften.

Ik heb een voorbeeldcode gevonden uit de volgende YouTube-video.

De poging is om 3 servo’s aan te sturen met mpu6050. Ik heb dezelfde code gebruikt, maar de code aangepast aan het braccio-schild.

Code

De code was niet gemakkelijk in te kaderen. Had verschillende methoden van vallen en opstaan om het te doen, maar was het eindelijk gelukt.

De testvideo vindt u onderaan de pagina.

Met behulp van mobiele applicatie

De volgende methode die ik wilde proberen, was om een mobiele applicatie te gebruiken om de servomotoren te besturen.https://www.hackster.io/KureBasRobotics/gesture-controlled-trainable-arduino-robot-arm-via-bluetooth-4a1e57

De bovenstaande link was echt heel nuttig om me te helpen begrijpen hoe ik dit mogelijk kon maken. Ik heb dezelfde app gebruikt die in de zelfstudie wordt gebruikt en heb de code gewijzigd.

Code

# include <Wire.h>
# definieer MIN_PULSE_WIDTH 650
# definiëren MAX_PULSE_WIDTH 2350
# definiëren DEFAULT_PULSE_WIDTH 1500
# definiëren FREQUENTIE 50
# include <Arm.h>
# omvatten <Servo.h>

Basisservo;
Servo schouder;
Servo elleboog;
Servo wrist_rot;
Wrist_ver servo;
Servo grijper;
int servo1;
int servo2;
int servo3;
int servo4;
int servo5;
int servo6;

ongeldige setup () {
Serial.begin(9600);
   Braccio.begin();
}

void loop() {

if (Serial.available ()> = 2)
{
    unsigned int servopos = Serial.read ();
    unsigned int servopos1 = Serial.read ();
    unsigned int realservo = (servopos1 * 256) + servopos;
    Serial.println (realservo);

    if (realservo> = 1000 && realservo <1180) {
    int servo1 = realservo;
    servo1 = kaart (servo1, 1000,1180,0,180);
    Arm.ServoMovement (20, servo1, 15, 180, 170, 0, 73);
    vertraging (10);

    }

    else if (realservo> = 2000 && realservo <2180) {
      int servo2 = realservo;
      servo2 = kaart (servo2,2000,2180,0,180);
       Arm.ServoMovement (20, 0, servo2, 180, 170, 0, 73);
      vertraging (10);

    }

else if (realservo> = 3000 && realservo <3180) {
      int servo3 = realservo;
      servo3 = kaart (servo3, 3000, 3180,0,170);
       Arm.ServoMovement (20, 0, 15, servo3, 170, 0, 73);
      vertraging (10);
    }
else if (realservo> = 4000 && realservo <4180) {
      int servo4 = realservo;
      servo4 = kaart (servo4, 4000, 4180,0,180);
        Arm.ServoMovement (20, 0, 15, 180, servo4, 0, 73);
      vertraging (10);
    }

   else if (realservo> = 5000 && realservo <5180) {
      int servo5 = realservo;
      servo5 = kaart (servo5, 5000, 5180,0,180);
        Arm.ServoMovement (20, 0, 15, 180, 170, servo5, 73);
      vertraging (10);
    }

   else if (realservo> = 6000 && realservo <6180) {
      int servo6 = realservo;
      servo6 = kaart (servo6, 6000, 6180,10,73);
       Arm.ServoMovement (20, 0, 15, 180, 170, 0, servo6);
      vertraging (10);
    }

}

}

int pulseWidth (int hoek)
{
int pulse_wide, analog_value;
pulse_wide = kaart (hoek, 0, 180, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
analog_value = int (float (pulse_wide) / 1000000 * FREQUENCY * 4096);
return analog_value;
}

Om één lus van de servo uit te leggen, wordt de waarde eerst gedefinieerd binnen een bereik zoals in het geval van servo 2 zijn 2000 tot 2180 en vervolgens in kaart gebracht. Het bereik zal variëren van 0 tot 180 en het laatste deel is dat de servo dienovereenkomstig beweegt.

Braccio met MPU6050 en Bluetooth

Flex-sensor

Ik kon de arm besturen met de gyrosensor, maar ik kon de grijper niet bedienen. Dus zoals voorgesteld door mijn regionale instructeur Ohad, besloot ik een flex-sensor te maken om de grijper te besturen.

Ik heb online gezocht naar het maken van een flex-sensor en er zijn om te beginnen talloze verwijzingen op youtube en Instructables.

https://www.youtube.com/watch?v=ibiFqtv0j-Y

http://www.instructables.com/id/DIY-Bend-Sensor-Using-only-Velostat-and-Masking-T/

De werking van de flex is vrij eenvoudig. Het heeft een laag resistief materiaal tussen de elektroden en de verandering in weerstand wordt gemeten wanneer de sensor gebogen is.

-flex sensor zijn sensoren die in weerstand veranderen afhankelijk van de mate van buiging op de sensor.

-ze zetten de verandering in de bocht om in elektrische weerstand- hoe meer de bocht, hoe meer de weerstandswaarde.

-flex sensor produceert is analoge waarde

Er is een specifieke manier om de sensor en het diagram hiervoor te verbinden.

Volgens de verschillende tutorials die ik op het net zag, waren de vereisten eenvoudig. De volgende zijn de materiële vereisten.

-Papier
-Koperen plaat / aluminiumfolie
-Jumper draden
-Isolatietape
-Een stuk plastic laken
-Potlood

DIY Flex-sensor

De eerste stap is om de gewenste maat (maat van je vinger) te meten en vervolgens het plastic, papier en koper in die maat te knippen.

Snijmaterialen tot strips

Ik heb een potlood gebruikt en aan beide kanten over het papier gekrabbeld. Dit is erg belangrijk omdat dit het resistieve materiaal is dat wordt gebruikt om de weerstand te meten.

Resistief papier maken

Het volgende deel was om de jumper aan elk van de koperen strips te bevestigen.

Koperstrip met jumper

Dit deel is in feite alle materialen in een sandwich plaatsen en inpakken. Ik plaatste de isolatietape, daarop de plastic folie en vervolgens de koperstrip. De plastic strip is alleen om de sensor bij het buigen weer rechtop te zetten.

De laatste laag of de middelste laag is het gekrabbelde papier.

Flex-sensor maken

Ik heb toen alle lagen ingepakt en dit is de laatste flex-sensor.

Flex-sensor

Ik heb een multimeter gebruikt om de weerstand van de flex-sensor te meten, maar ik kon geen waarden meten. Ik heb al mijn verbindingen gecontroleerd en alles was in orde. De fout die ik maakte was het krabbelen op papier. Hoe donker het gekrabbel, hoe beter de weerstandswaarde. Dus ik moest het papier verwijderen en het donkerder maken.

Opmerking: een andere manier om de waarden van de flex-sensor te controleren, is door de spanning ervan te controleren. Het programma daarvoor is te vinden in Arduino voorbeeldprogramma’s

Bestand> Voorbeelden> Basis> Analoge spanning

Flex-sensor

Deze flex-sensor werkte.

Nu moest ik de eerder geschreven code een beetje veranderen om de flex-sensor te accommoderen en de grijper te besturen.

Code

# include <Arm.h>
# include <Wire.h>
# include <I2Cdev.h>
# omvatten <MPU6050.h>
# omvatten <Servo.h>

Basisservo;
Servo schouder;
Servo elleboog;
Servo wrist_rot;
Wrist_ver servo;
Servo grijper;
MPU6050 accelgyro;

int16_t bijl, ay, az;
int16_t gx, gy, gz;

dubbele accXangle;
dubbele accYangle;
dubbele accZangle;

dubbele gyroXangle = 180;
dubbele gyroYangle = 180;
dubbele gyroZangle = 180;

uint32_t timer;
leegte setup ()
{
pinMode (A0, INPUT);

Braccio.begin();
Wire.begin ();

Serial.begin(38400);

Serial.println (“start I2C”);

accelgyro.initialize ();

Serial.println (“Testverbinding”);
Serial.println (accelgyro.testConnection ()? “MPU6050 Connected Successfully”: “Connection Unsuccessful”);
timer = micros ();
}

void loop()
{
int sensorValue = analogRead (A0);
zwevende spanning = sensorValue * (5.0 / 1023.0);
Serial.println (spanning);

accelgyro.getMotion6 (& ax, & ay, & az, & gx, & gy, & gz);

accXangle = (atan2 (ax, az) + PI) * RAD_TO_DEG;
accYangle = (atan2 (ay, az) + PI) * RAD_TO_DEG;
accZangle = (atan2 (ax, ay) + PI) * RAD_TO_DEG;

dubbele gyroXrate = ((dubbele) gx / 100,0);
dubbel gyroYrate = – ((dubbel) gy / 100,0);
dubbele gyroZrate = – ((dubbele) gz / 100.0);

gyroXangle + = gyroXrate * ((dubbel) (micros () – timer) / 1000000);
gyroYangle + = gyroYrate * ((dubbel) (micros () – timer) / 1000000);
gyroZangle + = gyroZrate * ((dubbel) (micros () – timer) / 1000000);
// Serial.println (gyroXangle);
//Serial.println(gyroYangle);
//Serial.println(gyroZangle);

                       // (stapvertraging, M1, M2, M3, M4, M5, M6);
// Arm.ServoMovement (0, gyroZangle, gyroYangle / 2, gyroYangle, gyroYangle / 2, gyroXangle, 10);

// timer = micros ();
if (spanning> = 0,14)
{
//Braccio.ServoMovement(15, gyroZangle, gyroYangle / 2, gyroYangle, gyroYangle / 2, gyroXangle, 73);
//gripper.write(73);
base.write (gyroZangle);
shoulder.write (gyroYangle / 2);
elbow.write (gyroYangle);
wrist_rot.write (gyroYangle / 2);
wrist_ver.write (gyroXangle);
grijper.write (73);
timer = micros ();
}
anders
{
    //Braccio.ServoMovement(15, gyroZangle, gyroYangle / 2, gyroYangle, gyroYangle / 2, gyroXangle, 10);
    //gripper.write(10);
     base.write (gyroZangle);
shoulder.write (gyroYangle / 2);
elbow.write (gyroYangle);
wrist_rot.write (gyroYangle / 2);
wrist_ver.write (gyroXangle);
grijper.write (10);
timer = micros ();
}
//gripper.write(10);
vertraging (1);

}

Braccio met MPU6050 + Flex-sensor

Alle bestanden kunnen worden gedownload vanaf HIER

BRON: http://archive.fabacademy.org/

Accelerometer en gyroscoop

Hoe werkt een versnellingsmeter?

Hoe werkt een gyroscoop?

De MPU6050 testen met Processing

Geef een reactie Reactie annuleren