snelheid ronddraaien steppermotor

Hallo,

Ik denk dat dat programmeer gedoe je in dit geval veel sneller klaar bent dan allerlei gekke pulsjes ect.

Even globaal over stappenmotoren. Je hebt 2 soorten, unipolaire en biplolaire. Er zijn hopen met informatie te vinden over deze motortjes op het web. Er staat er zelf een op deze site: https://www.circuitsonline.net/artikelen/view/47.

Als ik er eventjes van uit ga dat je een unipolaire motor kiest, dan zal je die moeten aansturen door ombeurten een van de 4 spoelen te bekrachtigen.

Stel die puls van jou gaat naar een 4017, en dan uitgang 5 aan de reset dan ben je er. Nu kan je kiezen om een puls deler te plaatsen tussen de puls die de omwentelingen meet en de 4017.

Toch zou ik zelf kiezen voor een arduino achtig iets en een mooie interface waar je de gegevens van de draad kan invullen en het aantal omwentelingen wat je wilt. Vervolgens rekent dat ding alles voor je uit en hoef je enkel nog maar op start te drukken.

Trouwnens, er zijn vast ook wel chippies die een clock en direction accepteren waar je meteen de motor aan kan knopen.

Op 29 juni 2016 17:49:21 schreef fred101:Maar ik heb geen ervaring met stappenmotors aansturen. Maken die per puls een vaste stap of bepaald de lengte van de puls en/of stroom de stapgrootte.

Dan wordt het hoog tijd dat je dat krijgt, niet?

Stappenmotoren maken per "puls", of beter gezegd, per wisseling van de bekrachtiging van de spoelen, een vaste stap, meestal 1.8 of 0.9 graden (200 of 400 stappen per omwenteling). Met een simpel trucje kun je dat aantal stappen verdubbelen, door steeds afwisselend 1 spoel, of 2 spoelen aan te zetten; in het laatste geval gaat de motor tussen de 2 stappen in staan.

Ik zou echt een Arduino of zo nemen; lekker gemakkelijk om mee te beginnen, en het grote voordeel is dat je daarmee geen integer deling hoeft te maken. Als het voor een bepaalde draaddikte beter uitkomt om 20.5 stappen te doen per winding, kun je er steeds afwisselend 20 en 21 doen, en dus gemiddeld goed uitkomen, zonder een cumulatieve fout.

Het programmeren van iets dergelijks is niet echt moeilijk, en best een leuk en uitdagend beginnersprojectje. Als je er nooit aan begint, ga je het nooit leren, en het is een trucje dat erg vaak handig is.

Unipolaire stepper:

