Het automatiseren van mijn PROXXON Freesmachientje.

 

1) Inleiding

Op de HCC dagen in het jaar 2000 demonstreerde Martin de Roode een ‘graveer machientje’ gebouwd van MDF platen, schuiflagers, keukenlades. (nog te zien op:  http://home.wanadoo.nl/bjmboetekees  kies daar: projecten, engraving) 

Stappenmotoren met daaraan draadeinden moesten voor de bewegingen zorgen. Voor het verspanen gebuikte hij een Proxxon minidril (MICROMOT 220/E) die eenvoudig in te bouwen is.

 

In dit verhaal ga ik vertellen wat het gevolg is geweest van deze ontmoeting. Ik heb nu een freesmachine die bestuurd wordt door een microcomputer.

Dit stuk bevat geen foto’s. Wilt U die zien, ga dan naar http://www.henkzelf.nl/Images/FreesMachImages.htm .

De freesmachine kan nu:

·        naast het voor de hand liggende freeswerk,

·        de printplaten die ik ontwikkel automatisch boren,

·        ook asjes op dikte kan frezen / slijpen

·        tandwieltjes maken.

Zo heb ik voor een kennis twee tandwielen met zelfs ‘schuine’ tanden voor een oliepomp van een klassieke Fiat Topolino gemaakt omdat die niet meer te krijgen waren. Dat kostte wel veel moeite om het apparaat dat te leren, maar ja, met een versleten tandwiel draait de motor van een voorloper van de Fiat 500 in de soep, en zou hij die auto’s alleen nog als hondenhok kunnen gebruiken.

 

Ik ga geen complete beschrijving maken waarmee U mijn ontwerp precies zou kunnen nabouwen. Eerlijk gezegd denk ik dat ik daar ook niet meer aan zou beginnen. In plaats daarvan ga ik vertellen over mijn ontwerp overwegingen / beslissingen, en dan niet alleen over de goede, maar ook over de foute. Ik vind namelijk:

 

Je moet leren van de problemen van een ander want je hebt geen tijd om ze allemaal zelf mee te maken.

 

Op deze manier hoop ik dat meer lezers iets opsteken van dit verhaal dan het kleine aantal dat ook wel een frasemachientje zouden willen automatiseren.

Hoofdstuk 10 beschrijft de bediening van alle functies. Dit hoofdstuk is vooral nuttig als naslagwerk voor mijzelf, maar misschien zitten er ideeën in die U over wilt nemen.

 

2) Het vooronderzoek.

Na het gesprek met Martin de Roode besloot ik me een Proxxon MICROMOT 220/E  aan te schaffen (altijd handig) en kocht in de bouwmarkt een paar van die lagers en M6 draadeind. Uit een paar oude 5 1//4 inch floppy drives sloopte ik de stappenmotoren en zaagde wat MDF. Al ‘spelend’ met die onderdelen sloeg de twijfel toe. De aandrijving met het draadeind had speling (rammelde iets in de moer) en de bewegingen van de tafel waren niet helemaal recht over het hele bereik vooral als de lagers wat kracht moesten opvangen.

De constructeurs op m’n werk in een bedrijfsmechanisatie van Philips (zie m’n website www.henkzelf.nl ) zeiden me: “Henk, je bouwt aardige software, en van elektronica weet je genoeg, maar als je mechanisch ook wat wilt maken, schaf dan maar een draaibankje en een echte freesmachine aan. Waar je nu mee bezig bent wordt nooit naar je zin, zo kennen we je wel”.

Nu hadden ze wel een idee over m’n salaris, maar de budget commissie thuis was veel kritischer dan die op m’n werk. “Draai- en freesbank? No way.” Het antwoord op de vraag: “En wat ga je er dan mee doen?“ was: “Robotjes Maken.” Ook dit was voor mijn wederhelft geen doorslaggevend argument.

Dus als ik het leukste deel van m’n werk, na mijn pensionering, als hobby wilde voorzetten, dan moest ik wel met de goedkoopste oplossing komen.

Ik bedacht dat frezen voor het maken van kleine machientjes (robotjes) belangrijker was dan draaien, en dacht dat ik met een freesmachientje ook wel een asje zou kunnen bewerken als ik dat asje in dat freesmachientje zou kunnen ronddraaien.

Na een halfjaartje opvallend snuffelen in catalogi voor het oog van het thuisfront, werd er een budget van f  766.50  geaccepteerd.

Hiervoor schafte ik aan uit het Proxxon assortiment (zie: http://84.244.158.123/~proxxon/index1.htm ):

·        Boor - freesbank BFB 2000            (f 312,-   nu E 154,95)

·        Kruistafel KT 150                            (f 332.25 nu E 166.50)

·        Machineklemmen PRIMUS 100      (f 122.25 nu  E   57.95)

De bijbehorende Freesmotor BFW 40/E         (f374,- nu E  177.50) schafte ik niet aan omdat ik die te duur vond en omdat ik immers al die MICROMOT 220/E had, waarvoor ik dan wel een verloopstuk zou maken. In de boor - freesbank kun je ook een boormachine met een hals van 43 mm zetten, en toen het spul binnen was lukte het me inderdaad met een frees in een boormachine het verloopstuk te maken van eikenhout. Dit ondanks dat die frees nogal wiebelde.

Toch was deze beslissing verkeerd. Ik heb de grote freesmotor later toch aangeschaft, en als ik dat meteen gedaan had, had ik een aantal keuzes bij het ontwerp van de besturing anders gemaakt. Nu moest ik een aantal zaken overdoen. Maar hierover later in hoofdstuk 7.

 

Over de aanschaf van de rest ben ik wel tevreden, hoewel het me tegenviel dat er ook bij deze kruistafel een flinke speling zit in de spindels. Deze was zelfs nog groter dan die in mijn proefopstelling met het M6 draadeind (zelfs ongeveer 0.75 mm). De speling zit niet zo zeer in de moer maar in de zeer simpele lagering aan het eind van de spindels. De nastelbare zwaluwstaartgeleidingen van de tafel kunnen echter zo stroef worden afgesteld dat er van ‘rammelen’ geen sprake is. Bovendien is de speling behoorlijk constant, dus kan de besturing er rekening mee houden door, als je de richting waarin je de spindel draait omkeert, eerst de speling te overbruggen. De mechanici op m’n werk vertelden me dat de freesbank die zij gebruiken voor kleine haastklusjes en correcties ook dit effect vertoonde en dat het een kwestie van vakmanschap was om hiermee om te gaan. Daar kon ik het dus mee doen: Mijn teleurstelling was een teken van amateurisme.

Tijdens dit project leerde ik: “Een amateur is iemand die iedere frees die hij molt en alle materiaal dat hij verknoeit zelf moet betalen. Bij een professional doet zijn baas dat”.

Een andere zaak die me tegenviel is dat door de stroeve lagering de stappenmotoren, uit de floppy disks, niet sterk genoeg waren. Met een tandwielvertraging zou het geheel wel erg langzaam worden. Op m’n werk zou ik grote stappenmotoren overwogen hebben, maar daar kon ik als amateur niet aankomen.

De elektromotoren met 1:50 vertraging die ik wel kon krijgen (RB-35 te bestellen bij Conrad onder nr. 22 75 52-04) bleken wel sterk genoeg en met 120 omwentelingen per minuut zouden ze de freestafel 240 mm/min = 4 mm/sec kunnen verplaatsen (max. snelheid). Ik zou dan nog wel een meetsysteem moeten aanbrengen en een regeling moeten toepassen, maar dat leek me te doen.

 

De machineklem zou ik zeker weer aanschaffen. De sleuven in de klemblokken, om rond materiaal te klemmen in exacte X of Z richting, zijn voor mij erg belangrijk. Ik heb de machineklem elektrisch geïsoleerd op de kruistafel gemonteerd en aangesloten op een input van de microcontroller waardoor deze kan detecteren of de frees het werkstuk raakt (als dit van metaal is natuurlijk).

 

De boor - freesbank BFB 2000 is wel minder ‘stijf’ dan andere freesbanken en bankjes. Met flink duwen kun je de freeshoogte 0.1 mm omhoog en omlaag buigen. Voor mij wordt dit nadeel ruim gecompenseerd door de ruime mate van de extra verstelbaarheid. Ik kan de frees zelfs buiten het bereik van de freestafel instellen en ook werkstukken inspannen die hoger zijn dan het 8 cm grote bereik van de Z as.

 

3) De projectdefinitie fase voor de besturing.

Van de software ontwerpers die ik op m’n werk mocht aansturen eiste ik altijd dat ze me aan het begin van een project antwoord gaven op de drie volgende vragen:

  1. Wat is er af als het af is? In een professionele omgeving is dit natuurlijk een heel pak papier dat met ‘Requirements Specification’ of een andere moeilijke naam wordt aangeduid.
  2. Wat gaat er fout als het fout gaat? Een risico analyse. Een zeeman die zich goed bewust is van alle klippen en zandbanken die hij tegenkomt weet deze meestal te omzeilen. Als de risico’s voor een bepaalde bestemming te groot zijn, is het beter een andere meer veilige haven als bestemming te kiezen. Het is goed om deze lijst met risico’s gedurende het hele ontwikkelproces aan te vullen.
  3. Wie zegt er goed als het goed is? Vaak kregen de software ontwikkelaars hun opdracht van de projectleider die verantwoordelijk was voor de hele machine, dat wil zeggen, voor de combinatie van de te ontwerpen mechanica, elektronica en software. Hij deed zaken met de fabriekschefs en zijn directe assistenten. Dit waren meestal niet degenen die later, voor levering, de afnametest kwamen doen, en ook niet diegenen die de machine moesten bedienen en onderhouden. Ik wilde dat de ontwikkelaars regelmatig contact onderhielden met deze ‘gebruikers’ omdat alleen zo een ‘handige’ machine ontstond. De (gemiddeld 10%) extra software ontwikkelkosten verdiende ik ruim terug door minder updates gedurende de garantie periode.

Het leuke van dit freesmachine besturingsproject was dat ik zelf de rol van klant en gebruiker heb. Bovenstaande vraag 3 is dus duidelijk beantwoord. Pas als ik het goed vind dan is het goed. Ik moet toegeven dat er veel meer dan 10% extra tijd aan de software is besteed om de bediening zo handig mogelijk te maken.

Vraag twee wordt na en tijdens vraag 1 beantwoord. In het antwoord op vraag 1 ziet U daarom een aantal keren: “(Wat gaat er fout al het fout gaat?)”.

 

3.1) Wat is er af als het af is.

De besturing moet voldoen aan de volgende eisen

  1. De X, Y en Z as kunnen met een instelbare snelheid naar een op te geven positie worden gestuurd. Zomogelijk gebeurt dit simultaan maar dat is geen eis.
  2. De positieregelingen mogen zeker niet doorschieten, d.w.z. even voorbij het doel schieten en dan terug gaan. (Wat gaat er fout al het fout gaat?).
  3. De positieregelingen moeten rekening houden met de speling in de spindels en eventuele extra speling in de aandrijving van de spindels. De waarde van deze speling moet per spindel kunnen worden opgegeven.
  4. De besturingskast moet commando’s, gegeven via een PC, kunnen uitvoeren.
  5. De besturingskast moet ook locale bedieningsorganen hebben zodat de freesmachine ook zonder PC te besturen is. Dit omdat bij het frezen metaalstof kan ontstaan wat zeker niet in een PC terecht moet komen (Wat gaat er fout al het fout gaat?).
  6. De besturingskast moet een serie commando’s kunnen opslaan om die later uit te voeren, ook nadat de PC losgekoppeld is.
  7. De onnauwkeurigheid van machine met besturing moet niet merkbaar groter zijn dan die van de mechanica.
  8. De besturing moet snel verwijderd kunnen worden om zo de machine met de hand (zoals gekocht) te kunnen bedienen. Hierdoor blijft hij bruikbaar als de besturing nog niet goed is of het project helemaal mislukt (Wat gaat er fout al het fout gaat?).
  9. Er moet gerekend worden op vervolg projecten, d.w.z. met enige uitbreiding, bijvoorbeeld t.b.v. een beperkte draaibank functie.

 

4) De hardware.

Tijdens het vooronderzoek had ik geconstateerd dat ik niet aan stappenmotoren kon komen die sterk genoeg zijn en dat elektromotoren RB-35 met 1:50 vertraging wel in staat waren om de spindels met aanvaardbare snelheid te verdraaien. Daar koos ik dus voor bij gebrek aan een beter alternatief.

Uit deze keuze en uit de in 3.1 geformuleerde eisen volgt dat de besturing uit de volgende delen zou moeten bestaan:

  1. Motoren (RB-35, Conrad nr 22 75 52-04).
  2. Vermogens regeling voor deze motoren.
  3. Een meetsysteem voor X.Y en Z as.
  4. Per as een regeling voor snelheid en positie.
  5. Een microcontroller met voldoende RAM om een acceptabel aantal commando’s te kunnen onthouden (zie eis 6).
  6. Bedieningsorganen voor de besturingskast d.w.z knoppen voor de te starten functies en middelen om de parameters van deze functies in te voeren (b.v. snelheid en gewenste positie van de assen).
  7. De benodigde voedingsspanningen.

 

4.1) De microcontroller.

Hiervoor gebruikte ik een 80592 uit de 80C51 familie. Dit was vooral gemotiveerd door:

De keuze van deze controller kan U dus best aanvechten. Ik gebruikte hem omdat ik van een aantal van deze gesneuvelde printjes een paar goede kon maken (wat op m’n werk niet economisch was).

De printjes bevatten naast de microcontroller:

Omdat dit een best krachtige controller is besloot ik om er maar 1 te gebruiken, en niet een voor elke motor en dan nog eens 1extra om die 3 te laten samenwerken. Communicatie tussen processors kost tijd en is complexer. Later twijfelde ik wel eens aan deze beslissing. Al m’n wensen in 48kB programma realiseren vereiste woekeren met deze ruimte.

 

4.2) Vermogens regeling voor de motoren.

Hiervoor werden de 2 Pulse Width Modulated Outputs van de microcontroller natuurlijk gebruikt. Omdat ik 3 motoren zou moeten besturen en maar 2 van deze outputs had gebruikte ik wat poorten gestuurd door twee gewone digitale outputs om deze 2 PWM uitgangen voor 4 motoren te kunnen gebruiken, al kunnen er maar twee motoren tegelijk aan het werk gezet worden. Hiermee accepteerde ik dus dat Z niet simultaan met X en Y kunnen worden bewogen (zie “Zo mogelijk…” bij eis 1).

