KITtyBot

Over dit project

Inleiding

Ik wilde een lopende robot met vier poten doen, meer in een "zoogdier"-stijl dan de normale "spin" of "insect". De inspiratie komt van de bekende Boston Dynamics-robots en andere vierpotige onderzoeksrobots. Het maken van zo'n robot is een hele uitdaging, omdat hij vrij gemakkelijk omvalt vanwege een hoog zwaartepunt en de voeten onder het lichaam in plaats van uit te spreiden naar de hoeken.

Het doel was om een ​​goedkope robot te bouwen met Arduino en goedkope microservo's. Deze oplossing heeft natuurlijk zijn beperkingen. Je kunt niet verwachten dat het perfect is, maar het is me nu gelukt om een ​​paar robots te bouwen die het loopgedrag kunnen uitvoeren zoals beschreven in deze film. En het beste doen met een heel klein budget is een uitdaging op zich en misschien iets waar jongens van zwaar gefinancierde onderzoeksprojecten nooit mee te maken krijgen. :)

Er werd al vroeg vastgesteld dat een studie van omgekeerde kinematica (IK) nodig was om het goed te doen. De code heeft een reeks vergelijkingen om gewrichtshoeken te berekenen op basis van gewenste voetbewegingen. Deze kunnen verder worden gebruikt in functies voor een aantal terugkerende taken, zoals het doen van een lichaamsbeweging (met handen en voeten in de tegenovergestelde richting bewegen) en het maken van een volledige voetbeweging (optillen in een bepaalde richting en weer neerleggen).

De volgende uitdaging is om gangstudies te doen, d.w.z. te definiëren hoe de robot moet lopen en draaien in termen van lichaamsbewegingen en voetbewegingen. Mijn robot maakt voortdurend gebruik van statisch stabiele gangen. Eén voet per keer wordt opgetild en in een nieuwe positie gezet. Het lichaam rust op de andere drie poten en om niet te kantelen moet het zwaartepunt binnen het statief blijven dat deze voeten vormen. Ik ontwikkelde vier standaardgangen - vooruit, achteruit, links en rechts. Dit maakt op zijn beurt gebruik van de bewegingsfuncties van de voet en het lichaam om te worden gecombineerd tot een volledige reeks.

Ik ontwierp ook een functie voor synchrone servobewegingen. In sommige gevallen maken meerdere servo's verschillende slagen gedurende een bepaalde tijd. Dit moet worden gesynchroniseerd om vloeiende bewegingen te bereiken.

Last but not least gebruik ik een volledig onbeschermde LiPo-batterij. Dit kan riskant zijn, het grootste gevaar is om het te snel of te diep te ontladen. Het eerste gevaar wordt vermeden zolang het niet per ongeluk wordt kortgesloten. Een normale RC-batterij heeft een ontladingssnelheid van 25 C, wat in dit geval 12 A toestaat. De UBEC zal onder alle omstandigheden voorkomen dat deze hoger is dan 2 A. Het tweede gevaar wordt voorkomen door een bewakingsfunctie in de software. De spanning wordt gemeten op een van de analoge pinnen en als deze lager wordt dan 7,0 V, wordt de robot tot rust gebracht.

En tot slot moet ik benadrukken dat de batterijen moeten worden opgeladen met een speciaal gebouwde oplader en met de gebruikelijke zorg moeten worden behandeld, laat het opladen nooit onbeheerd achter. De batterij moet losgemaakt worden van de robot (gebruik klittenband om hem te monteren) en opgeladen worden in een vuurvaste zak of op zijn minst met een veilige afstand tot ontvlambare materialen, zodat een brand kan worden ingesloten en niet kan worden verspreid. Berg je batterijen ook veilig op.

Als u niet bekend bent met LiPo-batterijen, raadpleeg dan een plaatselijke R/C-hobbywinkel en koop batterijen samen met een geschikte oplader en eventueel een vuurvaste tas/container om op te laden en op te bergen. Deze items staan ​​vaak vol waarschuwingsborden. Reda ze en gebruik je eigen gezond verstand. :)

De robot bouwen

Print de onderdelen volgens de meegeleverde bestanden. Neem even de tijd om de foto's te bekijken en erachter te komen hoe u de onderdelen in elkaar zet voordat u begint. Ik ben Scandinavisch, maar deze instructie is verre van het niveau van een IKEA- of LEGO-instructie :)