[Bericht gewijzigd door Arco op woensdag 29 juni 2016 18:51:47 (11%)

Ik ben het opzich met Sparky en hardbass eens, een processortje is een veel makkelijkere oplossing op een stappenmoter een vast aantal stappen te laten doen per ingangspuls.

Maar er zijn andere oplossingen denkbaar. Naast dat je met TTL-logica de benodigde golfvormen kunt maken, kun je ook andere mechanische oplossingen bedenken.

Als je genoeg nokjes op je wikkelas hebt, of gewoon een draaiknop met quadratuur-encoding koopt (vandijken heeft (had?) ze voor een euro/stuk) dan kun je een stappenmotor rechtstreeks aansturen.

Als je een draaiknop via tandwielen van je wikkelas aandrijft kun je de verhouding ook kiezen. En ben je eigenlijk gewoon een draaibank aan het bouwen... Waarmee je ook moet kunnen wikkellen.

Het kan natuurlijk helemaal elektronica loos. Gewoon een in grootte verwisselbare pulley op de twee assen en een V snaartje.

Maar dit project is eigenlijk min of meer ideaal om met microcontrollers te beginnen. Veel meer dan een arduino en wat transistortjes heb je eigenlijk niet nodig. Daarnaast zijn er echt 1001 tutorials op internet hoe je een stappenmotor aanstuurt met een arduino. Daarnaast is het nooit verkeerd om kennis van programmeren op te doen.

een stappenmotor driver als de A4988 (of hoe dat ding ook heet), doet steeds precies 1 stapje per pulsje op de "step" input. Ze kosten minder dan 2 euro op ebay. Maar als je een gewone 200stappen per omwenteling stappenmotor hebt, kan je eigenlijk dus niet sneller heen en weer dan in 200 wikkelingen, mits je natuurlijk 1 pulsje per omwenteling hebt.

Of je moet zo'n motortje gebruiken.

Een stappenmotor (zie het artikel van Lambiek hierover) is perfect geschikt voor dit doel, het wordt ook in commerciële machines gebruikt.
Een fraai zelfbouw voorbeeld is hier: http://www.cnczone.com/forums/i-c-engines/2497-cnc-software-2.html#pos…

Het idee wat fred had om met "discrete" logica een stappenmotor te besturen kan wel, maar heeft zoals al door anderen gemeld nogal wat voetangels en klemmen, hier is er één: je zult iets moeten verzinnen om die benodigde pulsjes (heel vaak meer dan 1) min-of-meer verdeeld over een omwenteling van de wikkel-as te produceren. En dat dus bij een instelbaar aantal...
De door blurp genoemde encoder gaat niet heel lang leven: een populair ALPS type wordt gespect op slechts 100000 omwentelingen. Zuiver optische typen gaan vaak langer mee, maar zijn duurder en vaak nogal kwetsbaar.
Vandaar de programmeerderij...

Omdat een stappenmotor een vaste stapgrootte heeft laat zich verplaatsing heel goed met een schroefas realiseren. Met een M6 schroefstang ga je per omwenteling 1mm opzij, dus als je 0.33mm draad aan het wikkelen bent moet je 1/3 omwenteling op je stappenmotor maken wat neerkomt op zo'n 67 of 137 stappen.
Eind sensors zijn niet strikt noodzakelijk, je kunt gewoon tellen of je er bent en dan de andere kant op gaan. Alleen mag je dan geen stap missen, dus ze zijn wel handig...
Vroeger deden ze het iets anders: http://info.ee.surrey.ac.uk/Workshop/advice/coils/winders/

Ene Jones heeft daar wel een leuk verhaaltje over.

Het zou niet eens in me op komen om het 'discreet' te doen. Maar ja, het kan natuurlijk wel .
Zoek een bij jou motortje passend controller IC. Als je afziet van 'half step' en dat soort dingen, dan is het in basis vrij simpel: je hebt een DIRECTION pin en een STEP pin. Bij elke puls op de STEP wordt aan de hand van de DIRECTION een stap de ene of de andere kant uit gemaakt.
Als je te snel stept ('te snel' is afhankelijk van wat jouw motortje lust bij de stroom door z'n spoeltjes en z'n load), ga je stappen missen.

In een 'discrete' setup, zou het kunnen werken als je een pulsgever hebt die 'ruim voldoende' pulsen oplevert. Zet daar een aantal delers achter (evt. 1 configureerbare deler) en kies met een draaischakelaar op welke deler je vandaag draait. Aan het einde van je 'klos' aan beide kanten een schakelaar die je DIRECTION omzet. En wikkelen maar...

Ik zou het met een controller doen in combinatie met een DRV8825 (zoals in het artikel staat) of met de gene die rew aangeeft de A4988, die dingen kosten zowat niets en werken gewoon goed. Plus dat de stroom goed instelbaar is bij die dingen, wat eigenlijk een must is bij een goede stappenmotor driver.

Maar goed als je het met discrete elektronica wil doen kan dat ook natuurlijk, maar je bent niet zo flexibel als met een controller.

Het lastiger van discrete oplossingen is natuurlijk ook dat je alleen integer delingen kunt maken, en daarmee dus een cumulatieve afwijking krijgt. Met een microcontroller kun je ook een breuk gebruiken, waarbij je bijvoorbeeld elke 21 pulsen 15 stappen zet.

Het programmeren daarvan is ook heel eenvoudig: je houdt een accumulator bij waar je bij elke puls van de encoder 15 bij optelt, en zodra die groter dan of gelijk aan 21 is, trek je er 21 vanaf en zet je een stap met de stappenmotor. Op die manier wordt de afwijking bij het zetten van de ene stap afgetrokken van de volgende, waardoor je altijd zo dicht mogelijk bij de ideale positie blijft.

Iets dergelijks kan overigens ook vrij simpel zonder microcontroller, met een FPGA of CPLD; je zou kunnen stellen dat dat ook "discrete logica" is, toch?

Als je nog nooit iets met een CPLD/FPGA gedaan hebt, zou ik toch eerst beginnen met een microcontroller; dat is nog niet iets gemakkelijker aan te leren (vind ik dan), en die ervaring is wat beter universeel toepasbaar.

Ik denk dat ik mijn Arduino maar eens moet afstoffen. Ik heb nu geen tijd er een fancy project van te maken maar ik kan het ding voor nu gewoon opnieuw programmeren per wikkeling. Dat is minder werk dan een heel user interface te schrijven. Ipv de "krukas" kan ik dan de stepper aan een stuk draadeind zetten want de motor kan dan net zo makkelijk van richting veranderen.

Dat hoeft niet eens automatisch want aan het eind moet hij vaak toch even stoppen om er bv tape over te doen.

Sparky, ik heb wel vaker wat geprogrammeerd. oa een temperatuur/RH% meter, de frequentie/output power van een zelfbouw meetzender, een breedband AC+DC TRMS powermeter. Alleen is dat niet echt mijn sterkste punt.

edit: lees net je laatste post, bedankt, nu begrijp ik het, ziet er niet te complex uit.

Ik heb een draaibank maar die draait te snel en heeft geen schroefdraad versnellingsbak.

Een berg pullys draaien is meer werk dan programmeren.

Ik heb een steppermotor met 4 draden. Dat is dus bipolair. Als ik er spanning opzet draait hij een stapje en ik moet idd van spoel wisselen voor de tweede stap. Dan wordt een processor wel handiger. Ik heb hier een paar L6203 en TDA1003 liggen.

Is een TDA1003 voor aansturing van steppermotoren dan?

Als je er vier gebruikt zou het kunnen ja, je kan een stappenmotor ook met een sinusvormig signaal aansturen. Als je met microstepping werkt krijg je ook een digitale sinus.

Ik heb wel vaker gehoord dat ze het via een versterker doen, een grote klant van vroeger heeft het eens gedaan. Alleen het positioneren wordt wat moeilijker, dat wordt nog een soort uitdaging.

Ik heb even de datasheet opgesnord, en hoewel alles kan natuurlijk zou ik lekker 2 van die L6203's pakken (vooropgesteld dat die al in de grijpvoorraad liggen, want anders zou je waarschijnlijk zo'n kant-en-klaar stepperdrivertje kiezen van het soort dat rew aandraagt).