Nog twee extra outputs worden gebruikt om de draairichting van de motoren te kunnen sturen. Achter deze poorten moest natuurlijk nog circuit om de 12V motoren te sturen. Ik gebruik transistors (BC139 en BC140 in een H-brug) want ik wist nog niet dat je bij www.voti.nl hier IC’s voor kunt kopen. Bovendien dacht ik dat ik met een zelf ontworpen circuit ook de stroom door de motoren kon meten via de ADC ingangen, en daar iets nuttigs mee kon doen tijdens het regelen. Dat bleek fout te zijn. De stroomsignalen bevatten zoveel ruis dat er zwaar gefilterd moest worden om een reproducerende waarde te verkrijgen. Deze RC filters zorgden er echter voor een vertraging waardoor een nuttige meetwaarde niet op tijd beschikbaar is om hem bij het regelen te gebruiken.

U begrijpt al, ik had geen enkele ervaring met het sturen van motoren zonder het gebruik van kant en klare ingekochte besturingselektronica. Maar ja:

Ervaring is dat wat je krijgt als je fouten maakt.

 

4.3) Meetsystemen voor X, Y en Z as.
Ik moest kiezen tussen:

Het eerste is natuurlijk het beste (meet dat wat je wilt weten, en niet iets waaruit je dat wat je wilt weten kan afleiden). Maar het is ook het duurste. De professionele meetsystemen die ik kende waren per stuk duurder dan m’n hele freesmachientje. Toen heb ik nog even met de gedachte gespeeld om computer-muizen in te zetten. Een oplossend vermogen van 600 stappen / inch staat gelijk aan 25,4 / 600 = 0.042 mm. Dat is niet goed genoeg om te voldoen aan eis 7.

Het is dus nodig om uit te bepalen wat het oplossendvermogen van het meetsysteem moet zijn om aan eis 7 te voldoen (De onnauwkeurigheid van machine met besturing moet niet merkbaar groter zijn dan die van de mechanica). Als je een as met de hand bediend en de verplaatsing afleest op een schaal verdeling op het handwieltje dan komt 1 streep op deze schaal overeen met een verplaatsing van 0.05 mm. Met een beetje gokken kun je nog wel op 0.02 mm nauwkeurig instellen. Daarom wordt eis 7 als volgt uitgewerkt:

Dit laatste punt moet worden uitgelegd. Men moet altijd nauwkeuriger kunnen meten dan het gewenste regel resultaat omdat de ruis in het meetsignaal klein moet zijn t.o.v. de toegestane regelfout. Normaal hanteer ik hier minstens een factor 10. Dat ik hier een factor 6 accepteer heeft de volgende reden. De X as kan ongeveer 150 mm bewegen. Dit is dus 15000 x 0.01 mm en 45000 eenheden van het meetsysteem. Aangezien een 16 bits getal heeft een bereik van 0 tot 65535 of (zoals ik koos) van -32768 tot 32767, kunnen we in de regelaar, posities met 16 bits aangeven. Hadden we de factor 10 genomen (0.002 mm) dan was de 150 mm overeengekomen met 75000 eenheden van het meetsysteem en die waarde kan niet met 16 bits worden weergegeven.

Opmerking: De keuze van 1/3 van 0.01 mm hing ook af van de beschikbare tandwielen maar daarover hieronder.

 

Ik koos dus om financiële redenen om de verdraaiing van de spindels te meten of beter uitgedrukt: de verdraaiing van de as van de motoren. Hierdoor kan het meetsysteem aan de motor worden gebouwd en kan samen met de motor verwijderd worden om te voldoen aan eis 8 (De besturing moet snel verwijderd kunnen worden om zo de machine met de hand (zoals gekocht) te kunnen bedienen).

Aangezien 1 omwenteling van de spindel en dus van de motor’s as overeenkomt met 2 mm zocht ik een meetsysteem van 600 stappen per omwenteling.

Een ‘incrementele’ encoder is relatief goedkoop te bouwen met twee lichtsluizen en een codeschijf met 150 gleufjes of een tandwiel met 150 tanden. Bij juiste plaatsing geven de lichtsluizen bij draaiing van het tandwiel, per tand, de volgende signaal combinaties af :  00, 01, 11, 10 (en dan weer 00, 01, 11, 10 voor de volgende tand enz.). Als de signalen van de twee lichtsluizen worden aangesloten op een microcontroller, dan kan de software de richting en de grootte van de verdraaiing door het volgen van deze signalen.

Ik had het geluk dat ik wat kant en klare encoders kon overnemen uit half ontwikkelde apparaten voor een project dat werd gestopt.

Deze koppelde ik aan de assen van motor met een paar tandwieltjes uit een gesloopte video recorder. De werking is echter identiek aan lichtsluizen die ‘tandwieltanden detecteren.

Met de op deze manier gekoppelde encoders kan de micro 37600 / 125 ( = 300,8 ) stappen per mm detecteren. Deze rare waarde wordt veroorzaakt door de beperking bij de keuze van de tandwielen. Gelukkig heeft de microcontroller geen bezwaar tegen het rekenen met rare waarden.

 

4.4) Regelingen voor snelheid en positie.

De inputs van de regelingen komen van de encoders naar de microcontroller en van de bedieningsorganen en eventueel een PC. De microcontroller regelt het vermogen voor de motoren via de PWM uitgangen. Dus software in de micro zal alle regelfuncties moeten uitvoeren. Dit wordt waarom besproken in onderstaand hoofdstuk: Software.

 

4.5) Bedieningsorganen voor de besturingskast.

Vooral vanwege eis 9 (Er moet gerekend worden op vervolg projecten, d.w.z. met enige uitbreiding) zou het niet handig zijn geweest om de besturingskast te voorzien van een knop voor elke voorziene functie. Verder moeten we ook nog middelen hebben om waarden in te stellen, zoals gewenste posities en snelheden, en om de ingestelde waarde weer te geven.

Daarom paste ik een ‘bedieningsinterface’ toe die ik ooit als hobby ontwikkelde en die in (bijna) alle microcontroller - ontwerpen op m’n werk is toegepast.

Deze bestaat uit:

Voor het besturen van de LCD zijn 8 datasignalen en 3 besturingsignalen nodig. Een van deze 3 signalen is het enable signaal. Zodra deze inactief is kun je de andere signalen veranderen zoals je wilt. Met de andere 2 besturingsignalen kies je 1 van de volgende functies.

·        Lees de inhoud van het besturingsregister van het LCD

·        Schrijf naar het besturingsregister van het LCD.

·        Schrijf een data byte naar het LCD (teken wat op de cursor positie moet komen te staan).

Met 2 bits kun je 4 combinaties maken, en er zijn hierboven maar 3 genoemd. De vierde combinatie en het false zijn van het enable signaal wordt door een paar poorten bij de knoppen gedetecteerd en als deze detectie ‘waar’ aangeeft worden de knoppen in een 4 bij 4 matrix op de datasignalen aangesloten. De micro gebruikt 4 datasignalen als output die zijn aangesloten op de 4 rijen van de matrix. De ander 4 worden als inputs aangesloten aan de kolommen van de matrix. Op deze manier kan de software de stand van elke knop uitvinden via de I/O pinnen welke toch al voor de LCD nodig waren.

Normaal staat er een bijschrift bij een knop op een bedieningspaneel. Omdat de koppen dicht bij elkaar zitten zijn de functie - knop relaties aangegeven met plaatjes op het frontpaneel. Start zo’n functie een menu, dan wordt het bijschrift voor een knop weergegeven op de onderste regel van de LCD.

Dit bijschrift kan worden veranderd als bij het actief zijn van verschillende menu’s.

 

Als we waarden willen instellen (b.v. positie van X) dan houden we de knop onder de getoonde waarde ingedrukt en draaien aan de encoder knop waarop de software de waarde verandert en toont.

Samengevat: Ik kan met het indrukken van knoppen net zoveel functies starten als ik wil, en met de encoder net zoveel verschillende waarden als ik wil instellen. Verder kan zo’n functie zijn: Het tonen van een waarden niet standaard op de LCD worden getoond. Als uitzondering heb ik nog wel wat LEDjes toegevoegd voor om b.v. de toestand van het (input)signaal wat aangeeft of de machineklem contact maakt met de 0V (via het werkstuk en de frees).

 

4.6) Voedingsspanningen.

De motoren en hun sturing hebben 12 V nodig. Deze hoeft niet goed gestabiliseerd te zijn. De microcontroller en aangesloten elektronica hebben een goed gestabiliseerde 5V nodig. Ik besloot de besturingskast met een 12V 1A stekkervoeding te voeden en van deze 12 V (onbelast 15 V) de 5V te maken doormiddel van een ‘stepdown converter’ die ik in het blad Electuur vond. Er komt een hogere stroom uit dan er ingaat (maar niet meer vermogen). Je raakt zo’n 25% vermogen kwijt in plaats van  60% bij een normale spanningsregelaar. Hoewel ik met een netvoeding niet zuinig hoefde te zijn met vermogen, hield ik er rekening mee dat ik de elektronica ook voor een mobiele toepassing zal gaan gebruiken en dan heb ik alleen een 12V accu nodig.

 

Later realiseerde ik me dat ik altijd een 20 / 50 W halogeen lamp naast de freesmachine had staan om het freesproces goed te kunnen volgen.

Ik verving de 50 W lamp hierin door een van 20 W en bouwde een brugcel en elco bij de trafo in de voet van de lamp. De 30 W die de trafo nu over had gaat nu gelijkgericht naar de regelkast. Dat scheelt weer een 220V aansluiting.

 

4.7) Printen.

Met de freeware versie van programma Eagle (zie: http://www.cadsoft.de/freeware.htm ) ontwikkelde ik 3 printen, De eerste met de microcontroller en andere 5 V logica. De tweede met de vermogensregeling voor de motoren en 12V logica IC’s. De derde met de 12V naar 5V stepdown converter.

De eerste, belangrijkste print, heeft de volgende aansluitingen.

·        Een 9 polige connector voor een RS232 interface voor communicatie met de PC en het laden van het programma in de microcontroller.

·        Een 16 polige flatcable connector voor bedieningsorganen (de LCD, drukknoppen en draaiknop).

·        Een 10 polige flatcable aansluiting voor de 8 bits van 4 encoders en hun voeding (zie meetsystemen).

·        Een 12 polige flatcable voor het aansluiten van print twee, de vermogensregeling voor de motoren. Deze voort de volgende signalen:

1.      Vier PWM signalen. (open collector om over te gaan van 5 naar 12 V.

2.      Twee bits voor de richting van de motoren (ook open collector)

3.      Vier analoge inputs om de stroom door de motoren te kunnen meten.

4.      de 5V voedingsspanning zodat de logica op print 2 kan zorgen dat de motoren niet zullen draaien als print 1 niet aangesloten is.

·        Een 64 polige connector zoals deze in een rek voor euro prints worden gebruikt. Hierop sloot ik de meeste aansluitingen van het microcontroller printje aan, ten behoeve van uitbreidingen (eis 9).

 

5) De software.

Over de structuur van de software heb ik niet lang nagedacht omdat die lijkt op voorgaande projecten. Voor de volledigheid van dit verhaal is het nodig om de belangrijkste karakteristieken te beschrijven. Dat doe ik in dit hoofdstuk. Toch ging de ontwikkeling van de software niet zo gestructureerd als die van de hardware vooral omdat belangrijke eigenschappen van de hardware niet voldoende bekend waren (en dat wist ik). Het verhaal van trial and error volgt in hoofdstuk 6.

 

5.1) Communicatie met de PC.

Als twee computers met elkaar moeten communiceren heb je aan beide kanten software nodig. Ik handhaaf mijn gewoonte om aan de PC kant een standaard terminal-emulator (b.v. Hyperterminal van Windows) te gebruiken. Elk karakter wat je tikt in het window van een terminal-emulator wordt direct verstuurd via de RS232 interface, en elk karakter wat binnenkomt via de RS232 interface wordt getoond in dat window. Daarnaast kun je de emulator nog opdracht geven om alles wat binnenkomt ook op te slaan in een . txt file en je kunt opdracht geven om alle karakters in een .txt file te versturen.

Dit laatste gebruik ik om lijsten met opdrachten te versturen naar de microcontroller. Deze lijsten kan ik dus met een tekst-editer op de PC maken en aanpassen. Voor complexe opdrachtlijsten zoals tandwielen gebruik ik eigengemaakte PC programma’s die opdrachtlijsten genereren aan de hand van een beperkt aantal gegevens.

Samengevat: De micro zorgt dat er een menu wordt getoond in het window van de terminal-emulator en wacht op een commando waarna hij het uitvoert.

Een van de mogelijke commando’s is het opslaan van een lijst met commando’s. Een ander is het uitvoeren van een opgeslagen lijst van commando’s.

 

Een commando wordt gegeven door het tikken van 1 letter of leesteken (alles behalve cijfers en + of -). Als de functie van het commando een parameter nodig heeft vraagt de micro naar dit getal. Bijvoorbeeld: Je moet een x tikken als je een gewenste verplaatsing van de X-as wilt opgeven. De micro vraagt dan eerst: “Correction X = “ waarna je de verplaatsing kunt opgeven in 0.01 mm. Je sluit een getal af met de enter toets, waarna de X as over de gewenste afstand wordt verplaatst. Wil je de X-as terug hebben naar de vorige positie dan volstaat het tikken van een a want dit is het commando “X Back to last position (now)”. Ik heb er voor gekozen dat er maar 1 getal per commando te gebruiken. Als je dus X en Y tegelijk wilt verplaatsen (via een rechte lijn) dan geeft je eerst het commando X (hoofdletter) en beantwoord je de vraag naar de doelcoördinaat. Het X (en Y) commando slaat alleen deze waarde op. Het commando M (move) start de beweging. Commando q (Quick) doet dit ook, maar dan op maximumsnelheid en dus niet volgens een rechte lijn, wat best mag als de frees geen contact maakt met het werkstuk.

Commando L (local-control) start de bediening via de knoppen onder het LCD. Dit commando wordt na het opstarten van de microcontroller automatisch gegeven (dus ook als er geen PC aangesloten is) en duurt totdat er een willekeurig karakter via de RS232 bij de micro binnenkomt. Zo staat de micro na het aanzetten op Local-control en kun je later een PC aansluiten en de bediening overnemen en met commando L weer op Local-control zetten en de PC loskoppelen.

 

5.2) Real time aspecten.