Het heupgewricht moet eerst worden gemonteerd. Ik heb dubbelzijdige tape van goede kwaliteit gebruikt om de onderdelen aan elkaar te hechten. Ze kunnen ook worden gelijmd, maar in het geval dat een kapot onderdeel moet worden gerepareerd, is het onmogelijk om ze te demonteren, een kapotte servo leidt tot vervanging van de complete verbinding.

Plaats de servosteun aan de onderkant van een servo, in lijn met de aandrijfas. Sluit je dan aan bij een andere servo met zijn as loodrecht. De afbeelding hieronder toont het heupgewricht voor rechtsvoor en linksachter. Voor de twee andere hoeken moeten spiegelverbindingen worden gemaakt.

Voordat u verder gaat, is het een goed idee om ervoor te zorgen dat alle 12 servo's gecentreerd zijn. De beste manier is om de printplaat (of breadboard, zie hieronder) in elkaar te zetten, alle servo's aan te sluiten en de code te laden. Wanneer de Arduino wordt opgestart, worden alle servo's gecentreerd (commandosignaal 90 graden). Het is nodig om de middenposities later te verfijnen als de robot is gemonteerd.

De volgende stap is het bevestigen van het onderdeel genaamd dij, het "bovenste lidmaat" van een beensamenstel. Dit onderdeel heeft uitsparingen die passen bij de servohoorns die normaal bij de servo worden geleverd. Lijm hoorns in de uitsparingen. Zorg ervoor dat u een lijm gebruikt die geschikt is voor het verbinden van het 3D-geprinte materiaal en het nylon plastic waarvan de hoorn is gemaakt. Het lijmpistool dat ik gebruikte werkte prima, ik heb echter wisselend succes gehad met CA-lijm (sommige merken werken, andere niet).

Het bovenbeen is in een hoek van 60 graden met het heupgewricht verbonden. Probeer een positie te vinden die zo dicht mogelijk bij deze hoek komt als de servo's gecentreerd zijn. Zet de hoorn op de servo-spline vast met de meegeleverde schroef (vaak de kortere van drie die bij een servo worden geleverd). Hieronder staan ​​​​twee foto's van gemonteerde dij en heup, servohoorn niet inbegrepen voor de duidelijkheid (of nooit gemodelleerd uit luiheid van mijn kant).

Het onderste deel van het been moet ook worden gemonteerd. In dit geval wordt een servo met schroeven aan het beengedeelte bevestigd. Er worden schroeven meegeleverd met de servo (vaak twee langere "hout" schroeven).

Nu kunnen de poten op het lichaam worden gemonteerd. Er zijn twee delen die ik "bumper" heb genoemd en die zich aan de voor- en achterkant van de robot bevinden (zoals de bumpers op een auto). Ze hebben uitsparingen voor servohoorns, net als het dijgedeelte. Lijm er hoorns in. Schuif vervolgens de servosteun van een bovenbeen in het daarvoor bestemde gat in de body. Wanneer dit aan beide zijden is gedaan, kan de montage door de bumper worden vastgezet. Laat de benen ongeveer 12 graden naar buiten wijzen (een 20 mm uitspoor van het been). De bumper wordt aan de carrosserie bevestigd met behulp van overgebleven (langere) servoschroeven.

Eindelijk kunnen de onderbenen van de robot worden vastgemaakt. Ze moeten in de tegenovergestelde richting van de dij worden geplaatst, zodat de punt van de voet zich precies onder het heupgewricht van elk beensamenstel bevindt.

Hiermee wordt de robot geassembleerd. Het zou eruit moeten zien zoals op de afbeelding hieronder. Merk op dat het ontwerp van de robot iets is gewijzigd ten opzichte van de bovenste afbeelding en het filmpje. De carrosserie is opnieuw ontworpen om het ontwerp te vereenvoudigen en robuuster te maken. De servosteun en hoorn voor het heupgewricht zijn van plaats verwisseld. Monteer dus volgens de 3D-beelden en vermijd verwarring door de foto's en filmclips.

Natuurlijk kunnen de hoeken van elk gewricht niet precies de vereiste hoeken hebben, het aantal splines op een SG-90-servo is 21, wat leidt tot een hoek van 17 graden tussen twee posities. U kunt de robot het beste binnen 10-20 graden monteren, de resterende fout moet worden aangepast door de neutrale positie in de code te wijzigen, zie verderop in deze instructie. Het is misschien een goed idee om alle servo's opnieuw aan te sluiten en de Arduino op te starten en de neutrale posities te controleren en indien nodig wat mechanische aanpassingen uit te voeren (een verbinding een of twee spiebanen verplaatsen). Je hebt de neiging om per ongeluk de servo's te draaien wanneer je ermee werkt.