Voor kleine steppers gebruik ik altijd de LB1973 van Sanyo...

Even een update. De hardware was vrij snel klaar maar de software kant vroeg heel wat meer werk. Jochem was zo aardig een stukje test software te schrijven en te helpen met dingen uitzoeken mbt de aansturing van de motor. En daarnaast de hoognodige geestelijke ondersteuning

Het viel niet mee maar het is gelukt. Dankzij hem weet ik nu ook waarom mijn arduino projecten niet vooruit te branden waren en het belang van fuses bij het branden van de Atmel Mega328 mbv mijn TL866A prorammer.

Mijn Arduino is iets te vaak mishandeld dus ik schrijf de software in de IDE, gooi het eruit als een hex file naar de TL866A. Ik maak meestal een 6 pin ICP op het pcb.
Ik heb zelf ooit een Arduino achtig ding met LCD genmaakt. Maar die bleken dus iets van 24x te langzaam. Ik gebruik nu Atmels zonder bootloader.

Ik heb een instelmenu gemaakt waar ik best trots op ben, een 10 slag pot met tellerknop (net als de delay knop op analoge scoops) en een drukknop de instellingen doe.
Dankzij het map commando is de aanduiding op die knop gelijk aan de display.
Waarom, simpel, die heeft een blokkeer knopje (wat achteraf dank zij de firmware niet nodig bleek maar het stelt wel lekker snel in)

Er komt op de display de vermelding van de parameter, zoals layers, turn per layer, draaddikte, richting feed motor. De potmeter wordt gelezen door de ADC, de waarde gemapped tot 0-1000 of 0-100, dan druk ik op OK en gaat hij naar de volgende. Dat kost nauwelijks tijd. Ik vind het prettiger dan een rotary encoder

