PWM Startwert mit Poti ändern

Hallo zusammen,

Ich falle gleich mal mit der Türe ins Haus. Ich habe eine Aufgabe, die ich nicht gelöst bekomme^^ Wirklich bewandert im Programmieren bin ich leider auch nicht. Zur Zeit lese ich ein Poti aus, um einen PWM-Pin zu steuern. Dieses wird später durch einen linearisierten Hall-Geber ersetzt. Mit einem zweiten Poti möchte ich den Startwert der PWM ändern, ohne den "Regelweg" zu minimieren. Ich hatte mir gedacht, dass ich ein mapping anlege (0, 1023, 0, 255) und die zweite null manipiliere. Genau das bekomme ich jedoch nicht hin. Sofern es denn überhaupt geht.

Sinn der Sache ist, damit einen Motor zu steuern. Da jedoch verschiedene Motoren nacheinander eingesetzt werden sollen, die nicht alle bei der gleichen Spannung anlaufen, wäre diese Funktion für mich äußerst wichtig.

Im konkreten geht es sich dabei um einen Regler für das Slotracing. Vielleicht sagt das ja dem ein oder anderen etwas.

Ich bedanke mich schonmal im Vorraus!

Marc.

marc_werth: Hallo zusammen,

Ich falle gleich mal mit der Türe ins Haus. Ich habe eine Aufgabe, die ich nicht gelöst bekomme^^ Wirklich bewandert im Programmieren bin ich leider auch nicht. Zur Zeit lese ich ein Poti aus, um einen PWM-Pin zu steuern. Dieses wird später durch einen linearisierten Hall-Geber ersetzt. Mit einem zweiten Poti möchte ich den Startwert der PWM ändern, ohne den "Regelweg" zu minimieren. Ich hatte mir gedacht, dass ich ein mapping anlege (0, 1023, 0, 255) und die zweite null manipiliere. Genau das bekomme ich jedoch nicht hin. Sofern es denn überhaupt geht.

Klingt für mich als wenn Du mit zwei Potis an A0 und A1 sowas in der Art möchtest:

byte regelWert=map(analogRead(A0),0,1024,analogRead(A1)>>2,256);

marc_werth: ... Slotracing. Vielleicht sagt das ja dem ein oder anderen etwas.

Jetzt, wo ich nachgesehen habe, weiß ich, dass das mal Autorennbahn hieß.

Schön, dass man auch am Wochenende mal etwas dazulernt.

Gruß

Gregor

Juhu, es klappt :slight_smile: auch wenn ich gerade höchstens oberflächlich verstehe warum.

Jap, man kann es auch Autorennbahn nennen. Ich persönlich fahre im Maßstab 1:32 auf Schienen der Marken Carrera und Ninco sowie deutlich schnellere Fahrzeuge im Maßstab 1:24 auf gefrästen Holzbahnen. Diese Klassen heißen Flexi und Eurosport. Diese bestehen aus gestanzten oder gelaserten Chassis aus Federstahl und haben echt heisse Motoren. Die genehmigen sich gerne 20A. Die 1:32er im Worstcase mal 1,8A. Alles bei ca. 12V.

Wie dem auch sei, ich bin meinem eigenen Regler nun ein großes Stück weiter. Jedenfalls machen die LED’s auf dem Breadboard nun was sie sollen.
Wenn der kontaktlose Abgriff des Triggers nachher per Hallsensor funktioniert kommt noch die Hexerei mit der Endstufe. Ein gleichzeitiges Durchschalten der FET’s muss verhindert werden, da zum Bremsen der Motor kurzgeschlossen wird.

Anbei dann noch mein bisheriger Codesalat. Schließlich lebt openSource nicht von Geheimnissen :wink:

int trigger = A0;         // trigger Pin am A0
int gas = 3;              // Gas am Pin3
int bremse = 6;           // Bremse am Pin6
int vollgas = 5;          // Vollgas am Pin5, dient zur Zeit als visuelle Kontrolle ob Vollgas erreicht wird
int startspannung = A1;   // Poti der Startspannung am Pin A1
int bremsdaempfer = A2;   // Poti der Bremsdaempfung am Pin A2
int triggerstellung = 0;  // variable der Triggerstellung
int power = 0;            // Variable der Startspannung
int brake = 0;            // Variable der Bremsdaempfung
//int beschleunigung = 0;   // Variable aus Triggerstellung und Startspannung
int motor = 0;            // Variable der Motorspannung




void setup() {
  Serial.begin(9600);       // wird nur während der Entwicklung benötigt um diverse Werte zu prüfen, später auskommentieren
pinMode (gas, OUTPUT);      // setzt gas-pin auf OUTPUT
pinMode (bremse, OUTPUT);   // setzt bremse-Pin auf OUTPUT
pinMode (vollgas, OUTPUT);  // setzt Vollgas-Pin auf OUTPUT

}

void loop() {

  triggerstellung = map(analogRead(trigger), 0, 1023, 0, 255);    //friemelt den großen Wert vom Poti ins PWM-Fenster
  power = map (analogRead(startspannung), 0, 1023, 0, 255);       //friemelt den großen Wert vom Poti ins PWM Fenster
  brake = map (analogRead(bremsdaempfer), 0, 1023, 0, 255);       //friemelt den großen Wert vom Poti ins PWM Fenster
//  beschleunigung = (triggerstellung)+(power);
  int motor=map(analogRead(trigger),0,1023,analogRead(startspannung)>>2,255); //Motorspannung unter Berückstichtigung der Startspannung. Hab aber noch keine Ahnung warum das funktioniert

  Serial.println(motor);                                          //wird nur während der Entwicklung benötigt um diverse Werte zu prüfen, später auskommentieren
  delay(1);                                                       //wird nur während der Entwicklung benötigt um diverse Werte zu prüfen, später auskommentieren

 


if (triggerstellung > 35)                                        //Trigger größer 35 macht PWM, ansonsten auf LOW
  {
    analogWrite(gas,motor);                                     //schreibt die Motorspannung aufs PWM unter Berücksichtigung der Startspannung
  }
  {
    digitalWrite(vollgas, LOW);                                 //kein Vollgas in Regelzone
  if (motor > 245)                                            //Motorspannung größer 245 macht Vollgas ansonsten auf LOW
  {
    digitalWrite(vollgas, HIGH);                                  //zieht den Vollgas-Pin auf HIGH
  }
  else
  {
    digitalWrite(vollgas, LOW);                                   //KEIN Vollgas
   if (triggerstellung < 25)                                       //Trigger kleiner 25
   {
    digitalWrite(vollgas, LOW);                                   //KEIN Vollgas
    digitalWrite(gas, LOW);                                       //KEIN Gas
    analogWrite(bremse, brake);                                   //zieht Bremse-Pin auf PWM
   }
   else
   {digitalWrite(bremse, LOW);                                    //KEINE Bremse wenn die obigen Bedingungen nicht erfüllt sind
   }

   
  }
}
}

marc_werth: Juhu, es klappt :-) auch wenn ich gerade höchstens oberflächlich verstehe warum.

Das Auslesen eines 10-Bit ADC mit analogRead(startspannung) ergibt einen Wert im Bereich 0 bis 1023.

Und wenn Du aus dem 10-Bit Wert die zwei niederwertigsten Bits herausschiebst, dann bekommst Du einen 8-Bit Wert im Bereich 0 bis 255.

Der Ausdruck "analogRead(startspannung)>>2"

hat also einen Bereich von 0 bis 255.

Denselben Effekt hättest Du mit einer Division durch 4:

Der Ausdruck "analogRead(startspannung)>>2" ist dasselbe wie "analogRead(startspannung)/4"

und liefert den Bereich 0 bis 255

Zwei Bits aus einer Variablen nach rechts herausschieben, Division durch 4, das ist alles keine Raketenwissenschaft.