YT eerste versie
YT tweede versie
[Bericht gewijzigd door harry64 op (25%)]
hardbass
PE2BAS
Wilde je dit zomaar delen of wil je feedback?
De eerste tip die ik je wil geven: Zo min mogelijk commentaar!
Ja je hoort het goed, het gaat tegen alle docenten in, maar zo MIN mogelijk commentaar.
Heel simpel voorbeeld:
void loop() {
int L = 1; // laagwindingen teller.
int WL = 1; // lagen teller.
Dit zou ik aanpassen naar:
void loop() {
int gewenstAantalLagen= 1;
int actueelAantalLagen= 1;
Waarom?
Je code is geeft nu aan wat er gebeurt. Ook verderop in de code weet ik niet meer wat WL was. Maar wel wat actueelAantalLagen betekent. Daarnaast kan door verloop van tijd je commentaar niet meer kloppen met de code.
Met andere woorden, de code klopt altijd met wat er gebeurt. Commentaar niet. Zorg ervoor dat de code te lezen is voor mensen. De processor doet toch wel wat er staat.
Dit is een persoonlijke voorkeur, maar ik zou er voor kiezen om in het Engels te werken.
Er is meer feedback die ik je zou willen geven, maar ik wacht eerst even af of je daar wel op zit te wachten 
Knap gemaakt !!
Is mijn eerste gedachtenkronkel na het bekijken van de twee filmfragmenten.
Ook het 'danser mechanisme' om de trekkracht op de draad te meten is leuk gevonden.
Als ik mag toch twee gedachtenkronkels
- 1) vermoedelijk gebeurt het oprollen nu op basis van het maximaal beschikbaar koppel van je aandrijfmotor.
Is het een meerwaarde als je het oprollen laat gebeuren op basis van een instelbaar koppel ?
Met andere woorden je trekt aan de draad met een gelijke kracht waarvan het maximum instelbaar is.
Dit heeft waarschijnlijk voordelen indien je een lange platte transformator kern moet wikkelen
- 2) als je een eerste "laag" gewikkeld hebt, wil je over die eerste laag een tweede laag wikkelingen leggen. Als je geen transformatorkern hebt die bewikkeld wordt, merk je dat de draad de neiging heeft verder te wikkelen in plaats van naar de reeds gewikkelde laag te gaan.
Een hol buisje dat de draad geleidt en dicht tegen de gewikkelde spoel aandraait kan dit oplossen, zonder dat dit een beperking inhoudt voor de grootte van de te wikkelen spoelen.
benleentje
Golden Member
int gewenstAantalLagen= 1;
int actueelAantalLagen= 1;
IK zou dan zelf als variatie nemen
actueleLagen en gewensteLagen omdat het toch wel duidelijk is het om aantallen gaat.
Maar voorkom van dit soort korte variabelen die als het programma groter word dan toch voor twijfel zorgen.
[Bericht gewijzigd door benleentje op (22%)]
hardbass
PE2BAS
Voor functies:
Hoe specifieker (kleinere scope) hoe langer de naam.
Hoe globaler (grote scope) korte naam.
Voorbeelden grote scope: strlen, memcpy, msToFreq
Kleine scope: StepMotorAndVerifyEncoder
Voor variabelen is dit precies andersom:
In een kleine scope is 'i' best prima om iterator aan te geven.
Maar voor een grote scope is 'i' heel vaag. Dan heb je liever: MaximaalAantalWindingenPerLaag.
---
Ik heb het wel met je eens, actueleLagen en gewensteLagen is nog mooier.
Als je ziet waarmee het begonnen is (https://www.circuitsonline.net/forum/view/169521), dan is dit toch wel een hele verbetering. Dit is ook voor een buitenstaander redelijk makkelijk te volgen. Dus heel goed.
benleentje
Golden Member
Op dinsdag 29 juli 2025 17:51:03 schreef deKees:
dan is dit toch wel een hele verbetering.
Maar wat hardbass zegt daar leer ik ook weer van en de namen van functies moeten ook duidelijk zijn heb ik daarvan geleerd.
Op dinsdag 29 juli 2025 12:12:30 schreef hardbass:
De eerste tip die ik je wil geven: Zo min mogelijk commentaar!
Ja je hoort het goed, het gaat tegen alle docenten in, maar zo MIN mogelijk commentaar.
Hier ben ik het niet zo mee eens. Als ik zelf niet ook veel commentaar in software zet weet ik na een jaar niet meer wat ik bedacht heb. Als ik 5000 regels code heb wil ik daar toch graag flinke blokken commentaar tussen hebben, anders kan ik later nooit meer even snel een aanpassing maken.
Arco
Special Member
Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Redelijk wat commentaar erbij is aan te raden (in Engels, da's makkelijk voor posten op buitenlandse forums)
Wel zinvol commentaar. Ik erger me altijd vreselijk aan:
- onnodig commentaar. bijv i = i + 1 en dan erachter zetten 'one added to i' ... 
- commentaar niet aanpassen als de code wijzigt. Vaak blijft het oude commentaar dan staan en slaat nergens meer op...
benleentje
Golden Member
Ja je hoort het goed, het gaat tegen alle docenten in, maar zo MIN mogelijk commentaar.
Zinloze commentaar zoals de nu de led aanzetten, nu de ventilator uitzetten sla ik ook over. Ben wel met je eens als je variabele en functie omschrijven duidelijk zijn is er niet zo veel commentaar nodig is.
Het liefst zet ik commentaar voor een functie of regel, maar commentaar achter een regel doe ik maar zelden.
Waar ik later achter kwam met mijn arduino projecten is een beschrijven van de gebruikte modules, de kleuren draad en hun functie en op welke pin.
Iedereen bedankt voor de adviezen. Ik ga weer even aan de gang met de adviezen.
Op dinsdag 29 juli 2025 15:54:23 schreef pamwikkeling:
Knap gemaakt !!
Is mijn eerste gedachtenkronkel na het bekijken van de twee filmfragmenten.
Ook het 'danser mechanisme' om de trekkracht op de draad te meten is leuk gevonden.Als ik mag toch twee gedachtenkronkels
- 1) vermoedelijk gebeurt het oprollen nu op basis van het maximaal beschikbaar koppel van je aandrijfmotor.
Is het een meerwaarde als je het oprollen laat gebeuren op basis van een instelbaar koppel ?
Met andere woorden je trekt aan de draad met een gelijke kracht waarvan het maximum instelbaar is.
Dit heeft waarschijnlijk voordelen indien je een lange platte transformator kern moet wikkelen
Lijkt mij fantastisch. Ik heb alleen geen flauw idee hoe de trekkracht van de stepper te sturen zonder stappen te verliezen.
Het huidige instrumentje met de Hall sensoren is min of meer beperkt tot (veel) "te hoog" en eventueel een "te laag". Het werkt wel goed om obstructie te detecteren zonder dat de draad breekt omdat de steppers dan onmiddellijk stoppen. Ook draadbreuk of i.i.g. (veel) te lage trekspanning kan nog wel gedetecteerd worden.
- 2) als je een eerste "laag" gewikkeld hebt, wil je over die eerste laag een tweede laag wikkelingen leggen. Als je geen transformatorkern hebt die bewikkeld wordt, merk je dat de draad de neiging heeft verder te wikkelen in plaats van naar de reeds gewikkelde laag te gaan.
Een hol buisje dat de draad geleidt en dicht tegen de gewikkelde spoel aandraait kan dit oplossen, zonder dat dit een beperking inhoudt voor de grootte van de te wikkelen spoelen.
Dat over dat buisje/tuitje is een goede opmerking. Ik ga eens nadenken over hoe ik dat vorm kan geven.
Op dinsdag 29 juli 2025 17:51:03 schreef deKees:
Als je ziet waarmee het begonnen is (https://www.circuitsonline.net/forum/view/169521), dan is dit toch wel een hele verbetering. Dit is ook voor een buitenstaander redelijk makkelijk te volgen. Dus heel goed.
Ik heb nu recentelijk de Arduino IDE 2.3.6 geïnstalleerd en begrijp nu wat je bedoelde met o.a. die rommelige indent.. 
Voor nu moet ik ook nog even e.e.a. uitzoeken rond de int's, float's e.d. want daar gaat e.e.a. niet goed omdat een aantal getallen waarschijnlijk te groot worden.
benleentje
Golden Member
Lijkt mij fantastisch. Ik heb alleen geen flauw idee hoe de trekkracht van de stepper te sturen zonder stappen te verliezen.
In principe is het koppel instelbaar via de stroom. Maar je gaat zonder encoder op de stepper nooit weten of je een stap verliest, maar dat weet je nu eigenlijk ook niet toch? Ik neem aan dat je erop gokt dat stepper meer dan sterk genoeg is.
Arco
Special Member
Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Om de 'slack' op te vangen zetten ze er vaak een extra tussenwiel met veer tussen om onregelmatigheden op te vangen en de draad altijd gespannen te houden.
Waarom stopt 'ie bij iedere omwenteling even? (dat schokken kun je met een meer soepele doorgaande loop voorkomen)
hardbass
PE2BAS
Hier een klein voorbeeldje van wat ik bedoel. Let wel op, dit zal niet werken, er mist een hoop. Het gaat puur om het demonstreren dat je code zo kan schrijven dat commentaar overbodig wordt. Je ziet dat overal waar eerst een comment stond, het nu duidelijk wordt gemaakt door een extra functie of een extra variabele toe te voegen.
@deKees, helemaal mee eens, dit is echt al veel beter dan waar het in dat topic initieel over ging. Chapeau voor TS om al zo ver te komen. Laat duidelijk zijn dat deze post niet bedoeld is om kritiek te leveren of te zeggen dat het beter moet. Het is puur bedoeld om te laten zien hoe je door goede naamgeving en kleine functies je code een stuk begrijpelijker kunt maken.
// This seems overkill, but it makes the code more readable
bool IsEven(int value) {
return (value % 2) == 0;
}
// Also for direction, instead of a boolean or int, this is undoubely clear whats going on.
enum Direction
{
DIRECTION_FORWARD,
DIRECTION_BACKWARD
};
// By keeping functions very small, its always very easy to see whats going on.
// Even for something as simple as this, an extra function can make it more readable later on.
Direction GetDirectionForLayer(int layer)
{
// Here you can see the benefit of the IsEven, its more clear than "if ((value % 2) == 0)...."
if (IsEven(layer)) {
return DIRECTION_FORWARD;
} else {
return DIRECTION_BACKWARD;
}
}
int GetNumberOfTurnsForLayer(int layer)
{
// Here I use an extra variable, just for making clear what this expression is supposed to be.
// If you place the expression directly in the if statement, it obfuscates it a bit.
bool isLastLayer = (layer == totalLayerCount - 1);
bool isLastTurn = remainingTurns <= 0;
if (!isLastLayer)
return turnsPerLayer;
if (isLastTurn)
return turnsPerLayer;
return remainingTurns;
}
// Because of the enum, its very clear whats going on. I dont have to remember things like: was 1 forward or backward?
void SetWindingDirection(Direction direction)
{
if (direction == DIRECTION_FORWARD) {
digitalWrite(wireDirectionPin, HIGH);
} else {
digitalWrite(wireDirectionPin, LOW);
}
}
void ProcessTurn(int layer, int turnIndex)
{
// By using these functions, i can simply read what it does.
// No need for comments to tell me.
ExecuteWindingStepCycle();
UpdateWireLengthEstimate();
CheckWireTensionOrPause();
DisplayTurnProgress(layer, turnIndex);
}
void ProcessLayer(int layer)
{
// Now that we have all the 'simple' functions, we can just read what is happening here.
// The function names should only be interpetable in a single way.
Direction direction = GetDirectionForLayer(layer);
SetWindingDirection(direction);
// The variable name can be short, since the function is small its still obvious what this varable does.
int numberOfTurns = GetNumberOfTurnsForLayer(layer);
// The scope is so small, even the name 'turnIndex' could become something like 'turn' or even 'i'
for (int turnIndex = 0; turnIndex < numberOfTurns; turnIndex++) {
ProcessTurn(layer, turnIndex);
}
}
// This helps to keep the main clean.
void ProcessAllLayers()
{
for (int layerIndex = 0; layerIndex < totalLayerCount; layerIndex++) {
ProcessLayer(layerIndex);
}
}
// Again, i can see by the names of the functions what happens
void loop()
{
WaitForStartButton();
GetUserInput();
CalculateParameters();
EnableMotors();
MoveWireGuardToStartPosition();
ProcessAllLayers();
DisableMotors();
}
buckfast_beekeeper
Van Lambiek wordt goede geuze gemaakt.
@TS: je include eeprom.h maar je lijkt het (nog) nergens te gebruiken. Hoe vaak denk je naar eeprom te schrijven? Is dat slechts een paarkeer, geen probleem. Is dat zeer vaak, is FRAM misschien een betere keuze.
Je schrijft ook dat je problemen hebt met bepaalde variabelen. Vele van je variabelen zullen nooit een negatieve waarde aannemen of het is alleszins de bedoeling dat ze dat niet doen. Declareer ze dan als unsigned. Bijvoorbeeld int8_t geeft een waarde tussen -127 en +127 weer. Het achtste bit wordt gebruikt voor positief of negatief. uint8_t loopt van 0 tot 255. Persoonlijk prefereer ik ook de grootte van de variabele aan te geven. uint8_t, int16_t, uint32_t, .....
hardbass
PE2BAS
Op woensdag 30 juli 2025 10:33:20 schreef buckfast_beekeeper:
@TS: je include eeprom.h maar je lijkt het (nog) nergens te gebruiken. Hoe vaak denk je naar eeprom te schrijven? Is dat slechts een paarkeer, geen probleem. Is dat zeer vaak, is FRAM misschien een betere keuze.Je schrijft ook dat je problemen hebt met bepaalde variabelen. Vele van je variabelen zullen nooit een negatieve waarde aannemen of het is alleszins de bedoeling dat ze dat niet doen. Declareer ze dan als unsigned. Bijvoorbeeld int8_t geeft een waarde tussen -127 en +127 weer. Het achtste bit wordt gebruikt voor positief of negatief. uint8_t loopt van 0 tot 255. Persoonlijk prefereer ik ook de grootte van de variabele aan te geven. uint8_t, int16_t, uint32_t, .....
Daar sluit ik me helemaal bij aan. Het probleem met de types zoals int is dat dit afhankelijk is van het platform. Als je code kopieert naar een ander systeem kan een int ineens nog maar 2 bytes zijn bijvoorbeeld. Dan gaan er dingen stuk. Met int32_t is het altijd hetzelfde.
Op woensdag 30 juli 2025 10:33:20 schreef buckfast_beekeeper:
@TS: je include eeprom.h maar je lijkt het (nog) nergens te gebruiken. Hoe vaak denk je naar eeprom te schrijven? Is dat slechts een paarkeer, geen probleem. Is dat zeer vaak, is FRAM misschien een betere keuze.Je schrijft ook dat je problemen hebt met bepaalde variabelen. Vele van je variabelen zullen nooit een negatieve waarde aannemen of het is alleszins de bedoeling dat ze dat niet doen. Declareer ze dan als unsigned. Bijvoorbeeld int8_t geeft een waarde tussen -127 en +127 weer. Het achtste bit wordt gebruikt voor positief of negatief. uint8_t loopt van 0 tot 255. Persoonlijk prefereer ik ook de grootte van de variabele aan te geven. uint8_t, int16_t, uint32_t, .....
Dat is goede info over de variabelen, dank daarvoor. Het bleek dat i.i.g. het omrekenen van wikkellichaam millimeters een -float- naar micrometers, de waarde numeriek te groot werd voor de float die de micrometers kreeg toegewezen met mm x 1000. Deze is omgezet naar long en werkt nu wel.
In de eerste versie werd de analoge waarde van een hallsensor 'eenmalig' naar de eeprom geschreven. Deze waarde diende als eindstop en referentie van de draadgeleider en werd opgehaald bij opstarten of een hardware reset van de processor. Echter bleek dat de waarde van de hallsensor te onstabiel is. Deze varieerde tussen 250 en 400 over de dag(en). Ik ga een eindstopschakelaar gebruiken. eeprom.h en aanverwanten gaat er dus uit.
Op dinsdag 29 juli 2025 19:54:15 schreef Arco:
Om de 'slack' op te vangen zetten ze er vaak een extra tussenwiel met veer tussen om onregelmatigheden op te vangen en de draad altijd gespannen te houden.
Waarom stopt 'ie bij iedere omwenteling even? (dat schokken kun je met een meer soepele doorgaande loop voorkomen)
Dat kwam omdat in de eerste versie eerst de ene an dan de andere stepper te sturen waardoor ze op elkaar moesten wachten.
Dat is inmiddels opgelost door beide de pulsen voor de draadgeleidermotor te verdelen over het totale aantal steps van de windingmotor en deze in 1 steppingproces gelijktijdig te genereren.
// regelt het aansturen van de stappenmotoren.
void stepping() {
// Initialisatie van de teller voor het aantal
// stappen van de draadverplaatsings motor.
int deelfactor = 0; // verdeelt de draadpulsen gelijkmatig over draadsteps.
int d = 0; // bruto draadsteps draadteller;
// De steps teller voor 1 360 graden rotatie
// van de windingmotor.
for (int s = 1; s < Steps + 1; s++) {
deelfactor = s % (Steps / draadsteps);
if (windingmotor == true) {
windingpuls();
}
// Als de trekkracht op de draad te hoog wordt dan
// noodstop om dat probleem op te losen.
if (draadtensiesensor > 60) {
Serial.print("STOP! Draad tensie te hoog: ");
Serial.println(draadtensiesensor);
while (okknop == HIGH);
}
// Sturing voor het wikkelen.
// Als teller d kleiner is dan het aantal
// draadsteps en deelfactor is nul, tel er 1 bij op
// en geef de draadmotor 1 stap tijdens het wikkelen.
if (d < draadsteps && deelfactor == 0 && windingmotor == true) {
d++;
if (d >= draadsteps) {
d = 0;
}
draadpuls();
}
// Snelle verplaatsing van de draadgeleider
// naar begin van de wikkelpositie.
if (d < draadsteps && windingmotor == false) {
d++;
if (d >= draadsteps) {
d = 0;
s= Steps;
}
draadpuls();
}
// Vertraging om de frequentie van de stepperpulsen
// te regelen.
delayMicroseconds(microsec);
// Meet hoeveel draad er is gebruikt.
draadmeter();
}
}
Vovpvi
De jacht is mooier dan de vangst....
Is het de bedoeling dat er 2 keer "while (okknop == HIGH);" in de loop staat?
Zou ik niet doen, werkt verwarrend.
Op dinsdag 29 juli 2025 12:12:30 schreef hardbass:
Wilde je dit zomaar delen of wil je feedback?De eerste tip die ik je wil geven: Zo min mogelijk commentaar!
Ja je hoort het goed, het gaat tegen alle docenten in, maar zo MIN mogelijk commentaar.Heel simpel voorbeeld:
void loop() { int L = 1; // laagwindingen teller. int WL = 1; // lagen teller.Dit zou ik aanpassen naar:
void loop() { int gewenstAantalLagen= 1; int actueelAantalLagen= 1;Waarom?
Je code is geeft nu aan wat er gebeurt. Ook verderop in de code weet ik niet meer wat WL was. Maar wel wat actueelAantalLagen betekent. Daarnaast kan door verloop van tijd je commentaar niet meer kloppen met de code.
Met andere woorden, de code klopt altijd met wat er gebeurt. Commentaar niet. Zorg ervoor dat de code te lezen is voor mensen. De processor doet toch wel wat er staat.Dit is een persoonlijke voorkeur, maar ik zou er voor kiezen om in het Engels te werken.
Er is meer feedback die ik je zou willen geven, maar ik wacht eerst even af of je daar wel op zit te wachten
Bij deze aangepast en dat is een stuk duidelijker i.d.d.
Feedback is altijd goed.
// Geeft realtime weer welke wikkelingen en lagen gedaan zijn.
void printwikkeldata(int windingteller, int laagwindingteller, int lagenteller) {
Serial.print("Uitgevoerd:");
Serial.print(windingteller);
Serial.print(" windigen van:");
Serial.print(totaalwindingen);
Serial.print(" waarvan:");
Serial.print(laagwindingteller);
Serial.print(" laagwindingen van:");
if ((laagwindingen * wikkellagen) >= windingteller) {
Serial.print(laagwindingen);
}
else {
Serial.print(restantwikkelingen);
}
Serial.print(" op laag:");
Serial.print(lagenteller);
Serial.print(" van:");
if (restantwikkelingen != 0) {
Serial.print(wikkellagen+1);
}
else {
Serial.print(wikkellagen);
}
Serial.print(". Draadgeleider richting:");
if (lagenteller % 2 == 0) {
Serial.print(" <-");
} else {
Serial.print(" ->");
}
Serial.print(". Meters draad:");
Serial.print(meterdraad);
Serial.print(". Draadtensie: ");
Serial.println(draadtensiesensor);
}
En:
void wikkelen () {
int laagwindingteller = 1;
int lagenteller = 1;
Serial.print("Uitvoeren?");
while (okknop == HIGH);
digitalWrite(enablestepper, HIGH);
Serial.println(" Oké");
// Telt totaalwindingen
for (int windingteller = 0; windingteller < totaalwindingen; windingteller++) {
// winding per laag teller.
if (laagwindingteller > laagwindingen) {
laagwindingteller = 1;
lagenteller++;
}
// Bepalen of het een even of oneven laag is voor
// de besturing van de richting.
if (lagenteller % 2 == 0) {
digitalWrite(draadrichting, HIGH);
} else {
digitalWrite(draadrichting, LOW);
}
stepping();
printwikkeldata(windingteller + 1, laagwindingteller, lagenteller);
laagwindingteller++;
}
// Klaar, uitschakelen steppers
digitalWrite(enablestepper, LOW);
Serial.println("Klaar.");
delay(100);
}
hardbass
PE2BAS
Leuk dat je deze hebt verwerkt in je code.
Eerst moest ik uitzoeken wat de code deed om te achterhalen wat deze variabelen betekenen. Dit is nu veel duidelijker.
buckfast_beekeeper
Van Lambiek wordt goede geuze gemaakt.
Om de code nog leesbaarder te maken, begin elk nieuw woord in je variabele met een hoofdletter. Bijvoorbeeld:
laagWindingTeller ipv laagwindingteller. Constanten schrijf ik meestal in hoofdletters en een underscore tussen de woorden. Bijvoorbeeld
const uint16_t STEPS_REVOLUTION = 6400;Ook dat is een goede qua structuur. Voorheen maakte ik er afkortingen van dus: lwt of LWT voor laagwindingteller. Maar ik merkte al dat ik met de huidige code soms namen van variabelen, constanten en functies door elkaar ging gebruiken, wat dus foutmeldingen of verkeerde uitvoer van code tot gevolg heeft.
Ondertussen de while okknop ook ondergebracht in een functie.
// Wacht op bevestiging input door gebruiker
// en ontdendering middels delay van 100 mS.
void jaknop() {
Serial.println("Oké?");
while (okknop == HIGH);
delay(100);
}
[Bericht gewijzigd door harry64 op (31%)]
benleentje
Golden Member
Wel grappig dat je het de ene keer een jaknop en de andere keer een okknop noemt.
Maar dat soort dingen doe ik ook soms nog. Maar toch heb ik gemerkt dat je daar eigen heel erg consistent in moet zijn omdat het bij een langere programma tot verwarring gaat leiden.
Video van de test met de oude wikkeldraad van bavelt's lijntrafo. Met de 'nieuwe' software. I.i.g. de nieuwe aansturing van de steppers.
https://www.youtube.com/shorts/-9UYCjJdv1Q