Er zit ook een pauze knop op die de boel stilzet zodat ik bv tape kan aanbrengen.

De omwentelingen worden door een IR lichtsluis geteld. Dat heeft me wel wat hoofdbrekens gekost toen het ding wel op snelheid werkte en ik de tab breder had gemaakt ivm extern licht, doorliep hij de loop een keer of twintig tijdens zo'n doorgang. Ik wilde geen wachtlussen toestand. Hij vergelijkt nu steeds een bit, die wordt bij t₀ van de onderbreking hoog en pas bij de wisseling daarop van hoog naar weer 0 en telt hij er 1 turn bij op.

De beide motors staan onder controle van de Atmel. De stepper 100% (richting, start/stop, stapgrote en snelheid), de windermotor alleen aan/uit. De snelheid en draairichting daarvan is analoog geregeld zodat ik
tijdens het wikkelen makkelijk de snelheid kan regelen.

De stepper wilde maar niet goed werken tot ik er achter kwam dat het niet werkt als je de motorspeed (rpm) niet eerst zet. Dat heeft me verruit de meeste tijd gekost.

Gisteren nog een mooiere "feed-kop" gemaakt met een messing buisje stukje teflonslang. Daar past weer een "liner" in in de vorm van zo'n rood spuitbus rietje (0,6mm) dus prima voor het meeste CU draad. Dat rietje kan ik uitschuiven zodat het zo dicht mogelijk bij de wikkelkamer kan komen.

De software is werkbaar maar ik zou er nog wat dingen bij willen die nu nog te ver gaan voor mijn programmeer kennis. In ieder geval kan ik zo de hardware testen

