EasyDirver und KY040 Hilfe

Hallo,
ich versuche mich mal wieder an einem Arduino Projekt.

#include <AccelStepper.h>

// Define the stepper and the pins it will use
AccelStepper stepper1(AccelStepper::DRIVER, 9, 8);

// Define our analog pot input pin
#define  SPEED_PIN 3

// Define our maximum and minimum speed in steps per second (scale pot to these)
#define  MAX_SPEED 10000
#define  MIN_SPEED 0.1

void setup() {
  // The only AccelStepper value we have to set here is the max speeed, which is higher than we'll ever go
  stepper1.setMaxSpeed(10000.0);

}

void loop() {
  static float current_speed = 0.0;         // Holds current motor speed in steps/second
  static int analog_read_counter = 1000;    // Counts down to 0 to fire analog read
  static char sign = 0;                     // Holds -1, 1 or 0 to turn the motor on/off and control direction
  static int analog_value = 0;              // Holds raw analog value.
 
  // If a switch is pushed down (low), set the sign 

  // We only want to read the pot every so often (because it takes a long time we don't
  // want to do it every time through the main loop).  
  if (analog_read_counter > 0) {
    analog_read_counter--;
  }
  else {
    analog_read_counter = 3000;
    // Now read the pot (from 0 to 1023)
    analog_value = analogRead(SPEED_PIN);
    // Give the stepper a chance to step if it needs to
    stepper1.runSpeed();
    //  And scale the pot's value from min to max speeds
    current_speed = sign * (((analog_value/1023.0) * (MAX_SPEED - MIN_SPEED)) + MIN_SPEED);
    // Update the stepper to run at this new speed
    stepper1.setSpeed(current_speed);
  }

  // This will run the stepper at a constant speed
  stepper1.runSpeed();
}

Es soll ein Poti das KY040 die Drezahl von einem Schrittmotor regulieren.
Wenn ich den Standart Code von Easy Driver Examples verwende dann löst sich das Poti wie ein Schalter bedienen.
Aber das soll er ja garnicht deswegen habe ich den Code wie oben abgewandelt aber es passiert nix wenn ich an ihm drehe.

Easydriver Anschlüsse sind:
Stepper Motor: Schwarz, Grün, Rot, Blau
Strom±: 7v
GND:GND
STP:9
DIR:8

Poti Anschlüsse sind:
GND: GND
+: 5V
SW: nix
DT: D3
CLK:D2

Jemand ne Idee ?
Der Code sollte ja eigentlich die Geschwindigkeit beim drehen des Potis erhöhen.

Mfg

Dann vertausche mal deinen Text mit dem Sketch.

gemacht danke nur das problem ist noch da :confused:

audiator:
gemacht danke nur das problem ist noch da :confused:

Klar, vorher war dein Sketch auch nicht zu lesen.

Der KY040 ist kein Poti, sondern ein inkremental Drehgeber.
Den kannst du nicht mit einem analogen Pin auslesen.
Da brauchst du einen entsprechenden Sketch, der die Impulse auswertet.

Das habe ich mir schon fast gedacht er arbeitet also wie Buttons nur halt in 2 richtungen statt druck.
Wie setzte ich das um finde leider keine anleitun die das hergibt wenn ich sag links rum oder rechts rum +50 pulse
:confused:

audiator:
Das habe ich mir schon fast gedacht er arbeitet also wie Buttons nur halt in 2 richtungen statt druck.
Wie setzte ich das um finde leider keine anleitun die das hergibt wenn ich sag links rum oder rechts rum +50 pulse
:confused:

Naje....wie Buttons ist wohl der falsche Ausdruck.

Aber wenn du keine Anleitung findest, hast du nicht gesucht.

In Google "drehencoder arduino" findest du massig Artikel, z.B. den hier. Oder "drehencoder" hier im Forum suchen und du brauchst viel Zeit zum Lesen.

Hi

Und wenn Das noch nicht reicht - der Drehencoder gibt einen 2-Bit-Gray-Code aus - falls Das geläufiger ist.

MfG

Danke euch da werde ich gleich mal nachschauen ich habe immer nur Taster oder Poti gesucht

Ok habe gesucht und auch was gefunden aber leider finde ich nur sachen über potis. :confused:
Wie sag ich den dem Arduino das links rum schneller und rechts langsamer ist.
Dazu habe ich das gefunden aber das ist mit Poti.

 Encoder RPM
 /*
  Gearmotor Rotary Encoder Test
  motor-encoder-rpm.ino
  Read pulses from motor encoder to calculate speed
  Control speed with potentiometer
  Displays results on Serial Monitor
  Use Cytron MD10C PWM motor controller
  DroneBot Workshop 2019
  https://dronebotworkshop.com
*/

// Motor encoder output pulse per rotation (change as required)
#define ENC_COUNT_REV 374

// Encoder output to Arduino Interrupt pin
#define ENC_IN 3 

// MD10C PWM connected to pin 10
#define PWM 10 
// MD10C DIR connected to pin 12
#define DIR 12 

