Een stappenmotor besturen met een AVR-microprocessor - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:19

Heb je wat weggevangen stappenmotoren van printers/schijfstations/etc rondslingeren?

Wat peilen met een ohmeter, gevolgd door een simpele drivercode op je microprocessor en je stapt in stijl.

Stap 1: Leer Steppers kennen

Kortom, je zult moeten uitzoeken waar alle kleine draden naartoe gaan.

De eerste stap is om erachter te komen of het een unipolaire of bipolaire motor is. Kijk eens naar Jones on Steppers voor wat diepere achtergrond, en dan naar Ian Harries' Site voor een eenvoudige methode om een onbekende motor te achterhalen. Lees je een beetje in en doe mee aan een walkthrough van deze motor die ik goedkoop heb gekregen. (Ze zijn nu te koop voor $ 0,99. Ze zijn klein, relatief licht, maar hebben niet veel koppel. Ik weet nog niet waar het goed voor zal zijn.)

Stap 2: Vind gemeenschappelijke grond

Dus je hebt vijf (of vier of zes) draden. Je motor zal twee helften hebben, en je kunt waarschijnlijk zelfs zien aan welke kant elke draad hoort.

Als je maar naar vier draden kijkt, heb je geluk - het is een bipolaire motor. Het enige dat u hoeft te doen, is uitzoeken welke twee paar draden bij elkaar passen. Als je een unipolaire motor hebt, of meer dan 4 draden, moet je je ohmeter doorbreken. Wat je zoekt is de gemeenschappelijke (aard)draad voor elke helft. Je kunt zien welke massa in een bipolaire motor is, omdat deze de helft van de weerstand tegen een van de polen heeft dan de polen over zichzelf. Afgebeeld zijn mijn aantekeningen van het aansluiten van draden op draden en het noteren van de weerstand (of als ze helemaal zijn aangesloten). Je kunt zien dat wit de grond is voor het onderste trio, omdat het de helft van de weerstand tegen rood of blauw heeft die ze tegen elkaar hebben. (Deze motor is vreemd en heeft geen middenaftakking op de bovenste magneetspoel. Het is alsof hij half bipolair, half unipolair is. Misschien zou je dit kunnen gebruiken om rotatie in de Rood-Wit-Blauwe spoel waar te nemen wanneer de Zwart-Gele spoel wordt aangedreven.)

Stap 3: Bepaal de stappenvolgorde

Ik wilde deze motor als een bipolaire aandrijven, dus ik negeer de witte aardingsdraad. Ik heb maar vier draden om me zorgen over te maken.

Misschien wilt u uw unipolaire motor sowieso als bipolair laten werken, omdat deze de hele spoel in beide fasen gebruikt in plaats van afwisselend tussen de twee helften van elke spoel. Meer spoel = meer koppel. Laat stroom door een paar lopen (let op de polariteit die je hebt gekozen) en laat dan tegelijkertijd stroom door het andere paar lopen. Wanneer u het tweede paar aansluit, let dan op welke kant de motor op draait. Schrijf dit op. Draai nu de polariteit om op het eerste paar dat je hebt gekozen. Sluit vervolgens het tweede paar weer aan met hun polariteit ook omgekeerd. Let op de richting. Hieruit zou u de volgorde moeten kunnen bepalen voor het draaien van de motor in beide richtingen. In mijn voorbeeld draaiden beide uiteindelijk tegen de klok in, dus als ik door de reeks stapte op dezelfde manier die ik koos, zal de motor CCW zetten.

Stap 4: De motor meenemen voor een proefrit

Als je nog niet bent uitgerust voor microprocessorprogrammering, zou je het slechter kunnen doen dan de Ghetto Development Kit of een van de verschillende PIC-programmeurs. Sluit de draden rechtstreeks aan op uw microproc en verbrand deze met de volgende code:

/* Spelen met het aandrijven van de kleine stappenmotoren. */

/* Inclusief vertragingsfunctie */ #define F_CPU 1000000UL #include /* Pin defs voor ATTiny2313 */ /* Volgorde met de klok mee */ #define BLUE _BV(PB0) #define BLACK _BV(PB1) #define RED _BV(PB2) #define GEEL _BV(PB3) #define DELAY 200 /* milliseconden tussen stappen */ int main(void){ DDRB = 0xff; /* Schakel output in op alle B-pinnen */ PORTB = 0x00; /* Zet ze allemaal op 0v */ while(1){ /* hoofdlus hier */ PORTB = BLAUW; _delay_ms(DELAY); POORTB = ZWART; _delay_ms(DELAY); POORTB = ROOD; _delay_ms(DELAY); POORTB = GEEL; _delay_ms(DELAY); } } Hoe simpel is die code? Echt eenvoudig. Het enige dat het doet, is een paar mooie definities maken, zodat ik de draden op kleur kan verwijzen in plaats van op hun pin-namen, en dan schakelt het ze in volgorde aan met een instelbare vertraging ertussen. Om te beginnen heb ik een vertraging van een halve seconde tussen de stappen gekozen. Zie de korte video voor de resultaten. Als je echt op je spel bent, tel dan het aantal stappen per cyclus om de hoekresolutie van de motor te bepalen. (Oh ja. PS. Rijdt gemakkelijk onbelast op 3.6v. Zie batterij in video.)

