Lichtsensor Servo steuern

[cube4 (Gast)]

Hallo,

Ich habe zwei Lichtsensoren die über den ADC ausgelesen werden und je 
nachdem einen Servo steuern sollen.
Ich bräuchte ein paar Denkanstöße wie ich das realisieren könnte.

In einer Schleife ?

LinkerSensor == RechterSensor
(nichts tun bzw. Letzten PWM-Wert beibehalten)

Wenn LinkerSensor > RechterSensor
(Servo nach Links drehen bis LinkerSensor == RechterSensor)
aber wie könnte ich das umsetzen ? eine Schleife die meinen Letzten PWM 
Wert runterzählt bis wieder LinkerSensor == RechterSensor ?

oder gibt es da einfachere Methoden und ich denke wieder zu Kompliziert 
?

Danke

[Karl H. (kbuchegg)]

cube4 schrieb:

> oder gibt es da einfachere Methoden und ich denke wieder zu Kompliziert
> ?

Die Grundidee ist nicht so falsch, aber die Usetzung ist viel zu 
kompliziert.
Du hast noch nicht verinnerlicht, dass dir die Hauptschleife, die jedes 
µC Programm hat, automatisch eine Art Zeittaktung deines Programms 
vorgibt, in die du dich am besten einklinkst, anstatt gegen sie zu 
arbeiten.

Jedes µC Programm sieht in etwa so aus

int main()
{
  Initialisierungen

  sei();

  while( 1 ) {

    Programmlogik

  }
}

Der Teil Programmlogik ist der interessante Teil. Deine Denkweise muss 
sein, dass sich die Programmlogik immer nur um Zeitpunkte kümmert. D.h. 
deine Programmlogik fragt sich: Was genau gibt es jetzt zu tun? Welche 
Ereignisse sind eingetreten? Welche Messwerte liegen vor? Welche 
Aktionen leiten sich daraus ab?
Und ein paar Myykrosekunden später beginnt die Hauptschliefe wieder von 
vorne und der ganze Prozess des "Was gibt es genau jetzt zu tun? etc. 
etc" beginnt wieder von vorne. Nur das eben jetzt ein etwas späterer 
Zeitpunkt vorliegt.


D.h. dein Programm baust du so auf

  ...

  while( 1 ) {

    Messung Links
    Messung Rechts

    if ( Messung Links < Messung Rechts )
      drehe Servo etwas nach links (zb PWM Wert--)

    else if ( Messung Links > Messung Rechts )
      drehe Servo etwas nach rechts (zb PWM Wert++)

    else
      stoppe Servo (zb PWM Wert nicht verändern)
  }

du musst dich von dieser "Ich drehe nach links bis die Werte gleich 
sind, und das Ganze am Besten in einer Schleife" - Denkweise lösen. Du 
hast bereits eine Schleife - deine Hauptschleife. Dein Programm ackert 
diese durch, viele tausend mal in der Sekunde. So schnell ist deine 
Hardware nicht, dass dein Programm den Punkt verpassen würde, an dem die 
beiden Messwerte gleich sind. Ganz im Gegenteil wird dein Programm eher 
sogar zu schnell sein, so dass du es bremsen musst, damit es den PWM 
Wert nicht viel zu schnell ändert, so dass das Servo nicht mitkommt.

>
> Danke

[cube4 (Gast)]

Habe es jetzt mal so umgesetzt aber ich mache irgendwas mit meiner 
Funktion falsch, kann mich jemand aufklären ?

#include <avr/io.h>
#include "MrLCD.h"
#include <util/delay.h>
  

uint16_t LinkerSensor = 0;
uint16_t RechterSensor = 0;
uint16_t LetzterWert = 512;