De uitdagingen:

Om met de incrementele encoders de positie van de assen bij te houden moet de stand van de encoder signalen met hoge frequentie worden uitgelezen om veranderingen in de stand te kunnen tellen. Daarnaast moeten we snelheden instellen. Aangezien snelheid afstand per tijdseenheid is, zullen we behoorlijk nauwkeurig tijd moeten meten.

Om aan de wens te voldoen dat de X en Y as simultaan naar een nieuwe positie bewegen hebben we een mechanisme nodig die de CPU tijd verdeelt tussen de software delen die de X en Y as regelen. Dit verdelen van CPU tijd is bij grotere computers een functie van een besturingssysteem (Windows, Linux of nog beter een specialistische real-time-kernel). Bij microcontrollers moet je deze functionaliteit zelf in je programma aanbrengen.

 

De gekozen oplossingen:

Om tijd te kunnen meten bouwen we een klok-interrupt-routine in die 6000 keer per seconde gestart wordt door een timercircuit in de micro. De 6000 keer is het laagste aantal waarop de timer ingesteld kan worden bij een systeem klok van 16 MHz.

Voor het uitvoeren van een interrupt-routine wordt het hoofd programma even onderbroken. Dat moet natuurlijk niet te lang want hoe langer de interrupt-routine nodig heeft, hoe minder CPU tijd er over blijft voor het hoofdprogramma.

Voor het meten van tijd laten we de interrupt-routine een variabele in het RAM met 1 ophogen. Het hoofdprogramma kan dan deze RAM variabele lezen en op 0 zetten. We kunnen natuurlijk meerdere van deze tellers toepassen.

Als het hoofdprogramma moet weten of er al een bepaalde tijd verstreken is, kunnen we beter een variabele door het hoofdprogramma op het gewenste aantal clock-ticks laten zetten en deze variabele door de klok interrupt routine alleen als hij groter dan 0 is met 1 laten verminderen. Het hoofdprogramma ziet dan in de variabele de resterende tijd. En kan testen of deze al 0 is.

Ook het beoordelen van de signalen van de encoders wordt door de klokroutine gedaan. Per encoder wordt een 16 bit variabele met 1 verhoogd of verlaagd afhankelijk van de verandering van de signalen. Het hoofdprogramma kan in deze 4 variabelen dus altijd de stand aflezen van de X Y en Z as en die van de encoder aan de draaiknop naast de LCD. Natuurlijk kan het hoofdprogramma deze positie variabelen op elk moment op elke gewenste beginstand zetten.

 

Voor het bepalen van de snelheid van de X Y en Z as gebruik ik het volgende mechanisme.

Om een snelheidsmeting te starten zet het hoofd programma een ‘Vlagbyte’ (een Ram variabele) op 1 en noteert in een andere variabele de positie van de as waarbij de interrupt-routine deze Vlagbyte op 0 moet zetten, b.v. 5 encoder stapper verder in de actuele draairichting. Bovendien zet het hoofdprogramma een ‘tijdteller’op 0. Alleen wanneer de Vlagbyte op 1 staat verhoogd de interrupt-routine de ‘tijdteller’ met 1. Alleen als de encoder signalen van de as verandert zijn (dus als en de positie variabele een nieuwe waarde krijgt) en de vlag staat op 1 dan test de interrupt-routine of de vlag op 0 moet worden gezet.

Het hoofdprogramma kan testen of de snelheidsmeting al klaar is door te kijken of de Vlagbyte al 0 is. Is dat zo dan kan het de verstreken tijd die nodig was om de opgegeven positie te bereiken aflezen in de ‘tijdteller’.

Tijdens het starten van de meting (zet Vlagbyte op 1, bereken ‘stop positie’, reset ’tijd teller’) wordt het optreden van de een interrupt heel even verhinderd om de fouten te voorkomen die zouden kunnen optreden b.v. als een interrupt zou optreden tussen het op 1 zetten van de vlag en het schrijven van de ‘stop positie’.

Opmerking: Ik moet toegeven dat ik eerst een paar andere meetmethoden heb toegepast die niet naar m’n zin werkten omdat het meetresultaat werd beïnvloed door de reactietijd van het hoofdprogramma. Bovenstaande methode heeft dat nadeel niet.

 

Voor het gelijktijdig regelen van X en Y paste ik coöperative-scheduling toe door een ‘State machine’ voor X en een ‘State machine’ voor Y. Dit is een zin die alleen informatici zullen begrijpen. Daarom probeer ik dit hieronder uit te leggen aan de hand van een sterk vereenvoudigde beschrijving van de software voor een as.

 

Laten we eens globaal beschrijven wat deze software moet doen als we de as van de huidige positie, punt A, naar een punt B willen sturen met een snelheid die de waarde V niet te boven gaat maar zomogelijk wel gehaald moet worden.

De volgende stappen hiervoor nodig:

  1. Zet de motorsturing op de juiste richting en (om te beginnen) op een laag vermogen en ga verder met stap 2.
  2. Wacht even om de motor tijd te geven om te reageren en als deze tijd afgelopen is, start de snelheidsmeting en ga verder met stap 3.
  3. Wacht tot de snelheidsmeting afgelopen is maar kijk ondertussen of we al bijna op punt B zijn aangekomen. Als we bijna op punt B zijn aangekomen zetten we het motorvermogen op de minimale stand, waarbij de as nog net blijft bewegen, en gaan verder met stap 4. Als we nog niet in de buurt van punt B zijn en de snelheidsmeting is klaar, dan corrigeren we het ingestelde motor vermogen om zo dicht mogelijk bij snelheid V te komen en gaan terug naar stap 2.
  4. Wacht tot de as bij punt B is aangekomen. En zet dan het motorvermogen op 0 en ga door naar stap 5.
  5. Laat zien dat het regelen klaar is en doe verder niets.

 

Pas op: Bovenstaande beschrijving is heel erg vereenvoudigd om als voorbeeld te dienen. Bij de software in m’n freesmachientje is het aantal stappen hoger dan 25.

Merk op dat stap 2 t/m 4 beginnen met het woord: ”Wacht”. De eenvoudigste methode om een programma te laten wachten is een programma lus waarbij de test herhaald wordt totdat deze aangeeft dat er verder kan worden gegaan. De hier toegepaste microcontroller kan zo’n test meer dan 200000 keer per sec uitvoeren. Als we in stap 2 dus 0.003 sec willen wachten wordt de test minstens 600 keer uitgevoerd waarvan 599 keer voor noppes. We zouden die 0.003 sec CPU tijd ook voor wat nuttigs kunnen gebruiken d.w.z. het regelen van een tweede as. Als we daardoor wel eens een keer 0.004 sec wachten in plaats van 0.003 sec dan verstoort dit het regelen toch niet. Bedenk hierbij dat de hoogste snelheid van een as 4 mm per sec. is, dus dat  hij voor 0.01 mm (de toegestane onnauwkeurigheid) minstens 0.0025 sec nodig heeft.

 

Om twee assen gelijktijdig te regelen doen we het volgende:

·        We schrijven een subroutine voor elk van de 5 stappen voor allebei de assen (10 subroutines). De eigenschappen bespreek ik hieronder.

·        We reserveren voor elke as een variabele die een adres van een subroutine kan opslaan. We noemen deze variabelen RoutinePointer.

·        We zorgen dat de clock-interrupt-routine voor elke as een eigen variabele (clock-tickcounter) met 1 verhoogt.

Het softwaredeel dat opdracht geeft voor het regelen van beide assen doet het volgende:

Omdat de Startroutine van een as het adres van zijn State routine voor stap 2 in zijn RoutinePointer heeft gezet kunnen we begrijpen dat StateCaller deze zal uitvoeren.

Laten we nu eens kijken hoe deze State routine voor stap 2 iedere keer dat hij wordt uitgevoerd doet. Dit is:

Hij controleert of de waarde van de as z’n clock-tick-counter nog lager is dan de gewenste wachttijd om de motor te laten reageren. Als dat zo is doet hij verder niets. Omdat de RoutinePointer niet veranderd wordt zal de StateCaller dezelfde routine steeds opnieuw aanroepen tot de clock-tickcounter wel hoog genoeg staat. We noemen dit: “De State-machine (toestand machine) die de as bestuurt is in state 2 (toestand 2)”. Als de clock-tick-counter wel hoog genoeg staat dan start de routine voor state 2 de snelheidsmeting van de as en schrijft het adres van de routine voor state 3 in RoutinePointer van de as. In de volgende rondgang van de StateCaller zal dus niet de routine voor state 2 worden uitgevoerd, maar die van state 3.

 

De state routine voor stap 3 doet het volgende:

Het controleert of de as al bijna op punt B is aangekomen en als dit zo is het zet het motor vermogen op de minimale stand waarbij de as nog net blijft bewegen en schrijft het adres van de routine voor stap 4 in de RoutinePointer.

Als dit niet zo is controleert de routine of de snelheidsmeting al klaar is.

Als dit zo is dan berekend hij een betere stand voor het motor vermogen en stuurt dit naar de hardware. Daarna wordt het adres van de routine voor stap 2 in de RoutinePointer geschreven en de clock-tickcounter van de as op 0 gezet.

Als dit ook niets zo is dan doet de routine verder niets tot het weer gestart wordt door de StateCaller.

 

Merk op dat de StartRoutine en de state routine voor stap 3 dezelfde dingen doen als de volgende stap, stap 2 is. Het is goed om deze dingen te laten doen door een aparte subroutine (GaNaarState2). Dit soort routines wordtTransitionRoutines  (OvergangRoutines) genoemd.

 

De werking van de state routine voor stap 4 kunt U zelf wel bedenken.

 

De functie van de state routine voor stap 5 is opvallend. Die doet helemaal niets en wordt door de StateCaller aangeroepen zolang de andere as zijn punt B nog niet heeft bereikt.

 

Slotopmerkingen over State-machines:

  1. Ik heb systemen gemaakt die alleen maar uit State-machines bestonden. En waarbij de ene State-machine een andere kon activeren. Het hoofdprogramma bestond alleen uit initialisatie van alles en de StateCaller die oneindig lang doorliep.
  2. De term coöperative in coöperative-scheduling geeft aan dat de State routines van een State-machine rekening moeten houden met de andere State-machines. Als ze de CPU lang bezig houden dan kunnen de andere State-machines wel eens te laat CPU tijd krijgen via de StateCaller. Ze kunnen zelfs het hele systeem ophangen. Dit kent U misschien nog wel van een rot programma onder Windows 3.11. Aangezien we bij micro’s alle software zelf ontwikkelen en de gebruiker geen programma’s van anderen kan bijladen en uitvoeren is coöperative-scheduling de eenvoudigste van alle alternatieven.
  3. Als U State-machines gaat gebruiken moet U zeker niet vergeten om de beschrijvende state-diagrammen te tekenen. In deze diagrammen worden states weergegeven door blokjes en de mogelijke transities door lijnen (pijlen). Zonder dit vindt U de weg in Uw software maar moeilijk terug als U na een paar maanden toch nog wat wilt aanpassen.

 

6) Ontwikkeling van de software (trial and error).

 Als U van mijn fouten en problemen wat wilt leren, dan is dit het belangrijkste hoofdstuk.

 

O.K. de printen waren gemaakt. De micro had verbinding met de PC via de RS232 interface en de LCD en knoppen werkten. Tijd om een paar test programmaatjes te maken om te kijken of de nieuw ontworpen circuits ook werken.

 

6.1)  Experiment 1.

Encoders aansluiten en de stand weergeven op het LCD gaf geen problemen.

 

6.2)  Experiment 2, het eerste foutje.

Vervolgens ging ik losse motoren aansluiten en een testprogramma maken waarmee ze, via de knoppen onder de LCD, linksom of rechtsom aangestuurd kunnen worden waarbij via de draaiknop de instelling van de PWM signalen kunnen worden ingesteld. Daar had ik m’n eerste tegenvaller. De pulsbreedte kan ingesteld worden tussen 0 en 255 en ik verwachte: Bij 0 staat hij stil en hoe hoger ik hem zet hoe harder de motor draait. Bij 0 stond hij inderdaad stil. Dat hij van 0 tot 20 ook stil bleef staan verbaasde mij niet. Een 12V motor op 1V aangesloten draait ook niet. Maar dat hij van 50 tot 255 op volle snelheid draait verbaasde me. Signalen met de oscilloscoop controleren bracht geen fout aan het licht d.w.z. niet van de elektronica, maar wel van mijn verwachting. De motor wordt met hoge frequentie aan en uit geschakeld, maar als hij aan staat krijgt hij de volle 12 V. Je regelt dus niet de snelheid van de motor, maar de kracht. Ik dacht: “Nou ja, hoe sneller ik de as wil laten bewegen, hoe meer kracht er nodig is”. Dat was het tweede foutje.

 

6.2)  Experiment 2, het tweede foutje.

Toen ik een motor aan de mechanica had gekoppeld en de proef herhaalde bleek dat de as pas bij een stand van ongeveer 150 begint te bewegen, en bij ongeveer 170 al op volle snelheid kwam. Bovendien ontdekte ik dat als de as eenmaal beweegt, hij blijft bewegen als de PWM wordt teruggedraaid tot stand 30. Ik dacht: “Had ik vroeger op school in de natuurkundeles toch maar beter opgelet bij dat verhaal over statische- en dynamische wrijving”. Dat, bij glijlagers, statische wrijving niet te verwaarlozen is, daar was ik nu wel achter, en ik vermoed dat dit ook de reden is waarom de losse motor bij stand 0 tot 20 stil bleef staan.


6.3)  Experiment 3, nog meer problemen.

 Het regelen van de snelheid bleek een veel grotere uitdaging dan ik had voorzien. Ik moest meer gegevens zien te meten over de relatie tussen de beweging en de aansturing van de motor. Het enige middel dat ik kon bedenken was een testprogramma met de volgende eigenschappen:

Op het moment van inschakelen van de motor begint het programma iedere milliseconde in geheugentabellen te noteren:

Als de tabellen ‘vol’ zijn stopt de clock-interrupt-routine met noteren dus als we de motor stoppen gaat het noteren door. Een nog niet gebruikte knop start de functie die de geheugentabellen ‘leeg’ maakt en een andere knop start het uitprinten van de tabellen via de RS232 interface. Het uitprinten van een regel met 3 getallen kost natuurlijk veel meer (CPU) tijd dan 1 ms. Daarom worden de gegevens ook als tussenstap in geheugen geschreven.