Stap 5: Zwaai het heen en weer

Dus je hebt het met de klok mee lopen. Nog iets interessants? Een beetje opschonen van de code, en we kunnen het heen en weer uitvoeren. Ik heb de volgorde met de klok mee in een array gezet, zodat je door de fasen kunt stappen met een eenvoudige for-lus. Nu kunt u de lus omhoog of omlaag laten lopen om met de klok mee of tegen de klok in te gaan.

int main(void){ const uint8_t delay = 50; const uint8_t met de klok mee = {BLAUW, ZWART, ROOD, GEEL}; uint8_t ik; DDRB = 0xff; /* Schakel output in op alle B-pinnen */ PORTB = 0x00; /* Zet ze allemaal op 0v */ while(1){ /* hoofdlus hier */ for (i=0; i<=3; i++){ /* stap door de kleuren met de klok mee */ PORTB = met de klok mee; _delay_ms(vertraging); } for (i=3; i>=0; i--){ /* stap door de kleuren ccw */ PORTB = met de klok mee; _delay_ms(vertraging); } }} Bekijk de pittige video voor het heen en weer.

Stap 6: Ik stap nooit half, omdat ik geen halve stap ben…

Afgezien van de Quest-tekst, is het half-stappen van je motor waar het is. U krijgt meer piekstroom, meer onmiddellijk koppel en tweemaal de hoekresolutie. Half-stappen in een notendop: in plaats van Blauw, Zwart, Rood, Geel, rijd je de motor met Blauw, Blauw+Zwart, Zwart, Zwart+Rood, Rood, Rood+Geel, Geel, Geel+Blauw. Het resultaat is dat je de helft van de tijd beide magneten tegelijk gebruikt. En gedurende de tijd dat beide sets zijn ingeschakeld, wijst de motor halverwege tussen de twee, waardoor de hoek tussen "stappen" kleiner wordt en de motor soepeler draait. Kun je dat opmaken uit de video? Ik weet het niet zeker… Nu ziet het deel van de code dat de halve stap doet er als volgt uit:

void halfStepping (uint16_t vertraging, uint8_t richting ){ uint8_t i; voor (i=0; i<=3; i++){ PORTB = richting; /* single-coil deel */ _delay_ms(vertraging); PORTB |= richting[i+1]; /* voeg in halve stap toe */ _delay_ms(vertraging); }} Het eerste PORTB-commando stelt een enkele pool in op positief en de rest op negatief. Dan wacht het. Vervolgens stelt het tweede PORTB-commando een tweede pool (op de andere wikkeling) in op positief, waarbij beide wikkelingen worden ingeschakeld voor 1,4x het koppel (en 2x de stroom). Een volledig programmaoverzicht is hieronder bijgevoegd. Er zijn nu twee arrays gedefinieerd (met de klok mee, tegen de klok in) en beide hebben elk 5 elementen om de i+1-invoer in de halfStepping-functie mogelijk te maken.

Stap 7: een motorstuurprogramma toevoegen

Tot zover goed.

Het enige probleem is dat de motor niet zo veel koppel lijkt te hebben, wat te wijten kan zijn aan het feit dat de microprocessor slechts ~ 50 mA per pin afgeeft. De voor de hand liggende volgende stap zou zijn om hem aan te sluiten op een motordriver om hem van meer sap te voorzien. Maar dan een beetje nadenken: ik rijd hem alleen met 5v en de weerstand van de spoelwinding is ~ 125 ohm. Dat betekent dat de motor maar 40 mA per pin trekt, en dat hij prima moet worden aangedreven door de (vlezige!) AVR-chip. Dus om meer spanning op de motor te krijgen, heb ik hem aangesloten op een SN754410 H-bridge-chip. De schakeling is vrij eenvoudig. Elke pin van de AVR gaat naar een ingang en de bijbehorende uitgangspinnen gaan naar de motor. De chip heeft 5v nodig voor het logische gedeelte en kan veel meer spanning opnemen in het motorgedeelte. Het heeft een beetje geholpen om het op 11.25v (drie 3.6v-batterijen) te laten draaien. Merkbaar meer koppel aan mijn vinger, maar het is nog steeds geen krachtpatser. Niet slecht voor een motor die kleiner is dan een nikkel, dat wel. En nu is het circuit een bipolaire stappenmotordriver voor algemeen gebruik geworden. 29 nov toegevoegd: Vannacht de motor een tijdje op 12v gedraaid en hij begon heet te worden. Ik weet niet zeker of het een resonantiefrequentieprobleem was of dat het gewoon te veel stroom was voor de wikkelingen. Hoe dan ook, wees een beetje voorzichtig als je deze kleine motor met grotere spanningen bestuurt.

Stap 8: Het einde

Dus wat heb ik geleerd? Het aansturen van een stappenmotor met een AVR (en een H-bridge-chip) is vrij eenvoudig, zelfs in de "fancy" half-stepping-modus.

Ik weet echter nog niet zeker wat ik met de kleine stappenmotoren ga doen. Eventuele suggesties?