void SensorenAuswerten(void);

  
int main(void)
{
  
  InitializeMrLCD(); //LCD initialisieren

  //ADC initialisieren
  
  ADCSRA = (1<<ADPS2) | (1<<ADEN); // Prescaler 16 | ADC-An 
  ADMUX  |= (1<<REFS0);        // AVCC als Referenz Kondensator bei AREF
  
  //PWM initialisieren
  
  DDRD |= 1<<PORTD4 ; // PD4 auf Ausgang
  TCCR1A |= 1<<WGM11| 1<<COM1B1 | 1<<COM1B0; // Fast PWM | PD4 Inverted
  TCCR1B |= 1<<WGM12 | 1<<WGM13 | 1<<CS10;  // Fast PWM  | Prescaler 1
  ICR1 = 19999;  // 20ms Period  
  //Send_A_StringToMrLCDwithLocation(1,1,"MUUUHHH!!!");
  
while (1)
{
  
  void SensorenAuswerten();


  if(LinkerSensor > RechterSensor) //Wenn LinkerSensor größer dann
  {  
    LetzterWert --; //LetzenWert verringern  
    OCR1A = LetzterWert; //Und an PWM ausgeben
  }
  
    else if(LinkerSensor < RechterSensor)  
  {  
    LetzterWert ++; //LetzenWert vergrößern  
    OCR1A = LetzterWert; //Und an PWM ausgeben
  }
  
    else if(LinkerSensor == RechterSensor) //Wenn gleich

  {
    OCR1A = LetzterWert; //dann nichts tun Letzten Wert behalten
  }

    
    
}
  
  
void SensorenAuswerten()
{

  //Linken Sensor auslesen
  
  ADMUX = 0x40; // REFS0 (AVCC) | PA0 lesen 
  ADCSRA |= (1<<ADSC);        //1. ADC PA0 auslesen Linker Sensor
  while (ADCSRA & (1<<ADSC) ) {}   //auf Abschluss der Konvertierung warten
  
  LinkerSensor = ADC;     //und in Variable übergeben
  
  Send_A_StringToMrLCDwithLocation(1,1,"Links:");
  Send_An_IntegerToMrLCD(7, 1, LinkerSensor,7); //Ergebnis an Display senden

  
  //Rechten Sensor auslesen
  
  ADMUX = 0x41; // REFS0 (AVCC) | PA1 lesen
  ADCSRA |= (1<<ADSC);       //2. ADC PA1 auslesen Rechter Sensor
  while (ADCSRA & (1<<ADSC) ) {}  //auf Abschluss der Konvertierung warten
  
  RechterSensor = ADC;   //und in Variable übergeben
  
  Send_A_StringToMrLCDwithLocation(1,2,"Rechts:");
  Send_An_IntegerToMrLCD(7, 2, RechterSensor,7); //Ergebnis an Display senden

}

}

[Karl H. (kbuchegg)]

Das