De elektronica aansluiten

Er zijn twee opties, alles op één breadboard of een printje maken met de meegeleverde Fritzing-vijl. U kunt problemen ondervinden met de spanning in het breadboard als u niet oppast bij het aansluiten van alle stroom- en aardleidingen op de servo's. In extreme gevallen kan één servo 600 mA verbruiken en slechte verbindingen leiden tot grillig gedrag. De PCB heeft zeer brede kopersporen voor de stroomkabels, dus als je gewoon goed soldeert, werkt het prima.

Er is geen aan / uit-schakelaar in mijn ontwerp. De robot wordt eenvoudig in- en uitgeschakeld door de batterij aan te sluiten. Als je er een wilt toevoegen, moet het na de batterijconnector zijn, waarbij de 7,4 V-voeding naar zowel de Arduino als de UBEC wordt onderbroken.

Breadboardversie

Het is mogelijk om de Pro Mini, connectoren voor de servo's en de meeste andere elektronica op één breadboard van halve grootte te hebben. Ik teken het schema in de onderstaande afbeelding. Zorg ervoor dat u korte jumperdraden gebruikt, vooral voor de 5 V-voedings- en massaverbindingen naar de servo's. De servoconnectoren zijn gewoon extra lange mannelijke headers die in stukken van drie worden gesneden en in het breadboard worden gedrukt.

Wat niet op de foto te zien is, is de batterij en de UBEC. Er kan wat soldeerwerk nodig zijn om dit te repareren om een ​​connectorfitting op de batterij te bevestigen. Vanaf de connector moeten twee jumperdraden worden aangesloten op de onderste "powerrail" van het breadboard om de Pro Mini te voeden (verbonden met RAW en GND). Sluit ook twee weerstanden van de 7,4 V-voeding aan op de A0-pin. 2.2k gaat van de positieve kant en 1k van de grond. Dit verdeelt de spanning, die meer dan 8 V is op een volle batterij, tot een waarde onder 5 V die kan worden gemeten door de analoge pin.

De uitgangszijde van de UBEC heeft een servoconnector. Het is best handig om een ​​header met twee mannen op de bovenste "stroomrail" toe te voegen. Zet het ergens in het midden zoals op de afbeelding om ervoor te zorgen dat de stroomverdeling naar de servo's zo evenwichtig mogelijk is.

De IR-ontvanger moet worden aangesloten op A1 en 5V-voeding hebben. De pinnen op de ontvanger zijn lang genoeg om direct in de gaten op het breadboard te passen.

Er is een schema hieronder en een afbeelding van hoe het afgewerkte breadboard eruit zou kunnen zien. Merk op dat de afbeelding een oudere versie van de robot toont met verschillende pinouts en aansluitingen. Het geeft nog steeds een idee over het aansluiten van jumperdraden en servoconnectoren.

Het breadboard wordt met zijn zelfklevende achterkant aan de body bevestigd. Richt het zo dat de hoek met de servo's aangesloten op de pinnen D3, D4 en D5 (rechtsboven in het schema) zich in de voor-/linkerhoek van de robot bevindt en zorg ervoor dat het bord gecentreerd is op het lichaam (juiste midden van zwaartekracht is van vitaal belang).

PCB-versie

Ik heb hieronder een Fritzing-bestand toegevoegd. Dit kan worden gebruikt om een ​​PCB te produceren, hetzij door te bestellen bij de service van Fritzing, hetzij door bestanden te exporteren voor de fabricage van PCB's. Ik heb een serie foto's gemaakt om de montage hieronder te laten zien. De print is op maat gemaakt voor deze robot met connectoren naar alle servo's, IR en spanningsmeting. Maar er zijn ook connectoren uitgebroken van de resterende pinnen. Deze kunnen worden gebruikt om andere apparatuur aan te sluiten als u de robot in de toekomst wilt uitbreiden.

Er zijn kleine "pads" op de body die in de hoeken van de print passen. Ook hier moet de hoek met de D3 naar D5 connector aan de voorkant/links zitten. Er zijn montagegaten op de printplaat, maar ik heb alleen een stuk dubbelzijdig plakband op de body gebruikt om deze te bevestigen. Het blijft op zijn plaats.

Batterij

De batterij is aan de onderkant bevestigd met klittenband. Er is hiervoor een plat oppervlak op het lichaam. Een LiPo-batterij van 7,4 V/500 mAh heeft normaal gesproken de vormfactor van ongeveer 55x30x10 mm (een paar mm geven of nemen) en hij past redelijk goed op deze plek.

