MECCANICA e DINTORNI

Intanto saluto tutti.

Ho giocherellato con chat GPT e guidata opportunamente l'IA (ho fatto solo pochissimi aggiustamenti) mi dato questo.

Nel codice che ti ho fornito, la velocità del motore passo-passo viene regolata in base alla velocità di rotazione dello spindle. Questo significa che se la velocità di rotazione dello spindle cambia durante una passata (ad esempio aumenta o diminuisce), la velocità del motore passo-passo verrà regolata di conseguenza per adattarsi alla nuova velocità di rotazione dello spindle. Di conseguenza, il motore passo-passo potrebbe accelerare o decelerare durante una passata per adattarsi alle variazioni della velocità di rotazione dello spindle.
Inoltre, il codice esegue più passate per completare la filettatura. Durante ogni passata, il motore passo-passo si muove avanti e indietro per creare la filettatura. Dopo ogni passata, il codice attende che l’utente prema il pulsante di reset prima di iniziare la passata successiva. In questo modo, l’utente può sincronizzare manualmente l’inizio di ogni passata con la posizione dello spindle.

#include <AccelStepper.h>

// Definisci i pin per il driver stepper
#define dirPin 4
#define stepPin 5
#define enablePin 6

// Definisci i pin per l'encoder
#define encoderAPin 2
#define encoderBPin 3

// Definisci i pin per i pulsanti
#define startButtonPin 7
#define resetButtonPin 8

// Crea un'istanza di AccelStepper
AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin);

// Variabili per tenere traccia della posizione dell'encoder
volatile long encoderPosition = 0;
long lastEncoderPosition = 0;
float ENCODER_COUNTS_PER_REVOLUTION = 360;

// Variabili per calcolare la velocità di rotazione dello spindle
unsigned long lastTime = 0;
float spindleSpeed = 0;
// Variabili per la filettatura
float threadPitch = 1.0; // Passo della filettatura in mm (da 0.5 a 2.0 con incrementi di 0.5)
float leadScrewPitch = 5.0; // Passo della vite associata allo stepper in mm
int stepsPerRevolution = 800; // Numero di passi del motore passo-passo per una rivoluzione completa
float threadLength = 20.0; // Lunghezza della filettatura in mm
int numPasses = 4; // Numero di passate

// Costanti per la regolazione della velocità del motore passo-passo in base alla velocità di rotazione dello spindle
#define MIN_SPINDLE_SPEED 200
#define MAX_SPINDLE_SPEED 500
#define MIN_STEPPER_SPEED 100
#define MAX_STEPPER_SPEED 1000

// Funzione di interrupt per il pin A dell'encoder
void encoderA() {
// Leggi lo stato dei pin A e B dell'encoder
int a = digitalRead(encoderAPin);
int b = digitalRead(encoderBPin);

// Aggiorna la posizione dell'encoder in base allo stato dei pin
if (a == b) {
encoderPosition++;
} else {
encoderPosition--;
}
}

// Funzione di interrupt per il pin B dell'encoder
void encoderB() {
// Leggi lo stato dei pin A e B dell'encoder
int a = digitalRead(encoderAPin);
int b = digitalRead(encoderBPin);

// Aggiorna la posizione dell'encoder in base allo stato dei pin
if (a == b) {
encoderPosition--;
} else {
encoderPosition++;
}
}

void setup() {
// Imposta i pin del driver come OUTPUT
pinMode(dirPin, OUTPUT);
pinMode(stepPin, OUTPUT);
pinMode(enablePin, OUTPUT);

// Imposta i pin dell'encoder come INPUT
pinMode(encoderAPin, INPUT);
pinMode(encoderBPin, INPUT);

// Imposta i pin dei pulsanti come INPUT
pinMode(startButtonPin, INPUT);
pinMode(resetButtonPin, INPUT);

// Abilita gli interrupt sui pin dell'encoder
attachInterrupt(digitalPinToInterrupt(encoderAPin), encoderA, CHANGE);
attachInterrupt(digitalPinToInterrupt(encoderBPin), encoderB, CHANGE);

// Imposta la velocità massima e l'accelerazione del motore passo-passo
stepper.setMaxSpeed(1000);
stepper.setAcceleration(1000);

// Abilita il driver del motore passo-passo
digitalWrite(enablePin, LOW);

// Memorizza il tempo corrente
lastTime = micros();
}