while (1)
{

  void SensorenAuswerten();

ist kein Funktionsaufruf, sondern die Deklaration einer Funktion, von 
deren Argumentliste nichts bekannt ist und die nichts zurückliefert.

Das

while (1)
{

  SensorAuswerten();

wäre einer.

[cube4 (Gast)]

So bekomme ich aber das Warning:

undefined reference to SensorAuswerten

[Karl H. (kbuchegg)]

cube4 schrieb:
> So bekomme ich aber das Warning:
>
> undefined reference to SensorAuswerten


Wie heisst noch mal deine Funktion?

  SensorAuswerten   (also Einzahl)

oder

  SensorenAuswerten   (also mehrere Sensore_n_)

?

Deine Funktionsnamen solltest du schon kennen, selbst wenn ich mich in 
der Eile vertippe.

[cube4 (Gast)]

Ne ich hab mich vertippt SensorenAuswerten, aber die Funktion heißt bei 
mir überall gleich und der Fehler kommt trotzdem ?

[Karl H. (kbuchegg)]

Sie kann nicht überall gleich heißen, sonst würdest du den Fehler nicht 
kriegen. Irgendwo muss ein Tippfehler sein.

Nimm den Namen in den Copy&Paste Buffer und kopier ihn überall drüber. 
So ist sichergestellt, dass alle Schreibweisen überall gleich sind.

[MaWin (Gast)]

Ein eindeutiges Argument warum man nichts in eine Funktion verpacken 
sollte wenn man ss sowieso nur ein Mal aufruft. Dann muss man auch nicht 
darauf achten, die Funktion vor der Verwendungsstelle zu definieren.
Du solltest deiner PWM noch Zeit geben, den Impuls auszugeben und die 
Wartezeit abzuwarten, bevor du schon wieder den PWM Wert änderst.

[Karl H. (kbuchegg)]

MaWin schrieb:
> Ein eindeutiges Argument warum man nichts in eine Funktion verpacken
> sollte wenn man ss sowieso nur ein Mal aufruft.

(*)

Na ja.
Iregendwann muss er aber mal lernen, worauf er achten muss und wie 
Fehlermeldungen zu interpretieren sind.

> Dann muss man auch nicht
> darauf achten, die Funktion vor der Verwendungsstelle zu definieren.

Er braucht nur die Funktion vor main schieben und auf die Schreibweise 
achten.
Das Argument sollte eigentlich lauten: Ein eindeutiges Argument, warum 
man auf Funktionsnamen achten soll, die einem wenig Spielraum für 
Tippfehler geben ohne dass man es bemerkt.

> Du solltest deiner PWM noch Zeit geben, den Impuls auszugeben und die
> Wartezeit abzuwarten, bevor du schon wieder den PWM Wert änderst.

Das allerdings.



(*) mich regen Funktionsnamen wie Send_A_StringToMrLCDwithLocation viel 
mehr auf. Viel zu lang, viel zu kindisch.

[cube4 (Gast)]

Hallo,

also an den Namen liegt es wirklich nicht hab es Kopiert, das mit den 
Namen
Send_A_StringToMrLCDwithLocation ist schon "besch.." ja :-) aber das hab 
ich von einer Seite die die ganzen Funktionen für mich wirklich gut 
verständlich rübergebracht hat, habe es erstmal so beibehalten.

Sei es wie es will, lass ich die Funktion weg und packe es so in die 
Schleife funktioniert es meiner Meinung nach recht gut, NUR meine PWM 
noch nicht also Servo bewegt sich nicht.

Werde das mit der Zeit mal einbauen und sehen.

[cube4 (Gast)]

So habe es jetzt so gelöst funktioniert recht gut, obwohl nicht nötig, 
würde mich dennoch interessieren wie ich den Servo noch schneller machen 
könnte ?
Die In bzw. Dekrementierung erhöhen ?

#include <avr/io.h>
#include "MrLCD.h"
#include <util/delay.h>
  

uint16_t LinkerSensor = 0;
uint16_t RechterSensor = 0;

//void SensorenAuswerten(void);

  
int main(void)
{
  
  InitializeMrLCD(); //LCD initialisieren

  //ADC initialisieren
  
  ADCSRA = (1<<ADPS2) | (1<<ADEN); // Prescaler 16 | ADC-An 
  ADMUX  |= (1<<REFS0);        // AVCC als Referenz Kondensator bei AREF
  
  //PWM initialisieren
  
  DDRD |= 1<<PORTD4; // PD4 auf Ausgang
  TCCR1A |= 1<<WGM11| 1<<COM1B1 | 1<<COM1B0; // Fast PWM | PD4 Inverted
  TCCR1B |= 1<<WGM12 | 1<<WGM13 | 1<<CS10;  // Fast PWM  | Prescaler 1
  ICR1 = 19999;  // 20ms Period  
  
  uint16_t LetzterWert = ICR1 - 1500; //ServoPos = Mitte (18499)

  
while (1)
{
  
  //Linken Sensor auslesen
  
  ADMUX = 0x40; // REFS0 (AVCC) | PA0 lesen 
  ADCSRA |= (1<<ADSC);        //1. ADC PA0 auslesen Linker Sensor
  while (ADCSRA & (1<<ADSC) ) {}   //auf Abschluss der Konvertierung warten
  
  LinkerSensor = ADC;     //und in Variable übergeben
  
  Send_A_StringToMrLCDwithLocation(1,1,"Links:");
  Send_An_IntegerToMrLCD(7, 1, LinkerSensor,7); //Ergebnis an Display senden

  
  //Rechten Sensor auslesen
  
  ADMUX = 0x41; // REFS0 (AVCC) | PA1 lesen
  ADCSRA |= (1<<ADSC);       //2. ADC PA1 auslesen Rechter Sensor
  while (ADCSRA & (1<<ADSC) ) {}  //auf Abschluss der Konvertierung warten
  
  RechterSensor = ADC;   //und in Variable übergeben
  
  Send_A_StringToMrLCDwithLocation(1,2,"Rechts:");
  Send_An_IntegerToMrLCD(7, 2, RechterSensor,7); //Ergebnis an Display senden
  
  int16_t Differenz = LinkerSensor - RechterSensor;


  if(Differenz > 50) //Wenn Differenz größer als +50 
  {  
    LetzterWert  --; //LetzenWert verringern  z.B 18499 --; = 18498
    OCR1B = LetzterWert; //Und an PWM ausgeben
    
  }
  
    else if(Differenz < -50) //Wenn Differenz kleiner als -50  
  {  
    LetzterWert ++; //LetzenWert vergrößern  
    OCR1B = LetzterWert; //Und an PWM ausgeben
  }
  
    else  //ansonsten 

  {
    OCR1B = LetzterWert; //dann nichts tun Letzten Wert behalten
  }

    
    
}
  
  


  


}

[Mikesch (Gast)]

Hi

Manchmal kommt man auch auf Ideen für Programme indem man sich eine 
Analogschaltung anschaut, die den selben Zweck erfüllt.

http://www.electronicsplanet.ch/Schaltun/servoson/servosonnennachfuehrung.html

Gruss
Mikesch