Ten slotte kan de robot worden "getoucheerd" door de servodraden in mooie bundels te binden, zodat hij er tijdens het lopen niet door kan struikelen. Het geeft de robot ook een mooi uiterlijk alsof het een vierbenig wezen is dat rondloopt en geen hoop servodraden. :)

Voltooien

Voordat de robots worden gebruikt, moeten de middenposities nauwkeurig worden afgesteld. Dit wordt gedaan door de array servodeg0 in de code te bewerken:

const float servodeg0[12] ={90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90};  

De waarden zijn in volgorde alfa, beta gamma en voor/links, achter/links, voor/rechts, achter/rechts. Dus beta rechtsvoor is de achtste positie in de array of servodeg0[7] (de nummering van de array begint met 0).

Er is ook een array genaamd servodir die de draairichting van de servo's definieert.

const int servodir[12] ={ +1, +1, -1, -1, -1, +1, -1, -1, -1, +1, +1, +1}; // Draairichting (positief is servo tegen de klok in)  

De servo's die ik heb gebruikt, bewegen van 0 tot 180 graden tegen de klok in. Ik heb ergens gelezen dat er servo's de andere kant op gaan. In dat geval moeten de tekens van de array-servodir de hele tijd veranderd zijn.

Start de Arduino en controleer de hoeken op alle servo's. Maak maatregelen en kijk of alles er recht en symmetrisch uitziet. Afstanden en hoeken moeten overeenkomen met de onderstaande afbeelding.

Het is moeilijk om bij elke meting binnen de exacte millimeter te zijn, binnen een cm is redelijk. Kijk welke wijzigingen nodig zijn en tel/aftrek deze op bij de waarde in de array servodeg0. Dit zal zeker een paar iteraties vergen voordat alles correct is. Je eindigt met een servodeg0-array die er ongeveer zo uitziet (een echt stuk code van een van mijn robots). En het belangrijkste is dat je uiteindelijk een robot moet hebben die op alle vier de poten rust en rechtop staat.

 const float servodeg0[12] ={80, 95, 100, 100, 110, 90, 100, 115, 100, 80, 80, 100}; 

Nu is alles klaar. Geniet ervan!

Misschien een paar tips voor onderweg.

De servo's moeten na een tijdje mogelijk opnieuw worden gekalibreerd. De middenpositie kan na verloop van tijd verschuiven. Controleer af en toe of alles op één lijn ligt.

Als je alles correct hebt gemaakt en nog steeds een robot hebt die omvalt, controleer dan het zwaartepunt. De batterij kan worden verplaatst om dit in evenwicht te brengen, wat een voordeel is met het gebruik van klittenband.

En nog een keer. Behandel uw LiPo-batterijen met zorg.

Verdere verbeteringen

Door mijn robot hier in te dienen, nodig ik ook mensen uit om het ontwerp te verfijnen, door meer functies toe te voegen of om een ​​iets andere lay-out te maken (groter, kleiner, cooler). De code moet opnieuw kunnen worden gebruikt op een robot met een iets andere lay-out of grootte. Onderstaande schets laat zien wat de verschillende constanten in de code zijn. Alle IK- en bewegingsfuncties zouden nog moeten werken als er een robot met verschillende maatregelen wordt gemaakt. Het laat ook zien dat de coördinaten zijn gedefinieerd, x wijst in de voorwaartse richting.

En natuurlijk zou het interessant zijn als mensen functies aan de robot zouden toevoegen. Er zijn verschillende knoppen op de afstandsbediening die functies kunnen krijgen (waarom niet dansen of een andere reeks bewegingen doen als er op een knop wordt gedrukt).

Persoonlijk experimenteer ik met analoge input. Ook heb ik gewerkt met een "draaiend lopen" gang om de robot enigszins te kunnen sturen, of koersafwijkingen te corrigeren met behulp van gyro of kompas. En ik voegde ook een ultrasone sensor en autonoom gedrag (obstakels vermijden) toe. Mijn huidige project is om analoge besturing te combineren met autonoom en alles te laten bedienen vanaf een smartphone. Dit heeft me gedwongen om veel nieuwe dingen te leren (Blynk, ESP6822, seriële communicatie tussen apparaten enz.) /P>