void loop() {
// Calcola il tempo trascorso dall'ultima lettura della posizione dell'encoder
unsigned long currentTime = micros();
unsigned long deltaTime = currentTime - lastTime;
lastTime = currentTime;

// Calcola la variazione della posizione dell'encoder
long deltaPosition = encoderPosition - lastEncoderPosition;
lastEncoderPosition = encoderPosition;

// Calcola la velocità di rotazione dello spindle in giri al minuto (RPM)
float spindleSpeed = (deltaPosition / (float) ENCODER_COUNTS_PER_REVOLUTION) / (deltaTime / 60000000.0);

// Regola la velocità del motore passo-passo in base alla velocità di rotazione dello spindle
stepper.setMaxSpeed(map(spindleSpeed, MIN_SPINDLE_SPEED, MAX_SPINDLE_SPEED, MIN_STEPPER_SPEED, MAX_STEPPER_SPEED));

// Leggi lo stato dei pulsanti
int startButtonState = digitalRead(startButtonPin);
int resetButtonState = digitalRead(resetButtonPin);

// Se il pulsante di partenza/ripartenza è premuto
if (startButtonState == HIGH) {
// Esegui il codice per la filettatura
for (int pass = 0; pass < numPasses; pass++) {
// Calcola il numero di passi del motore passo-passo necessari per fare una filettatura di lunghezza threadLength con il passo impostato da threadPitch e leadScrewPitch
int stepsToMove = (threadLength / threadPitch) * (leadScrewPitch / threadPitch) * stepsPerRevolution;

// Muovi il motore passo-passo alla posizione desiderata
stepper.moveTo(stepsToMove);
while (stepper.distanceToGo() != 0) {
stepper.run();
}

// Attendi che lo spindle completi un giro completo
long initialEncoderPosition = encoderPosition;
while (abs(encoderPosition - initialEncoderPosition) < ENCODER_COUNTS_PER_REVOLUTION) {
// Non fare nulla, attendi che lo spindle completi un giro completo
}

// Attendi che il pulsante di reset venga premuto
while (digitalRead(resetButtonPin) == LOW) {
// Non fare nulla, attendi che il pulsante di reset venga premuto
// Attendi che il pulsante di partenza/ripartenza venga premuto
while (digitalRead(startButtonPin) == LOW) {
// Non fare nulla, attendi che il pulsante di partenza/ripartenza venga premuto
}
}
}
}

// Se il pulsante di reset è premuto
if (resetButtonState == HIGH) {
// Muovi il motore passo-passo alla posizione di partenza
stepper.moveTo(0);
while (stepper.distanceToGo() != 0) {
stepper.run();
}
}
}

-------------------------------------
I valori di MIN_SPINDLE_SPEED, MAX_SPINDLE_SPEED, MIN_STEPPER_SPEED e MAX_STEPPER_SPEED dipendono dalle specifiche del tuo motore passo-passo e dello spindle. Questi valori vengono utilizzati per mappare la velocità di rotazione dello spindle (in giri al minuto) alla velocità del motore passo-passo (in passi al secondo).

MIN_SPINDLE_SPEED e MAX_SPINDLE_SPEED rappresentano il range di velocità di rotazione dello spindle che vuoi utilizzare per la filettatura. Ad esempio, se vuoi che lo spindle ruoti ad una velocità compresa tra 500 e 2000 giri al minuto durante la filettatura, puoi impostare MIN_SPINDLE_SPEED a 500 e MAX_SPINDLE_SPEED a 2000.

MIN_STEPPER_SPEED e MAX_STEPPER_SPEED rappresentano il range di velocità del motore passo-passo che vuoi utilizzare per la filettatura. Questi valori dipendono dalle specifiche del tuo motore passo-passo e dal driver che stai utilizzando. Ad esempio, se il tuo motore passo-passo può muoversi ad una velocità compresa tra 100 e 1000 passi al secondo, puoi impostare MIN_STEPPER_SPEED a 100 e MAX_STEPPER_SPEED a 1000.

ENCODER_COUNTS_PER_REVOLUTION è una costante che rappresenta il numero di impulsi generati dall’encoder per ogni giro completo dello spindle. Questo valore dipende dalle specifiche dell’encoder che stai utilizzando. Ad esempio, se il tuo encoder genera 1000 impulsi per ogni giro completo dello spindle, puoi impostare ENCODER_COUNTS_PER_REVOLUTION a 1000.

