Machine à fabriquer des bobines

Machine à enrouler les bobines

C'est une machine simple pour faire des bobines. Elle a son propre compteur interne, qui compte les enroulements qui sont faits. Vous pouvez régler une quantité de bobinages à l'avance. La machine s'arrête automatiquement, quand

croquis--

// inclure la bibliothèque

#include

// cette constante ne changera pas

const int buttonPin = 13 ; // la broche à laquelle le bouton poussoir est attaché

//const int ledPin = 13 ; // la broche à laquelle la LED est attachée

// initialiser la bibliothèque en associant toute broche d'interface LCD nécessaire.

// avec le numéro de la broche de l'arduino à laquelle elle est connectée.

const int rs = 12, en = 11, d4 = 7, d5 = 6, d6 = 5, d7 = 4 ;

LiquidCrystal lcd(rs, en, d4, d5, d6, d7) ;

// Les variables vont changer

int buttonPushCounter = 0 ; // Compteur pour le nombre de pressions sur le bouton.

int buttonState = 0 ; // état actuel du bouton

int lastButtonState = 0 ; // état précédent du bouton

//pour le pilote du moteur et la régulation de la vitesse par le potard.

int SENSOR_PIN = A0 ; // broche centrale du potentiomètre

int RPWM_Output = 9 ; // broche 5 de la sortie PWM de l'Arduino ; à connecter à la broche 1 de l'IBT-2 (RPWM)

int LPWM_Output = 10 ; // Sortie Arduino PWM broche 6 ; connecter à IBT-2 broche 2 (LPWM)

// Utilisé pour générer des interruptions en utilisant le signal CLK

const int PinA = 2 ;

// Utilisé pour la lecture du signal DT

const int PinB = 3 ;

// Utilisé pour l'interrupteur à bouton poussoir.

const int PinSW = 8 ;

// Garde la trace de la dernière valeur rotative.

int lastCount = 0 ;

//save stat of virtualposition

int saveState =1 ;

// Mise à jour par l'ISR (Interrupt Service Routine)

volatile int virtualPosition = 0 ;

void isr () {

static unsigned long lastInterruptTime = 0 ;

unsigned long interruptTime = millis() ;

// Si les interruptions arrivent plus vite que 5ms, supposez que c'est un rebond et ignorez.

if (interruptTime - lastInterruptTime > 5) {

si (digitalRead(PinB) == LOW)


{


  virtualPosition-- ; // Peut être -5 ou -10


}


else {


  virtualPosition++ ; // Pourrait être +5 ou +10


}





// Restreindre la valeur pour que l'option des enroulements sélectionnés ne puisse pas descendre en dessous de 0.


position virtuelle = min(10000, max(0, position virtuelle)) ;

}

// Gardez la trace de la dernière fois où nous étions ici (pas plus que toutes les 5ms).

lastInterruptTime = interruptTime ;

}

void setup() {

// visualisation de la sortie sur le moniteur série

Serial.begin(115200) ;

// broches du moteur

pinMode(RPWM_Output, OUTPUT) ;

pinMode(LPWM_Sortie, SORTIE) ;

// initialiser la broche du bouton comme une entrée

pinMode(buttonPin, INPUT) ;

lcd.begin(20, 4) ;

// Imprime un message sur l'écran LCD.

lcd.setCursor(0, 0) ;

lcd.print(" --JOB Tech-- ") ;

lcd.setCursor(0, 1) ;

lcd.print(" Bobineur ") ;

// Les impulsions rotatives sont des entrées (INPUT)

pinMode(PinA, INPUT) ;

pinMode(PinB, INPUT) ;

// L'interrupteur est flottant, donc on utilise le PULLUP intégré pour ne pas avoir besoin de résistance.

pinMode(PinSW, INPUT_PULLUP) ;

// Attachez la routine pour servir les interruptions.

attacherInterrupt(digitalPinToInterrupt(PinA), isr, LOW) ;

}

void loop() {

int sensorValue = analogRead(SENSOR_PIN) ;

int Stop = (saveState) ;

étiquette :

si (saveState < buttonPushCounter+1)

{

analogWrite(LPWM_Output, 0) ;


analogWrite(RPWM_Output, 0) ;


lcd.setCursor(0, 1) ;


lcd.print ("READY !!! :-)") ;


lcd.setCursor(0, 2) ;


lcd.print ("----Please Reset----") ;

goto label ;

}

// la valeur du capteur est comprise entre 0 et 1023

// la moitié inférieure est utilisée pour la rotation inverse, la moitié supérieure pour la rotation avant.

if (sensorValue < 512)

{

// rotation inverse


int reversePWM = -(sensorValue - 511) / 2 ;


analogWrite(LPWM_Output, 0) ;


analogWrite(RPWM_Sortie, reversePWM) ;

float motorSpeedR = reversePWM * (200.0 / 511.0) ;

lcd.setCursor(0, 3) ;


lcd.print ("Motor Speed R ") ;


lcd.print (motorSpeedR) ;


lcd.setCursor(19, 3) ;


lcd.print ("%") ;

// Serial.println (" Speed Reverse ") ;

// Serial.print (motorSpeedR) ;

//Serial.print ("%") ;

}

else

{

// rotation avant


int forwardPWM = (sensorValue - 512) / 2 ;


analogWrite(LPWM_Output, forwardPWM) ;


analogWrite(RPWM_Sortie, 0) ;





float motorSpeedL = forwardPWM * (200.0 / 511.0) ;


 lcd.setCursor(0, 3) ;


 lcd.print ("Motor Speed F ") ;


 lcd.print (motorSpeedL) ;


 lcd.setCursor(19, 3) ;


 lcd.print ("%") ;

}

// lire la broche d'entrée du bouton-poussoir :

buttonState = digitalRead(buttonPin) ;

// compare l'état du bouton à son état précédent.

if (buttonState != lastButtonState) {

// si l'état a changé, incrémenter le compteur.


if (buttonState == HIGH) {


  // si l'état actuel est HIGH alors le bouton est é de off à on.


  buttonPushCounter++ ;





  //imprime les pressions de bouton comptées sur le LCD


  lcd.setCursor(0, 0) ;


  lcd.print("Windings Done ") ;


  lcd.print(buttonPushCounter) ;





}





// Retarder un peu pour éviter les rebonds.


delay(50) ;

}

// sauvegarde l'état actuel comme dernier état, pour le prochain age dans la boucle.

lastButtonState = buttonState ;

// Quelqu'un appuie sur le bouton rotatif ?

if ((!digitalRead(PinSW))) {

saveState = virtualPosition ;

while (!digitalRead(PinSW))


  delay(10) ;


  //imprime le nombre d'enroulements réglé sur l'écran LCD.


  lcd.setCursor(0, 2) ;


  lcd.print("Amount Set ") ;


  lcd.print(saveState) ;

}

// Si la position actuelle du commutateur rotatif a changé, mettez tout à jour.

if (virtualPosition != lastCount) {

//imprime le nombre d'enroulements sélectionnés sur l'écran LCD.


lcd.setCursor(0, 1) ;


lcd.print("Select Amount ") ;


lcd.print(virtualPosition) ;








// Gardez la trace de cette nouvelle valeur


lastCount = virtualPosition ;

}

}