Wat via de RS232 binnenkomt, kan met het PC programma Hyperterminal opgeslagen worden in een .txt file. De micro print de waarden zo uit, dat de .txt file ingelezen kan worden in Excel. Hierin zien we dan 4 kolommen met getallen. De eerste kolom bevat het monster nummer wat dus gelijk is aan het aantal milliseconden sinds het starten van de motor. Met Excel kun je van de meetwaarden eenvoudig in grafieken weergeven wat de bestudering aanmerkelijk vereenvoudigd.

 

Bij het eerste gebruik van dit testprogramma ontdekte ik dat de grafiek van de stroom zo hard op en neer springt dat hij nauwelijks bruikbare informatie geeft.

U zult vast wel weten dat een motor, bij aanlopen de meeste stroom trekt en ik was nieuwsgierig naar dat aanloop effect. Filters bouwen in de stroom signalen (in de kabel tussen Print 1 en Print 2) gaf ook geen oplossing. Als ik zo zwaar filterde dat de ruis bijna weg was, dan was het aanloop effect ook niet meer te herkennen. Visueel was dit wel te herkennen in de grafiek van ongefilterde metingen, maar dat is geen bruikbare input voor een regelalgoritme voor de microcontroller. Jammer dan, die stroom meetfunctie is dus vergeefs in de elektronica ingebouwd.

 

Aan de andere twee grafieken zag ik dat de as veel langer doorging met bewegen nadat de motor was uitgeschakeld dan ik had verwacht. Ik zei tegen mezelf: “Stom, je kent de formule: half MV kwadraat. En niet de massa en snelheid van de freestafel is hier dominant maar de massa en snelheid van het anker van de motor. Daarvan is de snelheid veel hoger omdat die voor de 1 op 50 vertraging zit. Bovendien bouw je een magnetisch veld op in de spoelen van de motoren. Dat vertegenwoordigt energie die er ook weer uit komt (in warmte en mechanische arbeid)”.

 

Het experimenteren met dit programma bracht nog een probleem aan het licht. Stel ik wil de as maar 0.01 a 0.02 mm verplaatsen. Dan heb ik een probleem want zelfs als ik het minimale vermogen instel waarbij de as opgang komt, dan loopt de as na het uitschakelen van het vermogen veel verder door.

Bovendien is de afgelegde weg in de laatste paar milliseconden niet constant. Waarschijnlijk omdat het moment waarop de statische wrijving gaat meespelen niet constant is.

 

6.4) Experiment 4, hoe veroorzaak ik de kleinst mogelijke beweging.

Het zal duidelijk zijn dat als het probleem van de kleine verplaatsingen niet opgelost kon worden het nauwkeurig verplaatsen over grotere afstanden ook zou mislukken. Als je met de hand aan de spindels draait gaat het laatste stukje van de beweging ook stapje voor stapje.

Het programma uit experiment 3 werd dus zo veranderd dat de as na het indrukken van de knop links een beweging van hooguit 0.02 maar meestal 0.01 mm maakt.

De stand van de as wordt in eenheden van 0.01 mm en in de eenheden van de encoder (ongeveer 0.003 mm) op de LCD weergegeven. Bovendien werd geëist dat de stap in minimale tijd wordt uitgevoerd.

Hiervoor is heel wat experimenteren, en dus het maken van veel programmaversies, nodig geweest voor ik tevreden was.

De uiteindelijke oplossing bestaat uit de volgende programmastappen:

  1. Zet 30 clock-ticks (5 ms) vol vermogen op de motor (PWM op 255) Dit vanwege eis: stap in minimale tijd.
  2. Zet de PWM poort op 100 totdat de encoder (as positie) van 2 stappen (0.006 mm) in de gewenste richting heeft gemaakt (1 stap is niet genoeg want hij kon net op het randje staan).
  3. Zet 24 clock-ticks (4 ms) PWM poort op 200 en de richting tegengesteld. We remmen de motor dus af en neutraliseren het magnetisch veld in de spoelen van de motor.
  4. Zet de PWM poort op 20 in de gewenste richting. Dit vermogen is zo laag dat de spindel niet zal bewegen, maar het laat de motor wel de speling in de vertragingstandwielen (1:50 weet u wel) en die in de koppeling met de spindel, zo leggen dat hij bij een eventuele volgende stap in dezelfde richting niet eerst deze speling zal overbruggen en de as dus met een tik op gang brengt.

Bij de uitleg van punt 4 zullen oplettende lezers zich afvragen: “Maar wat als de volgende stap niet in dezelfde richting is?

Dan wordt de as dus wel met een tik op gang gebracht en is de stap toch groter dan bedoeld”.

Deze redenering klopt maar het effect is niet echt storend omdat bij verandering van richting toch eerst de totale speling moet worden overbrugd (zie hoofdstuk 2: Het vooronderzoek).

 

6.5) Experiment 5, hoe is de snelheid wel te regelen.

Bij Experiment 3 werd ontdekt dat het effect ‘statische wrijving’ een moeilijkheid oplevert bij het regelen van  de snelheid.

In de experimenten voor Experiment 4 is een methode gevonden om de as binnen korte afstand uit de omstandigheid te krijgen waarbij statische wrijving optreed. (5 ms volvermogen, dan PWM =100 tot motor beweegt, dan tegengas geven.)

Omdat het regelen van de snelheid een voorwaarde is om de as met een maximumsnelheid naar een positie te sturen, ging ik eerst een testprogramma maken voor de volgende eisen.

Als eerste moest gekozen worden in welke eenheden ‘snelheid’ wordt weergegeven.

Informatici die ik ooit bij mijn werk tegen kwam vonden dit een domme vraag en reageerden: “Volgens de internationale norm natuurlijk, dus meters per seconde”.

Vervolgens werkte hun regelsoftware met de snelheid als ‘drijvende komma variabele’ In die tijd hadden computers daar geen speciale hardware voor, net als de meeste microcontrollers van nu. Dus rekenen met ‘drijvende komma variabele’ kostte heel veel meer tijd dan rekenen met integer variabelen. Bij het testen beweerden ze dat ze het ook niet konden helpen dat de regelsoftware zoveel tijd van de CPU nodig had (ik wordt er weer boos om). Ik vind dat als je bij besturingssoftware de mogelijkheid hebt om het de CPU makkelijker te maken, internationale normen maar moet laten voor wat ze zijn en variabelen moet definiëren in eenheden waarmee het regelproces zo efficiënt mogelijk geïmplementeerd kan worden. Dat je deze omrekent, als je die variabele aan de operator toont, is een andere zaak. Aangezien ik zelf de operator zal zijn, en dit alleen maar extra programma omvang veroorzaakt, koos ik er voor om dit na te laten.

Omdat de clock-interrupt-routine het aantal clock-ticks kan tellen om een bepaalde positie te bereiken, dus om een bepaalde afstand af te leggen werk ik met tijd per afstand. Uiteindelijk kwam ik (na wat experimenteren met de X en Y as) uit op uit op clock-ticks per 5 encoder stappen ( per 0.00166 mm).  Dit is ongeveer gelijk aan het aantal seconden dat de as nodig heeft om 10 cm te verplaatsen. Voor de maximumsnelheid van 4 mm /sec is dit getal dus 25 en het bleek dat de statische wrijving ons parten gaat spelen als dit getal groter wordt dan 270. Bij het meten  kunnen we net voor of na de clock-tick de opgeregen positie bereiken dus we kunnen wel eens 1 tick fout meten. Bij de hoogste snelheid is de meetfout dus <= 4% en bij een lage snelheid ( b.v. 250) 0.4 %.

Bij de hoogste snelheid duurt een meting 25 / 6000 = 0.00416 sec (4 ms) en bij een lage snelheid 42 ms.

Als ik gekozen had om het aantal clock-tick te tellen die nodig zijn voor 10 encoder stappen, in plaats van 5, dan was de mogelijke meetfout gehalveerd maar de meettijd verdubbeld. Het eerste is goed voor de regelnauwkeurigheid, maar het tweede slecht. De eerste proeven deed ik met meten over 3 encoder stappen (0.01 mm) dat werkte niet zo goed. De 5 encoder stappen zijn dus bepaald met experimenten waarbij naar de snelste bruikbare meting gezocht werd.

 

De regellus (die zolang de knop ingedrukt is gestart wordt) bestaat uit de volgende stappen:

  1. Start de snelheidsmeting.
  2. Wacht of tot de meting klaar is, maar controleer ondertussen of de as (door een vorige opdracht nog) de verkeerde richting opdraait en of de meettijd een bepaalde maximum waarde overschrijd waaruit we concluderen dat de statische wrijving de beweging heeft gestopt.
    Als de as de verkeerde richting op gaat wordt de motor op maximum vermogen gezet en is de regellus klaar.
    Als de meting te lang blijkt te duren (as gestopt) wordt als bij een kleine stap (zie Experiment 4) de as weer aan de gang gebracht. Alleen remmen we wat minder, zodat de as net blijft bewegen en wordt een laag vermogen ingesteld waarbij hij net blijft bewegen..
    Als de meting wel binnen de gestelde maximum tijd klaar is, dan wordt de correctie voor het ingestelde vermogen berekend en de nieuwe waarde naar de hardware gestuurd. 

Het berekenen van de vermogens correctie is niets bijzonders als je een beetje thuis bent in regeltechniek en bestaat uit het volgende:

  1. Je bepaalt de regelfout, dat is: het verschil tussen de gemeten snelheid en de gewenste snelheid. Je vermenigvuldigt deze met een factor en je hebt deel A van de correctie voor de PWM stand. Daarmee bereken je de voorlopige nieuwe PWM waarde. Bovendien sla je de regelfout op voor gebruik in de volgende doorgang van de regellus.
  2. Je bepaalt het verschil van de gemeten regelfout en die welke in de vorige doorgang van de regellus is gemeten. Dit verschil is dus een maat voor hoe snel de doelsnelheid wordt benaderd. Je vermenigvuldigt dit getal met een tweede factor en je hebt deel B van de Vermogenscorrectie. Je trekt deel B af van de voorlopige nieuwe PWM waarde (zie vorige punt). Om het doel hiervan uit te leggen bekijken we het volgende geval. Stel U voor dat de gemeten snelheid nog te laag is dus deel A is positief, maar de snelheid nam snel toe tussen het uitvoeren van de regellussen. dan kan deel B de totale vermogenscorrectie zelfs negatief maken. Bij een juiste keuze van de vermenigvuldigingsfactoren voorkomt dit dat de snelheid hoger wordt dan de bedoeling is. Het doel wordt dus langzaam benaderd.
    Wanneer, tijdens de voorgaande regellus, de as gestopt was door statische wrijving en we hem weer op gang moeten helpen, wordt deel B niet uitgerekend want er is geen betrouwbare voorgaande snelheidsfout. Dan wordt alleen deel A als correctie gebruikt.
  3. Als de voorlopige nieuwe PWM waarde groter is dan 255 dan maak je hem 255 of als hij kleiner is dan 0 dan maak je hem 0.
  4. Je stuurt de voorlopige nieuwe PWM waarde naar de hardware en schrijft hem in RAM als ingestelde PWM waarde (ingesteld vermogen).

Merk op dat we bij het regelen geen gebruik maken van ‘remmen’ maar liever de doelsnelheid langzaam benaderen. Dit is om ‘tikken’ veroorzaakt door de speling in de tandwielkast van de motor en de koppeling van aandrijving en spindel te voorkomen (zie Experiment 4, punt 4).

 

De kunst was om de volgende waarden te vinden:

De grafieken van de gegevens die gebruikt werden tijdens Experiment 4 geven niet genoeg informatie. Bovendien zijn de tabellen veel te vlug vol, want regelen is een langduriger proces dus elke milliseconde in de tabellen schrijven is te frequent.

Daarom heb ik het aantal tabellen uitgebreid, en wordt er in de tabellen alleen waarden toegevoegd als er naar de PWM output wordt geschreven. Bovendien beginnen we na de laatste positie van een tabel opnieuw aan het begin te schrijven zodat de tabellen altijd de laatst geschreven metingen bevatten. Het uitprinten in de goede volgorde is wel wat complexer dan bij Experiment 4, maar goed te doen.

In de tabellen worden de volgende gegevens opgeslagen:

Na het uitpinten wordt het verloop van de snelheid dus weergegeven in de 4e kolom en de laatste kolom geeft de vermogensinstelling. Met de gegevens in de eerste kolom kan de tijd voor 1 regellus bepaald worden.

Met de gegevens op een regel (en de vorige regel) kan het berekenen van de vermogenscorrectie gecontroleerd worden.

Bij het regelen van de as naar een gewenste positie zijn bovenstaande gegevens ook voldoende. Als we twee assen tegelijk gaan regelen worden de as aanduiding in de tweede kolom belangrijk.

 

Met dit gereedschap ben ik instaat geweest om de gezochte constanten te bepalen maar dat is wel heel veel werk geweest. Het sturen en meten met een microcontroller en gegevens analyseren op een PC is veel inefficiënter dan alles doen met een PC. Nu bestond een optimaliseringslag uit:

  1. Constanten die je wilt proberen invoeren in het programma en dit compileren.
  2. Programma downloaden naar de micro (kost tijd)
  3. Proef uitvoeren.
  4. Gegevens naar PC versturen en opvangen met de terminal emulator opvangen (tijd en bedieningshandelingen)
  5. Gegevens in EXCEL inlezen, grafieken maken en bestuderen.

Omdat de regeling bij verschillende snelheid goed moet werken (en ik misschien wel niet zo slim of goed opgeleid ben) heb ik bovenstaande optimaliseringslagen wel meer dan 200 keer doorlopen.

Toen mijn elektronica toch een keer door metaalstof kapot ging (de kast had open gestaan) was ik toch blij dat ik voor een microcontroller had gekozen. Deze storing koste me alleen een nieuwe IC van E1.25 en geen hele PC.

 

Bij deze proeven ontdekte ik nog een nieuw probleem (uitdaging). In bovenstaand vooronderzoek heb ik het al gehad over de speling in de spindels, d.w.z. Als je een as een bepaalde richting hebt gedraaid, en je draait dan de andere kant op, dan kun je een flink eind draaien (ongeveer 0.75 mm op de schaal op het handwieltje) voor de x-y tafel werkelijk gaat bewegen. Deze hoek (de hoeveelheid encoder-stappen) is wel aardig constant dus voor het bepalen van de positie van de tafel kan het programma er rekening mee houden.