En nu natuurlijk proberen of het ook echt allemaal (handig) werkt. En zoja de electronica wat fatsoeneren (voornamelijk in een kastje bouwen ipv open een bloot op een stuk koelprofiel etc.
Misschien een trafo erbij zodat ik hem overal kan zetten (nu moet hij bij 2 labvoedingen in de buurt staan)

Ik ben blij dat ik voor digitaal ben gegaan want is wel heel gaaf geworden Maar zonder de hulp van Jochem was ik al lang gestopt. Analoog was het lang niet zo mooi en gebruiksvriendelijk geworden maar was ik waarschijnlijk al lang klaar geweest.

Ik heb ook Atmel studio 7 geinstalleerd. Dat echte C taaltje is flink wat ingewikkelder maar voor iemand die met een vinger typed en commando's, variabelen etc vergeet is het met die semi-auto aanvulling wel veel makkelijker werken. En zoiets als een variabele vergeten te resetten komt er in een debug sim hopelijk wel uit. Maar of ik daar ook echt uit kom weet ik niet. Dingen als DDRB.1 |=(1 <<5) zijn niet echt makkelijk (ik verzin maar even wat) als je gewend bent met digitalRead te werken. Het blijkt wel heel makkelijk te zijn zelf commandos/macros te maken met #define

Zo, dat was een heel verhaal Fred. Maar nu zijn we wel reuze benieuwd geworden naar het resultaat natuurlijk.

Bij deze vast de code. Net 2575 windingen van 0,11mm er op gelegd. 8 lagen van 302 per laag. Daarna nog een halve van 159. Het resultaat is superstrak. Ik ben in ieder geval erg blij met het resultaat.

Morgen zal ik wat foto's maken.
Er moeten nog een kleine aanpassing komen. Een mechanische om iets meer ruimte tussen spoel en langsvoeding te krijgen om zo dicht mogelijk tot de rand te wikkelen maar dat is zo gedaan. En gelijk de geleiderail wat verstevigen voor een nog strakker resultaat.

#include <LiquidCrystal.h>
#include <Stepper.h>

int pause = 0;                          // pin 2 atmel is pause, latching
int OKknop = 1;                         // pin 3 atmel, non latching pushbutton
int richtingKnop = 13;                  // pin 19 atmel, spdt switch,  open (high) and gnd(low)
int motor = A4;                         // pin 27 atmel, motor relais
int potmeter = A0;                      // pin 23 atmel, set potmeter 
int sluis = 12;                         // pin 18 atmel, 5V TTL. trigger is high output from sensor

const int stepsPerRevolution = 200;     // depending stepper motor

// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);

int stepCount = 0;                     // number of steps the motor has taken
int potDia;                            // wire diameter in micrometer
int turnCount = 0;                     // counts ir sensor triggers, 1 per turn
int StepsPerTurn;                      // steps of motor per turn
int richting = 1;                      // direction of steppermotor HIGH is forward,
int mux = 1;                           // 1 is FW, -1 BW multiplier          
int potLay;                            // number of set layers
int potTurn;                           // number of wire-turns
int layer = 1;                         // counter
int stepdistance = 625;                // 1 turn = 1250 um / 200 = 6,25 um/stap ivm float x100
int buttonState = 0;                   // current state of the button
int lastButtonState = 0;               // previous state of the button
int teller = 0;

void setup() 
{
  lcd.begin(16, 2);                       // set up the LCD's number of columns and rows:
  lcd.print("Welkom    ");                
  delay(500);
  lcd.clear();
  
  //-----------------------------------
  // declaring ports
  //------------------------------------
  pinMode(pause, INPUT_PULLUP);           // standard = HIGH, pause button
  pinMode(OKknop, INPUT_PULLUP);          // confirm button 
  pinMode(richtingKnop, INPUT_PULLUP);    // direction of stepper motor spdt switch
  pinMode(motor, OUTPUT);                 // relais winder motor
  pinMode(sluis, INPUT);                  // 1 positive puls per revolution
  
}

void loop() 
{
  int potVal;                             // the value of the potentiometer
  
  //----------------------------------------
  // set up number of turns per layer
  //----------------------------------------
  while (digitalRead(OKknop) == HIGH) 
    {
    lcd.setCursor(0,0);
    lcd.print("n per laag:    ");
    lcd.setCursor(12,0);
    potVal = analogRead(potmeter);
    potTurn = map(potVal, 0, 1023, 0, 1000);
    lcd.print(potTurn);
    lcd.setCursor(0,1);
    lcd.print("OK to set");
    delay(100); 
    }
   lcd.clear();  
   delay(500);
  

//-------------------------------------------------------
// set up number of layers 
//-------------------------------------------------------
  while (digitalRead(OKknop) == HIGH) 
  {
    lcd.setCursor(0,0);
    lcd.print("layers=:    ");
    lcd.setCursor(9,0);
    potVal = analogRead(potmeter);
    potLay = map(potVal, 0, 1023, 0, 100);
    lcd.print(potLay);
    lcd.setCursor(0,1);
    delay(100); 
  }
lcd.clear(); 
delay(500);


  //---------------------------------
  // set first layer direction
  //---------------------------------  
  while (digitalRead(OKknop) == HIGH) 
  {
    lcd.setCursor(0,0);
    lcd.print("direction feed");
    lcd.setCursor(0,1);
    lcd.print( "= ");  
    richting = digitalRead(richtingKnop);
     if (richting == LOW)
        {
         lcd.setCursor(2,1);
         lcd.print("naar voren ");
         mux = 1;
        }
      if (richting == HIGH) 
        {
         lcd.setCursor(2,1);
         lcd.print("naar achter ");
         mux = -1;
        }  
    delay(100);  
  }
  lcd.clear(); 
  delay(500);
    
  
  //------------------------------------------------
  // set up wire diameter to calculate steps/turn
  //------------------------------------------------
  while (digitalRead(OKknop) == HIGH) 
  {
    lcd.setCursor(0,0);
    lcd.print("WireDia - microm");
    lcd.setCursor(0,1);
    potVal = analogRead(potmeter);
    potDia  = map(potVal, 0, 1023, 0, 1000);
    lcd.print(potDia);
    lcd.setCursor(5,1);
    lcd.print("OK to set"); 
    StepsPerTurn = (potDia * 100) / stepdistance;
    turnCount = 0;
    stepCount = 0;
    delay(100); 
  }
  
  lcd.clear();
  delay(500);
  
  teller = 0;
  layer = 1;
  turnCount = 0;
  lcd.clear();
  
  //------------------------------------
  // winding motor control
  //------------------------------------
   myStepper.setSpeed(30);
   while (layer <= potLay )                   // proceed upto max number of layers
   {
    digitalWrite(motor, HIGH);                // relais winding motor
    StepsPerTurn = StepsPerTurn * mux;        // ivm direction , mux inverteert 
    
    while (turnCount <= potTurn)               // proceed until max number of turns per layer
      {   
        buttonState = digitalRead(sluis);
        if (buttonState != lastButtonState)    // compare the buttonState to its previous state
          {
            if (buttonState == HIGH)           // if the state has changed, increment the counter
              {
                turnCount++ ;                   // if the current state is HIGH then the button wend from off to on:
                myStepper.step(StepsPerTurn);
                lcd.setCursor(0,0);
                lcd.print("layer =  ");
                lcd.setCursor(12,0);
                lcd.print(layer);
                lcd.setCursor(0,1);
                lcd.print("turns =  ");
                lcd.setCursor(9,1);
                lcd.print(turnCount);
              } 
          }
        lastButtonState = buttonState;                    // save the current state as the last state  
      
    
        while (digitalRead(pause) == LOW)     // pause all
          {
            lcd.setCursor(0,0);
            digitalWrite(motor, LOW);
            lcd.print(".....WAIT......."); 
            delay(100);
            lcd.clear();
          } 
          
          digitalWrite(motor, HIGH);
      }
 
      delay(10);
      layer++;
      turnCount=0;
      lcd.clear();
      //mux = mux * -1;      //next layer the feed must run back to the start
}
       
   digitalWrite(motor, LOW);
 
}

Heb ik zelf-programmerende software geschreven ? Een soort AI.
Vandaag de 0,45mm laag erop en daar ontstonden 2 problemen. De stapgrote is te klein. Als ik hem op 1000 micrometer draaddiameter zet gaat het bijna goed. Ik heb nu een routine toegevoegd waarbij ik het rpm kan instellen. Misschien gaat hij te traag omdat hij ipv 0,11 mm nu 0,45 moet afleggen. Dat is 5x de afstand.

Maar nu het vreemde. De draairichting zet ik met een wisselwerking tussen schakelaar en het menu. Dat werkte prima maar bij 0,45 gaat hij net de andere kant op. De schakelaar werkt want ik kan hem zo weer corrigeren maar hoe dat kan ?

Zou er iets met het rekenwerk fout gaan. Dat er iets overloopt ofzo ? Long integer ipv integer ?

Welkom in de wondere wereld van onverklaarbare fouten in je code opsnorren. Debuggen noemen ze dat

Ik had het al per mail gezegd, maar ik vind het heel knap van je dat je bovenstaande zelf in elkaar hebt gezet en dat het in essentie doet wat je ermee wilt bereiken. Het is echter op een heel aantal punten 'beginnerscode' (geeft niet, al doende leert men) en dat maakt het op een bepaald moment ook veel lastiger om te zien waar iets mis gaat. Combineer dat met de belabberde debuggingmogelijkeden van een Arduino, en het feest is compleet
Groot voordeel bij foutzoeken in je code is wel dat je een display tot je beschikking hebt. Dat zou je bijvoorbeeld kunnen gebruiken om van een paar essentiële variabelen de waarde te printen. Dan kun je controleren of dat met je verwachtingen overeenkomt.

Een int gaat op een Arduino UNO/Duemilanove/.. (lees: ATmega328*) tot 32767. Ik heb niks nagerekend, maar je zou zelf eens kunnen redeneren of er iets uit de limieten zou kunnen gaan lopen.

Maar ik zal vanmiddag eens even een stukje "deftige software" voor je schrijven Fred. Gewoon de functionaliteit die je nu ook hebt, maar dan een beetje schoner. Dat kun je dan zien als een schone lei waar je zelf weer lekker op kunt voortborduren. Het is altijd goed om wat truukjes af te kijken. Het zijn veelal dingen die niet moeilijk zijn om te begrijpen, maar die je een keer gezien moet hebben zodat je ze zelf toe kunt passen. Leren programmeren bestaat zoals veel disciplines uit 1) goed afkijken bij iemand die het al kan, en 2) het veel zelf te oefenen daarbij vooral goed veel fouten te maken die je bij voorkeur uiteindelijk zelf weet op te lossen.