Questa costante viene utilizzata per calcolare la velocità di rotazione dello spindle in giri al minuto (RPM) . Il codice calcola la variazione della posizione dell’encoder (in impulsi) e la divide per ENCODER_COUNTS_PER_REVOLUTION per ottenere il numero di giri completi dello spindle. Questo valore viene quindi diviso per il tempo trascorso (in minuti) per ottenere la velocità di rotazione dello spindle in giri al minuto (RPM).

---------------------------------------------
Spero possa interessare

Ennio64, per prima cosa, prima di postare, avresti dovuto leggere il regolamento e passare in presentazioni. Ti invito a farlo velocemente.

Passiamo al codice: fa piacere vedere che dopo che è stata bloccata la gente si stia interessando all'IA e nascano i programmatori della domenica come i funghi. Personalmente sono molto affascinato da chatGPT e non concordo con il blocco, ma come tutte le cose va fatta con cognizione di causa. Il codice scritto dall' IA è concettualmente corretto ma scritto in modo estremamente scolastico e non tiene conto di tutta una serie di problematiche che si presentano con un algoritmo di questo tipo, per prima cosa la gestione dell'interrupt e la velocità con cui questo viene eseguito. Non mi dilungo ulteriormente perché, come scritto nel primo messaggio, questo thread serve a supportare chi vuole implementare il MIO codice e non a commentare il codice scritto da altri, ivi compresa una IA. Detto ciò, il mio consiglio è di prendere un arduino e provare a programmarlo con questo codice, poi se lo riterrai utile puoi sempre aprire un nuovo thread e commentare il tutto, ma mi raccomando, prima leggi il regolamento e passa in presentazioni!

caricata versione aggiornata 1.82 con bug del menù impostazioni sistemato.

Innanzitutto mi scuso per non essermi presentato prima.

Non mi ritengo un programmatore, e non è sicuramente la mia ambizione.
Il mio era solo un post (che posso anche rimuovere non è un problema) esclusivamente per evidenziare una delle tante possibilità di utilizzo di Chat GPT o IA che dir si voglia.
Ritengo sia un valido strumento, per chi come me al massimo butta giù due righe di codice, ma anche per esperti in quanto, pur con i suoi limiti, può fornire spunti interessanti.
Termino complimentandomi con McMax per l'ottimo lavoro che hai realizzato.

Un saluto a tutti

@Ennio

non rimuovere niente, al massimo chiedi ai moderatori di spostare il tuo messaggio in una discussione dal titolo appropriato, come Max ti ha suggerito. Il problema non è il post in sè, ma che la discussione in cui l'hai inserito sia dedicata espressamente ad altro (codice di Max e relative esperienze/problemi/richieste di aiuto).

Buon lavoro!!

Ennio, forse ieri sera sono stato un po' brusco e mi scuso per questo. Personalmente gioco già con ChatGPT da diverso tempo e, come scritto sopra, ne sono affascinato. Lo ritengo uno strumento sicuramente utile anche se la versione attualmente free (ovvero la 3.5) ha delle grosse limitazioni. Il problema vero di un codice come questo, al di la della parte matematica della routine, è più che altro nella gestione dei parametri e dell'interfaccia uomo-macchina (HMI). Se ti vai a leggere il mio codice scoprirai che è proprio l'HMI che occupa la stragrande maggioranza dello spazio e delle risorse, così ad occhio direi che siamo sull'80/85%. Nel codice scritto dall'IA la parte di HMI non è contemplata per niente. Oltre a ciò, produrre un algoritmo che funziona a volte non è sufficiente: dipende dalle condizioni in cui questo funziona e solo un accurato test sul campo può aiutarti a correggere gli errori ed adattarlo al meglio.

Se vuoi imparare a scrivere il codice il mio consiglio è quello di studiare e imparare a scriverlo da te. Poi, quando sarai in grado di farlo, l'IA ti offrirà un aiuto notevole visto che ti aiuterà a scrivere alcune parti del codice sostituendo un lavoro che, uno volta che lo saprai fare, diventerà monotono e ripetitivo.
Pensare che l'IA possa fare tutto il lavoro e prendere per oro colato quello che produce è, tra l'altro, uno dei motivi per cui il garante ha deciso di bloccarla...