// Analog pin for potentiometer
int speedcontrol = 0;

// Pulse count from encoder
volatile long encoderValue = 0;

// One-second interval for measurements
int interval = 1000;

// Counters for milliseconds during interval
long previousMillis = 0;
long currentMillis = 0;

// Variable for RPM measuerment
int rpm = 0;

// Variable for PWM motor speed output
int motorPwm = 0;

void setup()
{
  // Setup Serial Monitor
  Serial.begin(9600); 
  
  // Set encoder as input with internal pullup  
  pinMode(ENC_IN, INPUT_PULLUP); 

  // Set PWM and DIR connections as outputs
  pinMode(PWM, OUTPUT);
  pinMode(DIR, OUTPUT);
  
  // Attach interrupt 
  attachInterrupt(digitalPinToInterrupt(ENC_IN), updateEncoder, RISING);
  
  // Setup initial values for timer
  previousMillis = millis();
}

void loop()
{
  
    // Control motor with potentiometer
    motorPwm = map(analogRead(speedcontrol), 0, 1023, 0, 255);
    
    // Write PWM to controller
    analogWrite(PWM, motorPwm);
  
  // Update RPM value every second
  currentMillis = millis();
  if (currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;


    // Calculate RPM
    rpm = (float)(encoderValue * 60 / ENC_COUNT_REV);

    // Only update display when there is a reading
    if (motorPwm > 0 || rpm > 0) {
      Serial.print("PWM VALUE: ");
      Serial.print(motorPwm);
      Serial.print('\t');
      Serial.print(" PULSES: ");
      Serial.print(encoderValue);
      Serial.print('\t');
      Serial.print(" SPEED: ");
      Serial.print(rpm);
      Serial.println(" RPM");
    }
    
    encoderValue = 0;
  }
}