Op 11 juli 2016 12:13:55 schreef Jochem:

Een int gaat op een Arduino UNO/Duemilanove/.. (lees: ATmega328*) tot 32767.

En als dat te weinig is kan je "long" 32 bits, of "long long" 64 bits gebruiken. Wel gaat eea dan langzamer rekenen natuurlijk, maar voor iets wat je 1x uitrekenet naar aanleiding van user input kan dat natuurlijk nooit een probleem zijn. Maar in andere gevallen wel.

Op 9 juli 2016 22:21:16 schreef fred101:Morgen zal ik wat foto's maken.

Ben wel benieuwd !

Ik heb even zitten kijken..

Bij een draaddiameter groter dan 327µm zal hij overflowen denk ik. Die wordt namelijk *100 gedaan en dan zit je boven 32767 als resultaat. Leuk feitje: dan klapt hij om naar negatief en dan heb je meteen de verklaring voor de omgekeerde wikkelrichting.

Een long is niet gelijk nodig in dit geval; zo lang je draaddiameter de 655µm nog niet overschrijdt kun je volstaan met een unsigned int. Deze moet je wel even strategisch kiezen, omdat je later voor StepsPerTurn juist weer negatief wilt kunnen gaan, maar daar heb je gelukkig dat grote bereik niet meer nodig.