Le macchine non sostituiranno mai la mente umana... sono solo in grado di andare velocissime nei calcoli e le decisioni che vengono prese sono solo il frutto di cio' che trovano nei database .
Piccolo esempio OT :
Sto lavorando ad un progetto con un SW che crea una modellazione solida di un terreno partendo da una nuvola di punti , funziona ! una cosa incredibile solo 10 anni fa ...peccato che non è in grado di decidere se, cosa e come modellare ,quindi alla fine deve essere corretto a mano da un utente senziente ( o quasi ... cioè io )

Ci sto smanettando per ora girando l èncoder a manina
Non capisco alcune cose
Quando l èls e`accesa lo stepper e`sempre abilitato?
Non ho la Norton, la mia vite in pollici fa 1,588 mm giro 1.5875 in verita`
Ho una riduzione 3 a 1 tra vite e stepper, ho messo il driver a 200 passi e detto all els che ho 600 step giro
nella norton per l àvanzamento libero dovrei mettere 158, mi porto dentro un errore ma, a parte questo mi sembra che il risultato di avanzamento sia molto piu`dell`errore


edit : girando a scatti l encoder a mano mi e´capitato che lo stepper per inseguire andasse oltre la max vel impostata ed e`andato in stallo

Si lelef lo stepper é sempre abilitato, purtroppo. Avevo provato a disabilitarlo ma il metodo non é uguale per tutti i driver quindi ho deciso di tenerlo abilitato per evitare problemi.

Per correggere l'errore sull'avanzamento avevo previsto una funzione di taratura ma ancora non l'ho terminata.

In modalità filettatura lo stepper insegue sempre l'encoder, a prescindere dalla massima velocità impostata per il motore.
La massima velocità viene considerata solo in avanzamento e in movimento libero. Questo perché le due modalità di pilotaggio dello stepper sono diverse: in avanzamento e movimento libero lo stepper viene pilotato in PWM con on time fisso e frequenza variabile mentre in filettatura vengono generati i singoli step quando richiesti. La tracciatura della velocità in filettatura richiede risorse che su arduino purtroppo non ci sono. Si potrebbe fare ma a quel punto bisognerebbe ridurre ulteriormente la velocità in filettatura che sarebbe comunque parecchio sotto al limite quindi non ha molto senso, anche considerando che una volta che il sistema andrebbe a limitare la velocità mentre filetta il sincronismo sarebbe comunque perso e il filetto in questione da buttare.

Grazie, ho capito quasi tutto,
il duvvio che mi rimane prche`non ho fatto prov in tal senso, se ho troppi giri ad inizio filettatura il sistema prima legge i giri calcola e mi avverte o parte comunque e quindi sta me calcolare prima?

se hai troppi giri ad inizio filettatura si pianta perché appena prende il sincronismo parte a cannone cercando di inseguire il mandrino. Quando filetti non devi andare a tuono, un po' come quando filetti con le ruote, non puoi andare troppo forte. Tu hai la sfiga di avere una vite con passo molto corto quindi per muoversi lo stepper deve fare tanti passi rispetto ad una vite con passo più lungo. Io con 400 passi stepper e vite da 8TPI (3,175mm) per un filetto normale con passo 1-2 mm filetto tranquillamente a 250/300 rpm, tu mi sa che devi andare un po' più piano.

potenzialmente si , da vedere come proseguo con le modifiche, cambiare un vite su un nanetto e`lavoro da poco e risolverebbe anche il passo strano

@lelef e @McMax

Per quanto riguarda lo “stepper sempre abilitato” io avevo modificato lo sketch 1.81 in modo da gestire l’Enable del driver per abilitare lo stepper solo quando deve eseguire dei movimenti ( avevo corretto anche il bug del menu sistemato da McMax nella 1.82 . Ho anche inserito delle costanti per modificare i livelli di Enable e Disable per adattarli ai driver, da modificare prima della compilazione.

ho fatto prima il debug con l’analizzatore logico e poi controllando l'assorbimento durante il funzionamento e sembra funzionare correttamente.

se interessa a qualcuno lo giro volentieri.

Ciao Max,
credo ci siano dei refusi in ImpostaPassoXXXX

a fine void fai questo


Ma è già presente a livello di menu filettatura




La variabile thread_pitch_mm non credo serva più.

probabile che siano rimate delle righe di codice inutili. Elimina pure!