Het probleem is dat het draaien aan de spindel ook veel makkelijker gaat dan als de x-y tafel in z’n stroeve geleiding  moet worden bewogen. In dit stuk gelden daarom andere regel constanten.

Van dit ‘gat’ in de positiemeting (ik duidt het in het vervolg aan met het engelse woord ‘gap’) kunnen we de grootte opgeven aan het programma. Hierdoor kan het programma bepalen wanneer ander regelgedrag noodzakelijk is. Gelukkig is een juiste snelheid van de motor in het ‘gap’ minder belangrijk zolang de spindel maar met zeer lage snelheid aan de overkant aankomt.

 

De grootte van het ‘gap’ kan met een programma functie worden bepaald door de as eerst in een richting te laten stappen tot een metalen blokje in de machineklem elektrisch contact maakt met een frees, en vervolgens de andere kant op te laten stappen tot het contact verbroken is. De machineklem had ik geïsoleerd gemonteerd en aan een input verbonden weet U nog wel?

 

Met de verworven kennis maakte ik test programma 5 af voor de X en de Y as die ik dus met 4 knoppen op instelbare snelheid omhoog en omlaag kon sturen. (Z is een bijzonder probleem dat komt later). Bovendien toonde het LCD de stand van de assen in encoder-stappen (‘steps’ genaamd) en de bovenzijde van het ‘gap’ in 0.01 mm. Deze laatste waarde wordt als X of Y ‘positie van de tafel’ genomen.

Met een extra knop combinatie kan de ‘X positie van de tafel’ en de ‘Y positie van de tafel’ apart op 0 gezet worden. Als de motor aan de onderzijde van het ‘gap’was staat deze dus op een negatieve waarde.

Nog 4 extra knop combinaties werden gekoppeld aan de functies: Met maximale snelheid omhoog / omlaag. Die functies waren simpel (richting goed zetten en PWM op 255).

Met dit test programma was het al makkelijker om de freesmachine te gebruiken dan bij handmatige aandrijving.

Deze functies zijn nog steeds onderdeel van de Locale Bediening via knoppen op de besturingskast.

 

6.6) Experiment 6, X en Y as sturen naar een opgegeven positie.

Eis nr. 2: (De positieregelingen mogen zeker niet doorschieten) en, het gevaar dat dit veroorzaakt kan worden door de speling in de tandwielkast van de motor en de koppeling van aandrijving en spindel, veroorzaakt dat de positieregeling moet worden uitgevoerd in 3 fasen met elk hun eigen regelalgoritme.

Elke van deze fasen heeft zijn eigen regellus. Een doorgang van de regellussen voor fase 1 en 2 voert ook een doorgang van de snelheidsregel-lus uit.

 

U kunt zich voorstellen dat als we een heel kleine verplaatsing willen uitvoeren we Fase 1 en 2 moeten overslaan.

Voor een wat grotere verplaatsing kan het zijn dat de opgegeven maximumsnelheid al te hoog is. We zouden al snelheid moeten verminderen voor de motor de opgegeven maximumsnelheid heeft bereikt. Daarom beoordeelt de routine die het positieregelen start in welke fase moet worden begonnen en berekent hij een schatting voor de maximale snelheid die toepasbaar is voor deze beweging.

Tijdens het ‘afmaken van de software voor alle eisen’, hieronder beschreven in hoofdstuk 8, bedacht ik dat snelheid laag houden aan het einde van een beweging niet in alle gevallen gewenst is.

Soms is doorschieten voorbij de gewenste positie helemaal niet erg en is het vertragen zelfs ongewenst. Als we gaten boren, dan is het helemaal niet erg als de Z doorschiet bij het weer omhoog halen van de boor. Als de frees het werkstuk tijdens het doorschieten van een X of Y beweging toch niet meer raakt omdat we frezen tot de rand van het werkstuk, dan geeft ‘on speed’

doorbewegen tot de opgegeven positie een gelijkmatiger resultaat en het doel word sneller bereikt (gepasseerd). Daarom maakte ik een extra soort opdracht aan de positie regel software mogelijk.

Bij het uitvoeren van deze opdracht wordt de hele beweging uitgevoerd met de regellus van fase 1 en zal deze regellus de snelheid niet verminderen. Als het doel bereikt (gepasseerd) is wordt de motor uitgeschakeld en is de opdracht klaar. Vooral bij het uitvoeren van een script levert dit snelheidswinst op omdat de microcontroller dan al aan het volgende commando kan beginnen terwijl de motor nog niet stil staat. Bij het maken van het script moet je natuurlijk goed in gedachte houden dat een as die ‘on speed’ naar een positie is gestuurd niet op die positie is gestopt.

 

Voor de bediening werden (naast de positie regellussen) 4 knopfuncties aan het programma van Experiment 5 toegevoegd en wel 2 voor de X as en 2 voor de Y as. Bij het indrukken van de ene knop wordt de maximumsnelheid (in clock-ticks) op de onderste regel van het LCD getoond die je dan met de draaiknop kan veranderen. Bij het indrukken van de tweede wordt de doelpositie (in 0.01 mm) op de onderste regel van de LCD getoond die je ook hier weer met de draaiknop kan veranderen. Na het loslaten van deze knop wordt de beweging uitgevoerd.

 

Bij het testen van dit programma realiseerde ik me dat voor het boren van b.v. gaten in printjes nog een paar knopfuncties erg handig zouden zijn. Deze gaten zitten meestel op een raster (grid) van 0.1 inch = 2.54 mm.

Daarom bouwde ik per as nog 3 knopfuncties in.

Deze extra mogelijkheid maakte heel wat rekenen en precies mikken met de draaiknop overbodig.

Toen dit werkte maakte ik nog de functie voor een derde extra knop die bij het instellen van de doelpositie kan worden gedrukt. Deze functie zet de waarde van ‘de vorige doelpositie’op het LCD. Zo kun je een as instellen zonder met de draaiknop tussen twee posities heen en weer sturen.

 

Hoewel er met dit programma nog lang niet voldaan werd aan alle gestelde eisen (er zat zelfs nog geen motor aan de Z as) was het al heel bruikbaar. Ik gebruikte het zelfs om alle mechanische onderdelen te maken om een motor en encoder aan de spindel van de Z as te bouwen. Met zaag, vijl en boor had ik dit niet voor elkaar gekregen.

 

6.7) Experiment 7, Het besturen van de Z-as.

De mechanica van de freesmachine voor de Z beweging is anders dan die van de X_Y tafel. Wel vinden we ook hier zwaluwstaartgeleidingen. Verder kan de slee met frees, zoals bij een boorstandaard, doormiddel van een hefboom tegen de druk van een veer in naar beneden getrokken worden. Door het omzetten van een palletje kan dit ook gedaan worden met een spindel. De speling in de spindelaandrijving is groot (wel 2 mm), maar als de veer wat voorspanning levert heb je hier geen last van.

Verder kun je de veer doormiddel van een draaiknop al dan niet actief maken. Als de veer niet mee doet, zakt de slee met frees en motor op eigen gewicht omlaag mits de zwaluwstaartgeleidingen  niet strak (stroef) zijn ingesteld. Omdat dit vanwege een nauwkeurige geleiding eigenlijk wel nodig is koos ik voor een actieve veer.

Het nadeel hiervan is dat de kracht die de motor moet opbrengen om de slee omlaag te duwen groter wordt naarmate de veer verder gespannen wordt.

Bij eenzelfde motor zoals gebruikt bij X en Y as (vertraging 1:50) was maar 1.5 cm bruikbaar van de 8 cm die de slee omhoog en omlaag kan. Daarom verving ik de motor door een met een vertraging van 1 : 100 waardoor 2.5 cm bruikbaar werd. Vanwege andere verstelbaarheid van de machine kon ik wel kiezen welke 2.5 cm, dus accepteerde ik dit compromis met tegenzin.

En ander nadeel was dat de constanten voor de snelheidsregeling voor het omhoog gaan anders moeten zijn dan voor het omlaag gaan. In het eerste geval helpt de veer, in het tweede geval werk hij tegen. Ik heb nog proeven gedaan om de functie van de veer te laten uitvoeren door een katrollen systeem met tegengewicht in de pijp waaraan de Z slede wordt geklemd. Hierbij is de kracht wel constant over de hele 8 cm, maar dit werkte bij kleine verplaatsingen toch niet goed.

 

Nadat het programma van Experiment 6  is uitgebreid met de zelfde knopfuncties voor Z als die voor X en Y en met de aangepaste snelheidsregeling had ik een programma waarvan ik dacht: Aan eis 1, 2, 3, 5, 7, en 8 is voldaan. Nu 4, 6 en 9 nog. De ontwikkeling van die functies is niet relevant in dit hoofdstuk. Het resultaat wordt in een later hoofdstuk beschreven samen met wat ik nog meer verzon.

 

7) Gedonder met de PROXXON MICROMOT 220/E.

In hoofdstuk 2 heb ik verteld dat ik niet de Freesmotor BFW 40/E had gekocht en de kleinere Proxxon MICROMOT 220/E met wat knutselen had gemonteerd. Bij de proeven met de X as had ik al eens zo’n  MICROMOT gemold toen de as tijdens het frezen wat sneller bewoog dan ik had ingesteld (sorry een bug in het programma). Een borrel verdoofde het verdriet, en de volgende dag, na een tocht naar de bouwmarkt, deed alleen m’n portemonnee nog zeer. Ruim een jaar later sneuvelde deze vervanger ook. De geharde stalen as brak net voor het hoofdlager. Dit lager zit opgesloten tussen veerringen die in gleuven in de as passen, en het gat waarin je de freesjes steekt loopt door tot halverwege het lager. Bij de voorste gleuf ontstaat dus een zwakke plek. Omdat ik geen enkele reden kan bedenken waarom het gat niet 5 mm ondieper is gemaakt vind ik dit een constructie fout. De service dienst van PROXXON leverde me wel (tegen betaling) een nieuwe as, maar ik was al dommer dan een ezel, en wilde me niet voor een derde keer aan dezelfde steen stoten.

Bij www.kruis.nl kreeg ik een goede deal bij het bestellen van de Freesmotor BFW 40/E die eigenlijk bij mijn PROXXON spul hoort. Deze is geen veel groter en zwaarder uitgevoerd en levert veel meer kracht bij veel lagere toerentallen dan de MICROMOT. Ook kunnen er grotere frezen gebruikt worden (spantangen van 2.5 tot 6 mm).

 

Toen ik de BFW 40/E ging gebruiken bleek dat meer consequenties te hebben dan ik verwacht had. Zo bleek de keuze om Z tegen veerdruk om laag te duwen (zie 6.7) de verkeerde. Omdat frezen spiraalvormige snijkanten hebben veroorzaken ze (bij de sterkere motor) een neerwaartse kracht die samen met het gewicht van de freesmotor groter kan zijn dan de kracht van de veer. De veer elimineert de speling dan niet meer.

Omdat de BFW 40/E veel zwaarder is, kon ik de speling laten elimineren door de zwaartekracht. De neerwaartse druk wordt dan niet meer geleverd door de spindel wat een probleem is bij het boren. Dit heb ik opgelost met gewichten van 1.7 kg en 2.4 kg die stabiel op de freesmotor kunnen worden gezet waardoor de totale gewicht (= druk op de boor of frees) op 5.3 kg komt.

 

Veel ingrijpender was dat een conclusie getrokken tijdens het vooronderzoek niet meer klopt. De roterende frees veroorzaakt een kracht haaks op de beweging van de frees. Bij de MICROMOT was die kleiner dan de statische wrijving van de nastelbare zwaluwstaartgeleidingen van de X - Y tafel, bij de BFW 40/E niet.

Als je in X richting freest kan de X-Y tafel dus in Y richting gaan bewegen over een afstand gelijk aan de speling van de spindel.

De eerste oplossing die ik verzon was: Maak er een paar commando’s bij waarmee je de spindels aan de boven of onderkant van het ‘gap’ kunt sturen zodat de haakse kracht niet in de richting van de speling werkt.

De tweede oplossing: Laat de microcontroller voor een X beweging de Y spindel aan de goede kant van het ‘gap’ zetten (en de X spindel bij een Y beweging).

Met deze oplossing heb ik lang gewerkt.  Maar, er kwam nog een ander probleem boven water. Als je een randje wilt frezen van materiaal  waarbij de frees kracht moet zetten, dan werkt de oplossing wel in de ene richting goed, maar in de ander richting (frees snijdt in de richting van de verplaatsing), dan wijkt de frees toch een beetje. Voor nauwkeurig werk moet je het randje dan meerdere keren frezen.

 

Als laatste uitbreiding project (na de uitbreiding die het kopen van een draaibankje overbodig maakte) besloot ik om de problemen met deze 2 spindel speling grondiger op te lossen.

Bij levering had de X –Y tafel twee M4 bouten met knop waarmee de X en Y beweging kon blokkeren. Je draait de bout aan, en klemt daarmee de tafel vast.

Om dit te automatiseren kocht ik bij Conrad 2 kleine 12V motoren en een assortiment kunststof wandwieltjes (bestel nr. 29 77 04 04) en maakte met behulp van m’n freesmachine nog wat mechanische onderdelen waardoor de motoren via een vertraging van 1 : 125 konden draaien aan een stuk M4 draadeind.

 

Het eerste ontwerp voor de stuurelektronica van deze motoren bleek niet het goede. Dit idee was:

Ik verwachtte dat het contact bij het vastdraaien nog gesloten bleef tot de hoge aanloopstroom van de motor voorbij zou zijn. Als bij het losdraaien de spanning uitgezet zou worden zou de motor immers nog wel even door draaien. Het contact wat ik in de mechanica had gebouwd bleek niet te voldoen en een microswitch bleek moeilijk afstelbaar in te bouwen.

 

Bij het tweede ontwerp worden, per motor twee signalen van de microcontroller gebruikt. Een voor links om en 1 voor rechtsom. Bovendien kan de microcontroller via een ADC ingang de motorstroom meten. De software besluit dat de bout vast zit als de stoom 10 ms boven een grenswaarde zit, Het concludeert dat de bout in de ‘los’ stand is als de motorstroom 600 ms lang lager is dan deze grenswaarde. Om zeker te zijn dat het losdraaien wordt de volgende procedure uitgevoerd:

 

8) Software afmaken voor alle eisen.

Toen ik aan de hierboven beschreven software begon, was die alleen maar bedoeld voor het ontdekken van de eigenschappen van de mechanica (zie begin hoofdstuk 5). Natuurlijk probeerde ik wel modules te maken die met minimale inspanning in het definitieve programma zouden kunnen worden opgenomen.