void updateEncoder()
{
  // Increment value for each pulse from encoder
  encoderValue++;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
  
 /*
  Gearmotor Rotary Encoder Test
  motor-encoder-rpm.ino
  Read pulses from motor encoder to calculate speed
  Control speed with potentiometer
  Displays results on Serial Monitor
  Use Cytron MD10C PWM motor controller
  DroneBot Workshop 2019
  https://dronebotworkshop.com
*/
 
// Motor encoder output pulse per rotation (change as required)
#define ENC_COUNT_REV 374
 
// Encoder output to Arduino Interrupt pin
#define ENC_IN 3 
 
// MD10C PWM connected to pin 10
#define PWM 10 
// MD10C DIR connected to pin 12
#define DIR 12 
 
// Analog pin for potentiometer
int speedcontrol = 0;
 
// Pulse count from encoder
volatile long encoderValue = 0;
 
// One-second interval for measurements
int interval = 1000;
 
// Counters for milliseconds during interval
long previousMillis = 0;
long currentMillis = 0;
 
// Variable for RPM measuerment
int rpm = 0;
 
// Variable for PWM motor speed output
int motorPwm = 0;
 
void setup()
{
  // Setup Serial Monitor
  Serial.begin(9600); 
  
  // Set encoder as input with internal pullup  
  pinMode(ENC_IN, INPUT_PULLUP); 
 
  // Set PWM and DIR connections as outputs
  pinMode(PWM, OUTPUT);
  pinMode(DIR, OUTPUT);
  
  // Attach interrupt 
  attachInterrupt(digitalPinToInterrupt(ENC_IN), updateEncoder, RISING);
  
  // Setup initial values for timer
  previousMillis = millis();
}
 
void loop()
{
  
    // Control motor with potentiometer
    motorPwm = map(analogRead(speedcontrol), 0, 1023, 0, 255);
    
    // Write PWM to controller
    analogWrite(PWM, motorPwm);
  
  // Update RPM value every second
  currentMillis = millis();
  if (currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;
 
 
    // Calculate RPM
    rpm = (float)(encoderValue * 60 / ENC_COUNT_REV);
 
    // Only update display when there is a reading
    if (motorPwm > 0 || rpm > 0) {
      Serial.print("PWM VALUE: ");
      Serial.print(motorPwm);
      Serial.print('\t');
      Serial.print(" PULSES: ");
      Serial.print(encoderValue);
      Serial.print('\t');
      Serial.print(" SPEED: ");
      Serial.print(rpm);
      Serial.println(" RPM");
    }
    
    encoderValue = 0;
  }
}
 
void updateEncoder()
{
  // Increment value for each pulse from encoder
  encoderValue++;
}

Hi

Rotary-Encoder-Test klingt nun echt nicht nach einem Poti.

Allerdings wird hier entweder nur eine Spur ausgelesen, oder der Encoder liefert die Drehrichtung nicht.
Wo Da ein Poti ist: für die Geschwindigkeit des Motor.

#############################

Der Sensor schimpft Sich Dreh-Encoder oder auch Quadratur-Encoder.
Unterm Strich hast Du zwei Datenspuren, Die ein um 90° versetztes Signal ausgeben.
Somit hast Du bei kontinuierlicher Drehung immer nur einen Wechsel zur gleichen Zeit:
A B
0 0
0 1
1 1
1 0
0 0
...
Wenn Du anders herum drehst:
A B
0 0
1 0
1 1
0 1
0 0
1 0
...
Die Kunst ist nun, schnell genug nachzusehen, ob sich was an den Signalen geändert hat.
Und wenn ja, in welche 'Richtung' Das geschehen ist.
0 0 -> 0 1 Rechts herum
0 1 -> 0 0 Links herum
Da wir hier 2 Bit Sensor-Daten haben, ergeben sich 4 Fälle.
Von allen dieser vier Fälle können wir (theoretisch) auf alle vier Fälle wieder kommen.
Dabei ist einer der Fälle identisch (Welle steht), Einer links, Einer rechts davon und der Letzte auf der gegenüberliegenden Seite - hier waren wir zu lahm und haben mindestens einen Schritt verpasst.
Vier Mal Vier gibt 16, wir können also alle Fälle in einem Array ablegen, Welches 16 Werte speichert.

[0]  B0000 steht, mache Nichts
[1]  B0001 rechts
[2]  B0010 links
[3]  B0011 Doppelschritt - ungültig
[4]  B0100 links
[5]  B0101 steht
[6]  B0110 Doppelschritt - ungültig
[7]  B0111 rechts
[8]  B1000 rechts
[9]  B1001 Doppelschritt - ungültig
[10] B1010 steht
[11] B1011 links
[12] B1100 Doppelschritt - ungültig
[13] B1101 links
[14] B1110 rechts
[15] B1111 steht

Um an den Index zu kommen, schiebst Du das alte Signal an die Bits 2 und 3, das Aktuelle kommt auf die Bits 0 und 1.
So machen Das viele der Encoder-Libs.

MfG

Habe da was gefunden das geht denke ich in die richtung

const int PinDT=4;    // DATA signal
const int PinCLK=2;    // CLOCK signal

// Variables to debounce Rotary Encoder
long TimeOfLastDebounce = 0;
int DelayofDebounce = 0.01;

// Store previous Pins state
int PreviousCLK;   
int PreviousDATA;

#define CLK_PIN   2
#define DATA_PIN  3

void setup() {
  // Put current pins state in variables
  PreviousCLK=digitalRead(PinCLK);
  PreviousDATA=digitalRead(PinDT);
}

 if ((millis() - TimeOfLastDebounce) > DelayofDebounce) {
    
    check_rotary();  // Rotary Encoder check routine below
    
    PreviousCLK=digitalRead(PinCLK);
    PreviousDATA=digitalRead(PinDT);
    
    TimeOfLastDebounce=millis();  // Set variable to current millis() timer
  }
  void check_rotary() {

 if ((PreviousCLK == 0) && (PreviousDATA == 1)) {
    if ((digitalRead(PinCLK) == 1) && (digitalRead(PinDT) == 0)) {

    }
    if ((digitalRead(PinCLK) == 1) && (digitalRead(PinDT) == 1)) {

    }
  }

if ((PreviousCLK == 1) && (PreviousDATA == 0)) {
    if ((digitalRead(PinCLK) == 0) && (digitalRead(PinDT) == 1)) {

    }
    if ((digitalRead(PinCLK) == 0) && (digitalRead(PinDT) == 0)) {

    }
  }

if ((PreviousCLK == 1) && (PreviousDATA == 1)) {
    if ((digitalRead(PinCLK) == 0) && (digitalRead(PinDT) == 1)) {

    }
    if ((digitalRead(PinCLK) == 0) && (digitalRead(PinDT) == 0)) {

    }
  }  

if ((PreviousCLK == 0) && (PreviousDATA == 0)) {
    if ((digitalRead(PinCLK) == 1) && (digitalRead(PinDT) == 0)) {

    }
    if ((digitalRead(PinCLK) == 1) && (digitalRead(PinDT) == 1)) {

    }
  }            
 }

Wie sag ich ihm das er schneller und langsamer werden soll. Ich denke das ist nicht üblich und wird deswegen auch nicht so praktiziert weil alle Potis dafür nehmen. Ich finde nämlich keine beispiele.

Doch...doch, dass wird schon damit gehen.

Du musst nur die jeweiligen Impulse zählen, die du erzeugst, wenn du rechts herum drehst und dann entsprechend die Motordrehzahl z.B. erhöhst und links herum die Drehzahl verkleinerst.

Habe da was gefunden das geht denke ich in die richtung

der Sketch - so wie von dir gepostet - kompiliert nicht, da er unvollständig ist.
Poste einen Link, wo du den her hast.

Warum nimmst du nicht eine Anleitung die von Arduino kommt und dann einen Sketch der mit einer mitgelieferten Library wahrscheinlich auch funktionieren wird?

https://playground.arduino.cc/Main/RotaryEncoders/

und dann gleich die erste Library "Encoder". Ob gut oder schlecht sei dahingestellt, aber es funktioniert.

Super werde die Tage mich da mal rein lesen leider die woche keine Zeit so wirklich