Ik denk als je potDia nou als unsigned int declareert, dan krijg je een 'int to unsigned int promotion' voor alle andere termen in de berekening StepsPerTurn = (potDia * 100) / stepdistance;, dus dan mag je tussenresultaat max 65535 zijn.

Samengevat voor Fred:

int potDia;            // wire diameter in micrometer

vervangen door

unsigned int potDia;   // wire diameter in micrometer

zou het probleem op moeten lossen tot aan 655µm draaddiameter.

Ik ga even verder per mail, want daar kreeg ik een stuk code waarin ik commentaar zag staan dat niet strookt met de theorie:

int potSpeed; //speed in RPM, voor 0,11mm is 30 voldoende, voor 0,5 veel sneller (150)

Het aantal RPM voor je stappenmotor zou bij een draaddiameter van 0,5mm niet meer dan 20RPM hoeven te zijn, uitgaande van een maximale snelheid van 50RPM van je spoellichaam (apart regelbare DC-motor, waarvan Fred de maximale snelheid eerder per mail aan mij had doorgegeven). Voor de mee-rekenaars: spoed van de spindel aan de as van de stappenmotor is 1,25mm.

Ik maak even een elementair stukje test-code Fred, je krijgt zo hebt inmiddels een uitgebreide email.

Mooi, dan had ik het goed dat het getal te groot werd. Vanmorgen nog even met long geprobeerd maar dat deed ik vast verkeerd want het veranderde niet.
0,65mm is meer dan genoeg, Ik heb wel eens dikker draad gebruikt maar dat waren ununs of luchtspoelen.

Ik heb net die unsigned aangepast maar nog niet kunnen testen. Er ligt nu een patient in onderdelen op de tafel. (gedeeltelijk, de andere helft staat in de garage, een zekering automaat van 50 kilo) Misschien vanavond nog, maar na een uur achter de microscoop in een pcb zitten graven op zoek naar mogelijke traces voor de verdampte via. Maar nu wil mijn rug even niet meer.

De handbedien routine werkt maar verdient geen schoonheidsprijs. Dit lijkt me eigenlijk iets voor een interupt.

Dat commentaar mbt die snelheid was een aantekening voor mijzelf omdat ik dacht dat hij daardoor te kleine stappen nam. Maar dat is dus de schuld van het omklap bitje. Met 0,11 mm klopt het perfect. 304 windingen x 0,11 mm en maakt 33,44 mm wat aardig overeenkomt met de gemeten 33,5mm.
Pas rond de 325 µm gaat het fout (even uit mijn hoofd)

Ik heb een ICSP connector met de layout van de arduino op het pcb gemaakt en een kabeltje voor de TL866A maar dat is geen succes. Ofwel, het doet niks anders dan wat meldingen maken over een of andere identiteit crisis. Wel jammer want nu zit de boel zo redelijk netjes met de connector goed bereikbaar maar omdat dat niet werkt moet ik steeds op de tast onder een rothoek zo'n 28 poter verwisselen.

Ik heb een filmpje gemaakt maar dat moet ik nog van mijn telefoon naar de computer zien te krijgen.