Toen ik koos om niet 1 microcontroller per as plus 1 voor coördinatie te gebruiken, maar alles met 1 microcontroller te doen, wist ik nog niet dat de snelheidsregelingen en de positie regelingen zoveel programmaruimte zou vergen.

Het grootste probleem bij het maken van de definitieve software was dan ook: “Hoe krijg ik alles in de beschikbare 48 kB”.

Dat het uiteindelijk toch gelukt is, komt door de volgende acties:

 

Een ander nadeel, van het gebruik van maar 1 microcontroller is: de tijd dat deze moet besteden aan het tonen van gegevens op de schermen. Hoewel schrijven op het LCD veel sneller is dan schrijven via de RS232 interface moest ik er voor kiezen om de actuele posities van de assen niet te tonen tijdens een beweging (pas erna). Zelfs als de machine bediend wordt via de PC toon ik de gegevens die het vaakst veranderen op de LCD want dit gaat sneller.

Wanneer een heel groot script (serie van commando’s opgeslagen in het geheugen) wordt uitgevoerd, is dit tonen van gegevens soms niet nuttig. Om tijd te sparen maakte ik dit daarom uit- en weer inschakelbaar (via knoppen onder het LCD). Voor een freesklus waarvoor 250.000 bewegingen moesten worden gemaakt zelfs al kost  het schrijven van een lijn op LCD maar 0.01 sec. is de uitvoeringstijd toch 2500 sec. (42 minuten) korter.

 

In hoofdstuk 5.2 (Real time aspecten) heb ik beschreven hoe ik met behulp van Statemachines de X en Y as gelijktijdig naar een nieuwe gewenste positie kan laten bewegen. Wanneer dat bewegingen zijn waarbij de frees of boor geen contact maakt met het werkstuk, dan is het helemaal niet belangrijk of dat gebeurd volgens een rechte lijn. Bij het boren van een groot aantal gaten in een printje geeft het gelijktijdig bewegen van X en Y naar een nieuwe boorlocatie een grote snelheidswinst.

Het frezen volgens een rechte lijn met zowel een X als een Y verplaatsing was een veel grotere uitdaging, en wel om de volgende redenen:

·        Als de verplaatsing voor de ene as veel kleiner is dan die voor de andere as, dan kan de snelheid van de as met de kleinste beweging niet zo laag ingesteld worden als nodig is, omdat we dan last krijgen van de statische wrijving.

·        Het opgang brengen van een as nadat hij gestopt is door statische wrijving kost extra tijd waardoor de andere as gaat voorlopen en de beweging niet recht wordt.

·        Het vertragen aan het eind van de beweging door de positie regelingen gaat ongelijk bij assen die op een verschillende gewenste snelheid zijn ingesteld.

Ik heb de volgende oplossing gekozen:

De totale beweging wordt uitgevoerd door een aantal kleine bewegingen die (behalve de laatste) ‘on speed’ aan de X en Y regelingen wordt opgedragen.

Als u vraagt: “Welk aantal?” dan vraag ik: “Wat noemt U recht?” Als U antwoort dat een beweging  ,waarbij de kleinste as verplaatsing 10 mm is, best 1 mm mag afwijken van de ideale lijn, dan is het aantal stapjes dus 10. Dat haal ik nog als de assen niet gelijktijdig bewegen. Als Uw antwoord is: “0.1 mm”, dan is het antwoord dus 100, en bij: “0.02 mm” (nauwkeuriger is de regering niet) is het antwoord: 500.

Het berekenen van ‘tussenpunten’ heet in de wiskunde ‘interpoleren’.

Via een commando met de PC kunnen we opgeven hoe groot de stapjes van de kleinste as beweging zijn tussen de punten waarvoor we ‘interpoleren’. We berekenen dus steeds de positie van de as met de grootste verplaatsing bij de volgende positie voor de as met de kleinste verplaatsing.

Als U het bovenstaande snapt, dan begrijpt U dat:

·        Hoe kleiner de ‘interpolatie stapjes’ worden ingesteld, hoe rechter de beweging, maar ook hoe meer de microcontroller moet rekenen dus hoe langer de beweging duurt.

·        Een beweging via een lijn van 45 graden duurt veel langer dan een net zo lange beweging over een lijn van 5 of 85 graden.

 

Verder kwam ik geen vermeldenswaardige problemen tegen. Op deze plaats vertel ik niet wat het afmaken van de software allemaal inhield. Dat neem ik mee nadat in het volgende hoofdstuk de uitbreiding met de mechanica voor ‘draaien’ is besproken.

 

9) Vervolgproject draaibank functie (zie eis 9).

Al voordat ik aan de besturing begon speelde ik met een boorkop aan een as met lagers.

Deze lagers werden dan in de gleuven van de machineklem vastgezet. Ik kon zo een asje in de boorkop dunner frasen door met de hand aan de boorkop te draaien.

Om b.v. een wiel te maken werd het materiaal eerst aan een tijdelijke as gezet waarna die as dan in de boorkop werd gezet. Omdat de reactiekracht van het freesproces dan handmatig moest worden geleverd gebeurde het nog wel eens dat er iets mis ging en de frees de boorkop met grote snelheid liet draaien. Een stabiele aandrijving was dus vereist.

 

Als tweede proef knutselde ik een boorkop met as en lager (uit een kapotte accu boormachine) aan een stappenmotor en bouwde het geheel in een stevige doos. Deze doos kon dan in de machineklem worden gezet. Voordat ik aan de aansturing van de stappenmotor begon bleek deze proef al mislukt doordat ik het slingeren van het werkstuk bij het draaien niet kon wegwerken.

Tijdens deze proef kreeg ik wel twee goede ideeën.

  1. Doordat het draaimechanisme nu in een ‘doos’ zat kan deze doos ook onder een hoek in de machineklem gezet worden, waardoor ik makkelijker conische einden aan een as kan maken. Dit is dus beter dan lagers klemmen in de geulen van de machineklem.
  2. Als ik een stappenmotor via tandwielen met een grote vertraging aan een as met boorkop zou koppelen zou ik de boorkop heel precies kunnen verdraaien. Dit zou goed te pas komen bij het frezen van tandwielen. Verder kan de stappenmotor ook een grotere reactiekracht van het freesproces opvangen.

 

Dus bestelde ik bij Conrad het grootste (kunststof) tandwiel dat ze hadden (120 tanden) en een bijpassend tandwiel met 10 tanden voor aan de stappenmotor. Bij een IJzerhandel vond ik een meter as van 12mm die in het grote tandwiel past en ook nog 2 kogellagers voor die as.

Een extra printje aan de microcontroller voor het sturen van de 12V stappenmotor was ook niet moeilijk. Gewoon een 8 bit databuffer met een Darlington transistor array ULN2803A er achter (zie: www.voti.nl ). Via 4 van deze uitgangen kan de microcontroller de 4 spoelen van de stappenmotor aansturen. De 4 andere gebruikte ik later om de motoren van de klembouten te sturen (zie hoofdstuk 7). Daarna nog wat extra software die de spoelen van de stappenmotor in de juiste volgorde bekrachtigt, en ik kon de as op 4800 verschillende standen per omwenteling zetten De stappenmotor maakt er 400 per omwenteling  en de tandwielen vermenigvuldigen dit met 120 / 10.

In de software wordt deze as de Phi as genoemd.

 

Bij een winkel die goedkoop spul uit het verre oosten verkocht, vond ik goedkope boorkoppen voor boren tot 12 mm. Ik moest alleen nog een manier vinden om die recht aan een stuk van de as te krijgen en verder ook nog een manier om zo min mogelijk last te hebben van het slingeren van het werkstuk.

Dit laatste loste ik als volgt op:

Het gat met schroefdraad van de boorkop freesde ik uit tot 12 mm (maar een heel klein beetje taps). Het einde van de as werd ongeveer net zo taps afgefreesd, en ik had een passing die vast te lijmen was.

Voor ik dit deed verzon ik nog een verbetering. Ik verving de as door een pijp en boorde een gat van 10 mm. in de boorkop zodat een as waaraan ik wil frezen helemaal door de boorkop en de aandrijfas (pijp) gestoken kan worden. Hierdoor kan zo een as waaraan ik wil frezen op elke plaats ingeklemd worden.

 

 

 

                                                               Foto

 

10) Het bedienen.

Dit hoofdstuk dient als gebruikers handleiding. Het bestaat uit twee delen. In het eerste deel (10.1) wordt eerst het menu weergegeven wat door de microcontroller in het venster van de terminal-emulator wordt getoond. Daarna worden de te geven commando’s per functie beschreven.

In het tweede gedeelte (10.2) wordt iets dergelijks gedaan voor de knoppen onder de LCD.

 

10.1) Bediening via een PC.

 

Als Local control niet actief is toont de microcontroller het volgende in het venster van de terminal emulator:

                        -X-    -Y-    -Z-         CommandFileToWrite = None

Gridsize   (0.01 mm)    254    254     50 Interpolation square lines each 10

Gap (Mechanical play)   270    262     15 <-sensor steps, ALL OTHER IN 0.01 mm

----------------------------------------------------------------------------

SELECT ONE OF THE FOLLOWING!|-X-|-Y-|-Z-|  Contact LCD Menu        :v

Speed limit   (sec / 10 cm) | A | B | C |  Step Sub Menu           :d

Position correction   (now) | x | y | z |  Local Button control    :L

Gridsize                    | H | I | J |  View Text File Data     :V

Break Fixed                 | S | T |   |  Breaks Fixed and enabled:U

Break Released              | s | t |   |  Breaks disabled         :u

Back to Last Position (now) | a | b | c |  Execute commands in file:f

New Target position (later) | X | Y | Z |  Move xyz to Target pos. :M

Target gridsize up  (later) | h | i | j |  Write commands to file  :W

Target gridsize down(later) | n | o | p |  xyz QUICK toTarget      :q

One axes onSpeed to Target  | k | l | m |  z toTarget Fast onSpeed :e

Set current position = 0    | O | P | Q |  Give to PC data of file :g

Set Gap (Mechanical play)   | E | F | G |  Receive from PC file nr :r

Phi Motor Off       : )    Interpotate square lines each (0.01mm)  :N

Phi Motor On        : (    Kill and restart Micro : K    Wait msec :@

Phi ms/step =       : &    Phi move .. steps                       :*

Phi last * move back: [    Phi last * move again                   :]

Phi contiuesly Left : {    Phi contiuesly Right                    :}

Your command:

 
 

 

 

 

 

 

 

 

 


 

 

 

 

 

 

 

 

 

 

Sorry, de menu taal is (lijkt op) Engels. Dat is een gewoonte die tijdens mijn werk is vastgeroest.

 

Op de onderste regel ziet U een vraag om een van de 58 commando karakters te tikken.

Als er voor het uitvoeren van het commando geen waarde nodig is wordt het commando meteen uitgevoerd (1 toets drukken is voldoende)

Als voor het uitvoeren van het commando nog een waarde nodig is, dan wordt deze regel gewist, en wordt er naar die waarde gevraagd. Aangezien de microcontroller niet kan raden uit hoeveel cijfers de waarde bestaat moet het einde aangegeven worden met de ENTER toets waarna het commando wordt uitgevoerd.

Merk op dat als er identieke commando’s zijn voor X Y en Z deze in het menu aangeduid zijn met 1 beschrijving met daarachter, in 3 gemerkte kolommen, de commando letters voor X Y en Z. In de volgende hoofdstukken worden deze commando’s gezamenlijk behandeld.

 

De bovenste drie lijnen tonen een aantal ingestelde waarden, maar niet degene die heel frequent veranderen, want die worden op het LCD getoond.

Hieronder ziet U op een snapshot van het LCD dat voor zowel X, Y als Z vier getallen worden getoond. Dit zijn de waarden van:

X  6823 s250 |Y  2583 s250 |Z    0 s150

r  6822  6814|r  2583  2500|r    0     0

 
 

 

 


Het voordeel van het gebruik van de LCD voor frequent veranderende waarden is:

Het nadeel, dat er geen ruimte is voor een behoorlijke aanduiding van de betekenis van de getallen, nam ik voor lief.

 

 10.1.1) Randvoorwaarden instellen voor bewegingen.

Na het opstarten van de microcontroller wordt de maximum snelheid van X Y en Z laag gezet dus de waarde voor sec per 10 cm hoog (250). Deze instellingen kunnen met commando’s A B en C worden gezet op 0 … 255.  De waarden 0 … 15 zullen hetzelfde effect veroorzaken, omdat met vol vermogen toch niet kan halen.

De snelheid van de stappenmotor van de constructie draaibank functie (de Phi as) wordt aangegeven in ms per stap en is via commando & instelbaar tussen 1 en 255.

 

In hoofdstuk 6.6) hadden we het al over het concept raster (grid). Na het opstarten van de microcontroller worden de variabelen die de ‘grid’ waarden opslaan op een standaard waarde gezet, welke veranderd kunnen worden met commando’s H I en J. De ingestelde waarden kunnen worden gecontroleerd want die worden getoond in de bovenste drie status regels op het PC scherm. Commando’s die gebruik maken van deze waarden worden beschreven in hoofdstuk: 10.1.1) Commando’s voor het maken van een beweging.

 

Na het opstarten van de microcontroller worden de variabelen die de positie van X Y en Z as aangeven (in encoder steps) op 0 gezet. Op dat moment is het onbekend of de assen aan de ene of aan de anderen kant van het ‘gap’staat. Daarom wordt na het opstarten met elke as een kleine beweging heen en terug gemaakt zodat de software in het vervolg op juiste wijze rekening kan houden met de 3 ‘gap’s. De positie van de boven kant van het gap wordt aangegeven in (0.01 mm) als de positie van de tafel.

Als we aan een werkstuk beginnen zullen we de frees eerst naar de plaats brengen die we als oorsprong van het assenstelsel willen hanteren. Met commando’s O P en Q kan aangegeven worden dat de huidige tafel positie als nulpunt voor betreffende as moet worden genomen. Als de as aan de onderkant van het ‘gap’ staat dan wordt de variabele die door de encoder wordt veranderd dus gezet op: ‘gap’ grootte maal -1.

 

 Na het opstarten van de microcontroller worden variabelen die de ‘gap’ grootte moeten opslaan op waarden gezet die met vorige versies van het programma zijn bepaald. Voor experimenten kunnen deze waarden veranderd worden met commando’s E F en G. De ingestelde waarden kunnen worden gecontroleerd want die worden getoond in de bovenste drie status regels op het PC scherm.

 