/* Een IR-gestuurde versie van de KITtyBot 2. Het maakt gebruik van Arduino Pro Mini en de door mij ontworpen printplaat (Fritzing sketch Kittybotmini.fzz) Het is gebaseerd op de vorige robots KITtyBot en KITtyBot mini met een IR-afstandsbediening om de robot te besturen. Het maakt gebruik van een NEC (Adafruit)-afstandsbediening en de IRLib2-bibliotheken, zie https://github.com/cyborg5/IRLib2. Download IRLib2-bibliotheken uit de repository en installeer ze volgens de instructies. De algemene afmetingen zijn vergelijkbaar met de originele KITtyBot, maar er is een verplaatsing tussen de gamma- en alfa-as van 12 mm (de servo's zijn op elkaar gemonteerd). gegeven het meest stabiele gedrag. Gemaakt door Staffan Ek 2017*/#include #include #include  // Voeg eerst de decodeerbasis toe#include  // Voeg alleen het protocol toe dat u bent gebruikmakend van #define MY_PROTOCOL NEC //Definieert de IR-besturing (NEC) lang Vorige;IRrecv My_Receiver(A1);//Ontvangen op pin A0IRdecodeNEC My_Decoder;const int servonum =12; // Het aantal servo'sServo servo [servonum]; // Maak servo objectconst float servodeg0 [12] ={90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90};// Neutrale posities voor de servo's aangepast van nominale 90 graden ( een kalibratie is nodig om deze waarden aan te passen)float servodegnew[servonum]; // De gewenste servopositie in gradenfloat servodegold [servonum]; // De oude (of huidige) servopositie// Update onderstaande waarden naar de KITtyBot miniconst int servodir [12] ={+1, +1, -1, -1, -1, +1, -1, -1, -1, +1, +1, +1}; // Draairichting (positief is servo tegen de klok in)const float pi =3.1416;const float alfa0 =pi / 6; // De neutrale positie van alfa (30 deg)const float beta0 =pi / 3; // De neutrale positie van bèta (60 deg)const float jointlength =50; // De lengte van een beendeel (beiden hebben dezelfde lengte)const float width =120; // De breedte (afstand tussen voeten in y-richting, met toeout0 toegevoegd) const float leng =120; // De lengte (afstand tussen voeten in x-richting) const float distag =12; // Afstand tussen alfa- en gamma-asconst float toeout0 =20; // De buitenste afstand van de voeten vanaf het gamma-servocentrum (de afstand waarmee de voet naar buiten is gericht)const float-beenlengte0 =2 * jointlength * cos(alfa0);const float gamma0 =asin(toeout0 / (leglength0 + distag)); // De neutrale positie van gamma (door uitspoor 20 mm en distag 12 mm)const float bodyradius =sqrt(pow((width / 2), 2) + pow((leng / 2), 2)); // De lengte van diagonaal (afstand van midden tot voethoek) const float phi0 =atan (breedte / lengte); // De hoek van bodyradius vs de x (naar voren wijzende) asconst float height0 =sqrt(pow(leglength0 + distag, 2) - pow(toeout0, 2)); // De normale hoogte van de robot (als er hoeken of afstanden zijn gewijzigd, moet deze worden bijgewerkt) float leglength [4] ={sqrt(pow(height0, 2) + pow(toeout0, 2)), sqrt(pow(height0, 2) + pow(toeout0, 2)), sqrt(pow(height0, 2) + pow(toeout0, 2)), sqrt(pow(height0, 2) + pow(toeout0, 2)) };// Startwaarden van beenlengte niet-ondertekend lange tijdstap =500; // Tijd die elke reeks nodig heeft (bij gebruik van servomove())int staplengte =40; //De lengte van een stap in x-richting tijdens het lopen (voorwaartse en achterwaartse kruip)float phi =20; // draaihoek tijdens draaien (in graden, geen radialen!)// Variabel voor bewegingsfloat footpos[12]; // Voetposities, bestel LeftFrontxyz, LeftRearxyz, RightFrontxyz, RightRearxyzfloat stepturn [12] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Voetbeweging bij een bocht// De voetposities worden gekalibreerd met hun respectievelijke startpositiesconst float jointangle0[12] ={alfa0, beta0, 0, alfa0, beta0, 0, alfa0, beta0, 0, alfa0, beta0, 0};float-jointtangle[12]; // Gebruik een vector voor hoeken en bestel LeftFrontAlfaBetaGamma etcconst int voltagepin =A0; // De toegewezen pin voor spanningsmeting lowvolt =0; // Een variabele die de robot stopt als de spanning <7,0 Vint-modus =0; // De huidige geordende loopmodus; vooruit, achteruit, links, rechts ongeldig setup () { Serial.begin (9600); Serial.println ("KITtyBot mini"); //Deze regels zijn alleen om de configuratie te controleren. Kan worden verwijderd. Serial.print("Gamma0:"); Serieel.println(gamma0); Serial.print("Beenlengte0:"); Serial.println(beenlengte0); Serial.print("Bodyradius:"); Serial.println(bodyradius); Serial.print("Phi0:"); Serieel.println(phi0); Serial.print("Hoogte0:"); Serieel.println(hoogte0); servo[0].bevestigen (3); servo[1].bevestigen (4); servo[2].bevestigen (5); servo[3].bevestigen (6); servo[4].attach(7); servo[5].attach(8); servo[6].bevestigen (2); servo[7].bevestigen (A3); servo[8].attach (12); servo[9].attach (11); servo[10].attach(10); servo[11].attach(9); for (int i =0; i  2 * voeglengte) lresultaat =2 * voeglengte; // Als de beenlengte hoger is dan mogelijk, worden sommige volgende functies onstabiel return lresult;}float legright(float dx, float dz, float gamma) { float lresult =sqrt(pow(leglength0 - (dz / cos(gamma0 - gamma)), 2) + pow(dx, 2)); if (lresultaat> 2 * voeglengte) lresultaat =2 * voeglengte; // Als de beenlengte groter is dan mogelijk, worden sommige volgende functies onstabiel return lresult;}// Beta, het "kniegewricht"float beta (float leg) { float bresult =2 * acos(been / (2 * gewrichtslengte)); return bresult;}// Alfa, De andere hip servofloat alfafront (float dx, float beta, float been) { float resultaat =(beta / 2) - asin (dx / been); return aresult;}float alfarear(float dx, float beta, float been) { float aresult =(bèta / 2) + asin(dx / been); return aresult;}// Voetposities geven op basis van een draaihoek f (in graden). Stepturn wordt gebruikt om footpos-waarden ongeldig te maken turnpos(float f) { stepturn[0] =bodyradius * cos(phi0 + (f * pi / 180)) - leng / 2; stepturn [1] =lichaamsradius * sin(phi0 + (f * pi / 180)) - breedte / 2; stepturn [3] =lichaamsradius * cos(pi - phi0 + (f * pi / 180)) + leng / 2; stepturn [4] =lichaamsradius * sin(pi - phi0 + (f * pi / 180)) - breedte / 2; stepturn [6] =lichaamsradius * cos (2 * pi - phi0 + (f * pi / 180)) - lengte / 2; stepturn [7] =lichaamsradius * sin (2 * pi - phi0 + (f * pi / 180)) + breedte / 2; stepturn[9] =lichaamsradius * cos(pi + phi0 + (f * pi / 180)) + lengte / 2; stepturn[10] =bodyradius * sin(pi + phi0 + (f * pi / 180)) + width / 2;}// Berekent servoposities (in graden) op basis van gewrichtshoeken in de functie hierbovenvoid servopos() { for ( int i =0; i <12; i++) { servodegnew[i] =servodeg0[i] + servodir[i] * (jointangle[i] - jointangle0[i]) * 180 / pi; }}// Het servo-algoritme voor gecontroleerde en gesynchroniseerde bewegingen. Alle servo's moeten hun eindpositie bereiken aan het einde van een timestepvoid servomove() { int servotimeold[servonum]; // Lokale variabele voor de tijd van de laatste servopositie int servotimenew [servonum]; // Lokale variabele voor de huidige tijd wanneer de servo int SERVOPULSE [servonum] is geplaatst; // Lokale variabele om naar de servo-driver float servodeg [servonum] te schrijven; // Lokale variabele voor de huidige servopositie float servodegspeed [servonum]; // Lokale variabele voor de gewenste verlaging van de servosnelheid per milliseconde unsigned long starttime =millis(); // Tijdstempel de start van het algoritme unsigned long timenow =starttime; // Tijd nu resetten voor (int i =0; i   
 
 Aangepaste onderdelen en behuizingen  
 The body of the robot. Carries the PCB and battery.At each end of body, like bumper on a car. You should have two of these.Supports the hip joint. Print four of theseThe upper limb of leg. Print four.The lower limb (or foot). Print four.All parts put together. Not for printing.
 
 
 Schema's  
 This is a Fritzing file to allow PCB production. Use it to order from Fritzing themselves or export to a suitable format an manufacture elsewhere. kittybotmini_XKZYltyQVJ.fzz