De stapgrootte voor het ‘interpoleren’ van ‘tussenpunten’ (zie hoofdstuk 8) wordt na opstarten op 10 (= 0.1 mm) gezet en kan met commando N worden veranderd. De ingestelde waarde kan worden gecontroleerd want die wordt getoond in de bovenste drie status regels op het PC scherm.

 

10.1.2) Commando’s voor het maken van een beweging.

Commando’s X Y en Z kunnen worden gebruikt om een nieuwe ‘Target’ (doel) positie op te geven. Het enige wat de software doet bij het uitvoeren van een van deze commando’s is vragen naar deze nieuwe waarde, en deze opslaan in RAM. De nieuwe waarde wordt ter controle ook getoond op de LCD. Deze commando’s vragen dus naar een getal dat moet worden ingetikt.

Soms kunnen minder bewerkelijke manieren gebruikt worden om een de targetpositie te veranderen.

De beweging naar de nieuwe positie wordt nog niet uitgevoerd tot een van de volgende commando’s worden gegeven.

 

Commando M  (move) start de meest complexe manier van bewegen. Eerst wordt de Z as naar zijn Target positie gestuurd en daarna worden de X en Y as simultaan naar hun nieuwe positie gebracht waarbij de frees beweegt via een ‘rechte’ lijn. Hiervoor worden dus ‘tussenpunten’ berekend via ‘ínterpoleren’ (zie hoofdstuk 8). Bij het maken van de beweging zal een as nooit sneller bewegen dan de ingestelde maximum snelheid. In de praktijk zal deze snelheid, bij gelijktijdig bewegen van X en Y, niet worden gehaald omdat deze beweging opgedeeld wordt in een aantal kleine bewegingen.

Als de actuele positie en de target positie van een as gelijk zijn zal de as natuurlijk niet gaan bewegen. Als alleen de X as of de Y as een nieuwe target positie heeft is de ingestelde maximum snelheid dus wel belangrijk.

 

Er zijn gevallen waarin we er helemaal niet in geïnteresseerd zijn dat er een ingestelde maximum snelheid wordt aangehouden en dat de XY beweging van de frees in een rechte lijn wordt uitgevoerd. Dit is bijvoorbeeld het geval als de frees tijdens het bewegen geen materiaal zal verspanen. We willen dan alleen maar dat de target posities zo snel mogelijk worden bereikt.

We zouden dan dus eerst de commando’s A B en C kunnen gebruiken om een hoge snelheid in te geven, en na het uitvoeren de gewenste snelheden terug te zetten. Al dit tikwerk maakt een snelheidswinst onwaarschijnlijk.

Daarom is commando q (quick) geprogrammeerd. Dit commando voert weer eerst de Z beweging uit, maar dan op maximum snelheid, en daarna simultaan de X en Y bewegingen. Ook X en Y bewegen om maximum snelheid, en er worden geen tussenpunten berekend.

Na uitvoering van commando q zijn de ingestelde snelheden zoals die waren voordat commando q gestart werd.

 

In hoofdstuk 6.6 werd gemotiveerd dat we de target positie voor een as soms liever ‘on speed’ wilden bereiken waarbij we het doorschieten accepteerden.

De commando’s k l en m starten heton speed’ bewegen van de corresponderende as naar zijn target positie (dus alleen van die as). Commando e doet hetzelfde als commando m maar dan op maximum snelheid. Dit commando gebruik ik bij voorkeur om na het boren van een gat de boor weer omhoog uit het gat te sturen.

 

De hierboven beschreven commando’s zijn goed om de frees naar een, op één of andere manier berekende positie te sturen.

Als je bijvoorbeeld wilt dat de frees 5.1 mm naar links zal bewegen, moet je  (uit je hoofd) 510 van de gerealiseerde target positie aftrekken en deze waarde met commando X ingeven en daarna ook nog commando M geven. Om hetzelfde zonder reken en met minder tikwerk te doen zijn de commando’s x y en z toegevoegd aan het programma.

Deze commando’s vragen naar de gewenste correctie van de ‘target positie’ en starten de beweging direct voor de corresponderende as (met de ingestelde maximum snelheid). Let op: je kunt de target posities eerst veranderen (b.v. met grid size) zonder de beweging te starten en daarna de target positie nog eens aanpassen en de totale beweging starten met commando x y of z.  Dit is soms handig. Als je bijvoorbeeld de X as twee grid’s  naar rechts wilt sturen tik je ‘hhx’gevolgd door de ENTER toets. Omdat je geen cijfers tikt achter x en voor ENTER is de correctie opgegeven met commando x gelijk aan 0.

 

Soms wil je zoveel van het werkstuk afhalen dat de frees dit niet in één beweging kan uitvoeren.

Dan zul je b.v. de X as een aantal keren heen en weer sturen en na elke X beweging de Y as een beetje corrigeren. Om veel tikwerk te voorkomen zijn, voor dat heen en weer bewegen, zijn de commando’s a b en c  (terug naar vorige positie) aan het programma toegevoegd.

 

10.1.3) Besturing van het remmen van de X en Y beweging.

In hoofdstuk 7 heb ik verteld dat ik, als laatste uitbreiding, remmen (breaks) heb aangebracht waarmee de microcontroller de freestafel in X en / of  Y richting kan vastzetten.

In normale omstandigheden worden deze remmen automatisch bestuurd volgens de volgende regels:

Er zijn natuurlijk gevallen waar bovenstaande regels niet voldoende zijn, bijvoorbeeld als het toch beter is dat beide remmen vast staan bij een Z of  Phi beweging. In die gevallen kunnen de remmen worden vastgezet met de commando’s S en T. Om de rem mechanismen te kunnen testen zijn de commando’s s en t toegevoegd die de remmen los sturen.

Wanneer we gaatjes boren met een klein boortje (bijvoorbeeld in een printje), of erg zacht materiaal verspanen, is het vastzetten van de rem, van een as die niet moet bewegen, alleen maar tijdverspilling.

In die gevallen kan het automatisch vastzetten worden verhinderd door het geven van commando u.

Dit verhinderen kan weer worden opgeheven via commando U wat ook beide remmen vast stuurt.

 

10.1.4) Commando’s voor de stappenmotor van de Phi-as

De stappenmotor wordt nu gebruikt voor de draaibank optie zoals beschreven in hoofdstuk 9.

De optie wordt via een plug aan de besturingskast aangesloten. Natuurlijk kunnen we via deze plug ook een ander mechanisme met een stappenmotor aansluiten. Daarom wordt voor deze motor de algemene naam Phi motor gebruikt.

Omdat bijna alle hoofdletters en kleine letters a … z toegewezen zijn aan andere commando’s gebruik ik voor de Phi motor leestekens.

Voor de Phi as heb ik geen commando gemaakt waarmee je de as naar een op te geven positie kan sturen, omdat ik niet kon verzinnen hoe die positie dan wel zinnig weergegeven zou kunnen worden.

Bedenk dat ik de Phi as best een maand lang met 500 stappen per seconden zou kunnen laten draaien zonder dat het draaibank mechanisme vast loopt. Het aantal stappen zou kunnen worden uitgevoerd is groter dan de microcontroller kan aangeven.

Daarom kunnen we met commando * het aantal stappen opgeven voor het draaien door de stappenmotor. Een negatief getal betekend ‘Linksom’. Een positief  getal betekent rechtsom.

Met 1 commando kan een beweging van +/ -  32767 stappen worden veroorzaakt.

 

De snelheid waarmee de beweging wordt uitgevoerd kan worden gedefinieerd met commando &.

Hiermee leggen we het aantal milliseconden per stap vast tussen 1 en 255.

Geven we een getal op dat groter dan 255 is, dan wordt dit gecorrigeerd naar 255. Het getal 255 past nog net in een byte en werken met grotere getallen kost onevenredig veel CPU tijd.

Geven we een getal kleiner dan 1 op, dan wordt dit gecorrigeerd naar 1. De kracht die de stappenmotor levert wordt lager naarmate de snelheid hoger wordt ingesteld (door de inductie van de spoelen). Zo is de instelling van 1 ms per stap alleen maar bruikbaar als de frees het werkstuk niet raakt.

 

Wanneer de motor herhaaldelijk dezelfde hoeveelheid stappen moet maken, is veel tikwerk te voorkomen door gebruik van de commando’s [ en ]. Commando ] veroorzaakt een beweging zo groot als de laatste beweging met commando * en wel in dezelfde richting.

Commando [ veroorzaakt een beweging zo groot als de laatste beweging met commando * maar dan in tegengestelde richting.

 

Het werken met de draaibank functie had ik me als volgt voorgesteld: De stappenmotor laat het werkstuk continu draaien waarna de frees bestuurd wordt als bij een stilstaand werkstuk.

Aangezien de frees niet bestuurd kan worden tijdens het uitvoeren van commando *, kreeg de

clock-interrupt-routine er de taak bij om de stappenmotor indien gewenst op de ingestelde snelheid te laten draaien in de gewenste richting.

Of hij de stappenmotor moet laten draaien, en in welke richting, wordt bestuurd door een variabele in RAM die we via commando’s (en knoppen onder de LCD) op 1 van de volgende waarden zetten:

Om de motor op de ingestelde snelheid te laten draaien bevat dit deel van de clock-interrupt-routine

ook nog een timer waardoor het kan bepalen of de motor al dan niet een stap moet maken.

 

Na het opstarten van de microcontroller wordt de besturingsvariabele op 0 gezet zodat deze functie van de clock-interrupt-routine niet actief is. Met commando { zetten we deze functie op linksom en met commando } op rechtsom.

Het hierboven beschreven commando * zet de besturingsvariabele op 0 om te voorkomen dat zowel dit commando als de clock-interrupt-routine de motor een stap laten maken.

De besturingsvariabele wordt ook op 0 gezet door commando “Phi motor Off” = ). Dit commando veroorzaakt ook nog dat alle spoelen van de stappenmotor stroomloos geschakeld worden zodat de Phi as met de hand verdraaid kan worden.

Commando “Phi motor On” = ( schakelt de stroom naar de stappenmotor weer in.

 

10.1.5) Scripts.

Eis nr. 6 (zie hoofdstuk 3.1) stelt: “De besturingskast moet een serie commando’s kunnen opslaan om die later uit te voeren, ook nadat de PC losgekoppeld is”.

De eerste vraag is dan: “Hoe worden die commando’s dan opgeslagen?”. Voor de hand ligt het antwoord: “In een tabel in RAM slaan we de ASCII karakters op die we zouden tikken als we de commando’s stuk voor stuk zouden geven”.

Om het nog wat mooier te maken koos ik om de beschikbare ruimte in RAM te gebruiken voor een stapel van 10 ‘tabellen’ zodat er 10 series commando’s kunnen worden opgeslagen waarvan er een gekozen kan worden om uitgevoerd te worden. De ruimte in RAM wordt automatisch verdeeld waardoor het mogelijk is dat alle ruimte wordt gebruikt door 1 tabel. Alleen de lengte van alle tabellen samen is beperkt tot de 20.000 karakters die ik er in RAM voor reserveerde. Op deze manier kunnen er ongeveer 5000 commando’s van gemiddelde lengte worden opgeslagen.

Omdat een serie commando’s (script) voor een werkstuk vaak delen hebben die meerdere keren herhaald worden, heb ik het mogelijk gemaakt dat het script dat met de hand gestart wordt andere scripts als subroutine kunnen gebruiken. Zo was de ruimte in RAM ooit genoeg voor een werkstuk waarvoor de freesmachine 250.000 commando’s moest uitvoeren. Hij deed daar 15 uur over, dus ik ben ondertussen naar bed gegaan J.

Een script maak je met de PC en je slaat dit op in een PC file. Daarom noem ik de tabellen voor commando’s in de microcontroller ook files. In de microcontroller worden files niet aangeduid met een naam, maar met een nummer (0 … 9).

 

Om zo’n script van de PC naar een file in de microcontroller te transporteren doet U het volgende:

  1. U start de terminal-emulator, we nemen hier Hyperterminal van Windows als voorbeeld, en zorgt dat U commando’s kunt geven.
  2. U geeft commando r (Receive from PC file nr). De microcontroller vraagt naar een file nummer, wat U beantwoort met het nummer van de file in de microcontroller.
  3. Hierna heeft U 30 sec. om te zorgen dat de Hyperterminal het script verzent. Dit veroorzaakt U als volgt: Kies met de muis Verplaatsen, Tekstbestand verzenden, Vul de naam van de file op de PC in, of brows er na toe. En Klik op O.K.
    U zult de tekens uit de file ook afgedrukt zien worden, maar zonder dat er een nieuwe regel wordt genomen.

Zodra de microcontroller constateert dat er 1 sec lang geen karakter is ontvangen zal hij aannemen dat het transport klaar is en om het volgende commando vragen.

 

Wilt U een script van de microcontroller naar de PC transporteren, bijvoorbeeld om te controleren of hij goed is overgekomen, dan handelt U als volgt:

  1. U start de terminal-emulator, we nemen hier Hyperterminal van Windows als voorbeeld, en zorgt dat U commando’s kunt geven.
  2. U kiest met de muis Verplaatsen, Tekst doorsturen naar bestand. Vul de naam van de file op de PC in en klikt op Starten.
  3. Daarna geeft U aan de microcontroller commando g (Give to PC data of file: ) De microcontroller vraagt naar een file nummer, wat U beantwoort met het nummer van de file in de microcontroller. De microcontroller zal de file meteen beginnen te verzenden wat U op het PC scherm kunt volgen. Na afloop wordt er meteen naar het volgende commando gevraagd.
  4. U kiest met de muis Verplaatsen, Tekst doorsturen naar bestand. Stoppen.
  5. Hierna opent U de PC file met een tekstverwerker (b.v. Kladblok van Windows) de file en knipt de lijnen weg met de vragen naar een commando aan het begin en het einde van de file.

 

Het maken van een wat langer script op de PC vergt enig voorstellingsvermogen en gaat in de praktijk meestal niet in een keer goed. De commando’s stuk voor stuk geven leidt meestal wel tot een goed resultaat. Maar als je het werkstuk nog eens wilt maken, dan moet je alle commando’s weer bedenken. Daarom is er een mogelijkheid gemaakt om de microcontroller opdracht te geven om alle commando’s die je tikt niet alleen uit te voeren, maar ook te noteren in een file.

Het nummer van de file waarin de commando’s moeten worden genoteerd wordt aangegeven via commando W (Write commands to file: ) . Als U het noteren wilt beëindigen dan gebruikt U commando W weer en geeft een ongeldig file nr op (kleiner dan 0 of groter dan 9).

 

Met commando f (Execute commands in file: ) kunt U het achterelkaar uitvoeren van alle commando’s in een file starten.

Als U tijdens dit uitvoeren niet ingrijpt, dan wordt er op het PC scherm pas als alle commando’s uitgevoerd zijn naar een volgend handmatig commando gevraagd.

Als het nodig is, kunt U echter op twee manieren ingrijpen via knoppen onder de LCD.

De knop rechtsonder dient tijdens het uitvoeren van een script als ABORTknop. Bewegingen worden gestopt, en het uitvoeren van commando’s uit een file wordt afgebroken. Dit is bedoeld voor ‘Paniek situaties’ Ik kreeg het niet voor elkaar om de microcontroller te laten reageren op de uitroep: “Ho, ho, ho, STOP!”.

De knop linksonder dient tijdens het uitvoeren van een script ook als ABORTknop, met als extra eigenschap dat de stappenmotor ook stroomloos wordt. De tweede knop van links op de onderste rij dient als PAUZEknop. Voor de microcontroller aan een nieuwe commando begint, kijkt hij of deze knop ingedrukt is, en als dat zo is, dan toont hij een Menu op de LCD.  We moeten de knop dus ingedrukt houden tot dit Menu verschijnt want commando’s worden eerst afgemaakt. De onderste regel van de LCD labelt de knoppen er onder waardoor we de keuze hebben uit:

De uitvoering van het script wordt ook gestopt als er kennelijk een fout gemaakt is bij het intikken van het script. Een foutbericht meldt het karakter wat niet geïnterpreteerd kan worden.

Bij het tikken van scripts mogen we meerdere commando’s op 1 regel tikken en de commando’s scheiden met net zoveel spaties als we willen (0 spaties mag ook).

 

Wanneer het eerste karakter op een regel een # is wordt de hele regel als commentaar beschouwd en bij het uitvoeren door commando f  overgeslagen. Het is een goede gewoonte om als eerste regel van een script een commentaar regel op te nemen met de bedoeling van het script.

Commando V (View text file data) toont niet alleen de posities van de files in het geheugen, maar toont ook de eerste 30 karakters van een file. Als U dus een filenummer vergeten bent, kunt U het hiermee opzoeken.

 

Wanneer het eerste karakter op een regel een vraagteken is, dan wordt de rest op die regel beschouwd als een vraag die moet worden gesteld aan de operator. Commando f  toont deze tekst op de LCD, markeert op de onderste regel van het LCD twee knoppen met Yes en No, en wacht tot een van deze knoppen wordt ingedrukt. Als de No knop wordt ingedrukt wordt het uitvoeren van het script afgebroken, na het drukken van de Yes knop wordt het uitvoeren van het script voortgezet. Dit soort vragen zijn erg nuttig, aan het begin van het script, om de operator te laten controleren of de positie van de frees wel is zoals bedoeld bij het definiëren van het script.

Als er onderweg van frees of boor moet worden gewisseld, kan de volgende vraag worden ingevoegd: “?Staat er een boor van 1.2 mm klaar met de punt juist op het materiaal?”.

Voor de vraag wordt beantwoord kan de operator de juiste boor monteren en de Z as handmatig in de juiste positie brengen. Het volgende commando in het script zal dan meestal commando Q zijn waardoor het meetsysteem van de Z as weer gekalibreerd is ten opzichte van het werkstuk.

Een commando, dat alleen nuttig is in een script, is commando @ (Wait ms. : ). U kunt dit commando wel handmatig geven, maar het heeft geen nut behalve om de werking te testen. In het script kan het wel nodig zijn. Bijvoorbeeld: Als we een boor of frees naar beneden sturen, dan moet die boor zakken door de zwaartekracht (zie hoofdstuk 7). De tegendruk van het materiaal kan er voor zorgen dat de boor langzamer zakt dan de spindel toelaat. Als we precies tot een bepaalde diepte willen boren, dan moeten we nadat de spindel de gewenste positie heeft bereikt, het boren even de tijd geven met commando @.

                                                                                          

Een aantal commando’s, die je wel met de hand kunt geven, kunnen niet toegepast worden in een script. Dit zijn de commando’s E, F, G, K, L, g, en r. Er zijn hiervoor twee redenen:

·        Het is zinloos omdat bij de uitvoering van het script, de operator acties moet uitvoeren met de PC.

·        Het uitvoeren van het script zou verstoord kunnen worden door het uitvoeren van zo’n commando.

Zou U toch een van deze commando’s opnemen in een script dan resulteert dit bij uitvoering in een foutmelding.

 

Slotopmerking:

Voor het maken van een script heb ik een aantal speciale PC programma’s gemaakt en verwacht dat er nog veel meer zullen volgen. Bijvoorbeeld: Voor het frezen van een groot gat in materiaal met een bepaalde diepte maakte ik een programma waaraan ik moet opgeven:

·        De gewenste diameter van het gat.

·        De diameter van de gebruikte frees.

·        De dikte van het materiaal.

Het script dat geproduceerd wordt, definieert een heleboel rechte XY bewegingen waarmee de cirkel wordt benaderd met een nauwkeurigheid van 0.02 mm.

Een ander PC programma genereert scripts voor het maken van module 0.5 tandwielen.

Hiervoor hoef ik alleen op te geven:

·        De gewenste diameter van het asgat.

·        De diameter van de gebruikte frees.

·        De dikte van het materiaal.

·        Het gewenste aantal tanden.

Nog een ander PC programma vertaalt een file, die wordt gegenereerd door het print lay-out programma Eagle, met instructies voor het boren van een print door een professionele EXELON machine, naar een script waarmee mijn machientje het boren automatisch uitvoert.

 

10.1.6) Overige commando’s.

Commando L (Local control) is hierboven al terloops genoemd. Het activeert de bediening via de knoppen onder de LCD. Na het geven van commando L kan de PC losgekoppeld worden en

Gebracht worden naar een plaats waar hij geen gevaar loopt beschadigd te worden door rondvliegend metaalstof. Commando L zal zijn uitvoering beëindigen als hij merkt dat er weer een karakter is binnengekomen via de RS232 interface. Na het opstarten van de microcontroller wordt commando L automatisch gestart zodat de freesmachine na het aanzetten van de besturing direct kan worden bediend zonder dat er een PC aan te pas komt.

 

Commando d (Step Sub Menu) kan gebruikt worden om de X, Y, of Z as met de kleins mogelijke stapjes te laten bewegen (zie hoofdstuk 6.4). Ik heb er een apart menu van gemaakt omdat:

·        ik in het hoofdmenu geen 9 letters meer over had om deze functies te activeren,

·        deze functies weinig gebruikt worden

·        het hoofdmenu toch al druk is.

 

Commando v (Contact LCD Menu) is gemaakt om het positioneren van de nulpunten van de meetsystemen ten opzichte van het materiaal te vereenvoudigen. Voor ik dit commando had gemaakt gebruikte ik commando d (Step Sub Menu) om een as te laten stappen totdat de frees het materiaal juist raakte. Het Contact LCD Menu is ook op te roepen in Local control en de opties worden gekozen via de knoppen onder de LCD.

Per as hebben we 4 knoppen met de volgende functies:

Dit kan de microcontroller uitvoeren omdat de machineklem geïsoleerd is opgesteld en aan een input van de microcontroller is verbonden, terwijl de freesmachine met de 0 Volt is verbonden.

Wanneer we in plaats van een frees een meetpen met kleine bol van bekende diameter aan het eind monteren, dan kunnen de drie dimensionale contouren van een (metalen) onderdeel behoorlijk nauwkeurig bepaald worden. Dit is natuurlijk handig als je het onderdeel wilt namaken.

De stand van de assen worden op het LCD getoond zoals bij hand handbediening. Het meest linkse kwart van de LCD wordt gebruikt om de 4 knoppen daaronder te labelen.

De twee meest linkse knoppen (STOP) kunnen worden gebruikt om de uitvoering van commando v te beëindigen. De bovenste daarnaast (Fast) heeft alleen effect in combinatie met stapfunctie knoppen. Als alleen een stapfunctie knop wordt ingedrukt, dan wordt na iedere stap 200 ms gewacht. Als de Fast knop erbij wordt ingedrukt wordt dit wachten overgeslagen. Dat gaat dus sneller, maar stopt mogelijk minder nauwkeurig.

Wanneer de knop gemerkt met Rep. (report) wordt gedrukt wordt er een regel tekst via de RS232 interface verstuurd. In deze regel wordt de positie van X Y en Z gemeld zowel in 0.01 mm als de standen van de sensors. Als de terminal-emulator deze regels doorstuurt naar een file kan die file ingelezen worden in EXCEL (zoals bij het bepalen van de constanten bij de regeling). Als ik aan een onderdeel dat ik wil namaken ga meten, heb ik dus geen potlood nodig om de metingen te noteren.

 

Commando K (Kill and restart Micro) veroorzaakt dat de microcontroller hetzelfde doet als na het inschakelen van de spanning, maar het bovendien mogelijk maakt dat er nieuwe software in de microcontroller wordt geladen.

 

10.2) Bediening via de knoppen onder de LCD.

Als commando L actief wordt, kan de machine bediend worden via de knoppen onder de LCD.

De knoppen zijn verdeeld in 4 groepen 2 boven en twee onder. De groepen worden gebruikt voor de assen (van links naar rechts) Phi, X, Y, Z. De positie van de X, Y, en Z as worden precies boven hun knoppen weergegeven op het LCD. De ruimte boven de knoppen voor de Phi as wordt gebruikt voor labels.

In 0.01mm|x=     0 |y =     0 |z=      0

Was(last)|    -250 |       10 |       30

 
 

 

 


De bovenste lijn geeft de posities van de assen.

Tijdens een beweging toont de onderste lijn de Target (doel) posities. Bij stilstand toont deze lijn de vorige doel posities.

Wanneer U de spindels met de hand verdraait, zal de microcontroller de gegevens op het LCD ook veranderen zodat steeds de actuele toestand wordt weergegeven.

 

Stikkers op het front van de besturingskast dienen als geheugensteun om te onthouden welke knoppen gedrukt moeten worden voor welke functie. Hieronder volgt een volledige beschrijving.

 

10.2.1) Bediening van de X, Y, en Z as.

Het gebruik van de 4 knoppen voor een as is identiek voor de X Y en Z as, en bijna identiek voor de Phi as.

Als U de knop rechtsonder indrukt en weer loslaat zonder aan de draaiknop te draaien, dan gebeurt er dus niets. Dat geeft de mogelijkheid om nog meer functies te kiezen door andere knoppen erbij in te drukken.

 

10.2.2) Bediening van de Phi as.

De Phi as wordt bedient met de linker 4 knoppen. Omdat we hier te maken hebben met de  stappenmotor van de (draaibank) optie, wijkt de functie van de knoppen op enkele punten af van die voor de X, Y, en Z as.

Het instellen van de snelheid en het linksom en rechtsom sturen gaat net zoals bij de X, Y, en Z as.

Met de knop linksonder stellen we bij Phi niet de doelpositie in, maar wordt de functie van commando ‘)’ Phi motor Off  uitgevoerd. Zodra we de knop rechtsonder indrukken, waarbij we de snelheid kunnen instellen, wordt de motor weer aan gezet (commando ‘(‘ ). Als hij aan stond en we de snelheid willen instellen blijf hij gewoon aan.

Ook bij de Phi as kunnen we na het indrukken van de knop rechtsonder (snelheid instellen) extra knoppen indrukken voor het activeren van extra functies. Deze wijken af van die voor X Y, en Z, en wel als volgt:

 

10.2.3) Algemene bedieningsfuncties.

Hierboven noemden we extra knoppen die na het indrukken van de koppen voor het instellen van de snelheid erbij worden gedrukt. Hierboven beperkten we ons tot knoppen die behoorden bij dezelfde as. Maar dit is natuurlijk niet noodzakelijk. Voor de algemene bedieningsfuncties maken we gebruik van andere combinaties.

Uitleg van de ‘leer functie’ tijdens Local Control.

Wanneer we een plankje (of ander materiaal) van bijvoorbeeld 8 bij 8 centimeter aan de bovenkant netjes willen vlakfrezen met een frees van 6 mm, dan zetten we de frees eerst rechts boven juist naast het materiaal en geven met de knoppen achtereenvolgens de volgende verplaatsingen op:

En dan bedenken we: “Maar dit moeten we nog 80 / 3 = 27 keer herhalen. Had ik maar een script met deze commando’s. Maar ja, de PC gaan halen en een plekje schoonmaken voor hem kost ook tijd, dus laat ik maar doorgaan in handbediening”.

Met de ‘leer’functie van Local control is dit probleem opgelost. We handelen als volgt:

Hierna zullen de 3 bewegingen 27 keer worden uitgevoerd. Wij kunnen ondertussen koffie drinken.

 

De leer functie van Local control gebruikt alleen de commando’s A, B C en & voor het instellen van de sneheid. en de commando’s x, y, z en * voor het noteren van een verplaatsing. Het noteert dus geen posities, maar verplaatsingen.

Merk op dat als U op deze manier de machine iets geleerd hebt, het script met commando g naar een PC kunt transporteren voor opslag of verbetering.

 

12) Slot opmerkingen.

Het spreekwoord: “Bezint eer gij begint” is zeker van toepassing op dit project. Als ik de mechanica voldoende had gekend, en alle op te lossen problemen had voorzien, dan was ik er niet aan begonnen.

Terugdenkend geldt dit echter ook voor veel projecten op m’n werk. In ieder geval heb ik er veel van geleerd, waaronder:

“Kunnen doorzetten is net zo belangrijk als veel weten”.

Wanneer U vragen of opmerkingen hebt, stuur dan een mail naar henk@henkzelf.nl.

Een berichtje als U dit verhaal hebt gewaardeerd wordt ook op prijs gesteld.

 

Als U zich afvraagt wat mijn volgende project zal zijn kan ik melden:

Ik denk aan een machientje waarmee ik de kozijnen van de bovenverdieping en de dakrand kan schuren en verven als ik straks de ladder niet meer op durf. Ik heb alleen vage ideeën hoe het er uit zou moeten zien. Dat project kan ook wel eens 6 jaar gaan duren. In ieder geval heb ik met het freesmachientje er voldoende gereedschap voor.


Najaar 2006,

Henk van Broekhuyzen