Servo Motor Steuerung über Potentiometer

[servomoto (Gast)]

Hallo!

Für ein kleines Projekt würde ich gerne einen Servomotor über ein 
Potentiometer steuern. Der Servomotor läuft bereits, und lässt sich über 
das Poti steuern. Jedoch verliert der Servo anscheinend immer wieder das 
Signal. Dreh ich das Poti langsam von 0 auf ca. 1/2 Anschlag folgt mir 
der Servo ca. 1:1, dreh ich dann etwas weiter verliert der Motor auf 
einmal die Verbindung (Windows Plugin Sound kommt) und marschiert nur 
noch in größeren einzelnen Schritten weiter. Bleib ich dann wieder auf 
dem Wert, und drehe wieder langsam in die andere Richtung so fängt er 
sich wieder und marschiert 1:1 weiter bis er das nächste mal die 
Verbindung verliert.

Habt ihr eventuell eine Ahnung was das sein könnte? Vielen Dank schonmal 
für eure Hilfe & Ideen.

LG

Kurze Daten:
Servo VILROS MicroServe SG90 (Pulsbreite von 500us-2500us)
Arduino UNO Board - ATmega328p
(Den Code sende ich sobald sich einer damit auseinander setzen möchte)

[P.Rog (Gast)]

servomoto schrieb:
> (Den Code sende ich sobald sich einer damit auseinander setzen möchte)

Das könnte ein Henne-Ei-Problem sein ...

[servomoto (Gast)]

#define F_CPU 16000000
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

uint16_t ReadChannel(uint8_t mux_adc_channel);         //ADC-auslese Funktion deklarieren
uint16_t adc_value;                      // Rückgabewert der Auslese-Funktion
uint16_t valuetosend; 
uint16_t move = 0;
uint16_t adc_enabled = 1;
uint16_t grad;

void adc_init (){
   TCCR1A =  (1<<WGM11)|(1<<COM1A1) ;    // 9-Bit PWM Modus Auflösung 1024, NICHT invertiert
   TCCR1B = (1<<WGM13) | (1<<WGM12)|(1<<CS12)|(1<<CS10);    // Prescale 1024, Mode 14 (CTC)
   DDRB |= (1<< PB1);                  // PB1(OC1A) als Ausgang definieren
   ICR1 = 312;
}

ISR(USART_RX_vect)                                  // definiert Interrupt Service Routine für USART receive complete
{   
  cli();                                          // clear interrupt enable
  grad = UDR0;
  char sendString [3];

  if(grad >= 0 && grad <= 180)                // wenn Eingabe zwischen 0-180, dann accepted
  {  
    adc_enabled = 0;
    uart_sendstring(" Adc Disabled ");

    int_to_string(grad, sendString);
    uart_sendstring(sendString);
    move = grad * 5.688;
    OCR1A = (move / 35 ) + 8;
  }
  else                                            // wenn nicht, nochmalige Eingabe
  {  
    adc_enabled = 1;
    uart_sendstring("adc enabled");
  }
  
  sei();                                          // enable global Interrupt
}

// MAIN

int main(void)
{
   uart_init(115200);
   adc_init();
   sei();

   while(1)
     {  if(adc_enabled == 1)
     {
        adc_value = ReadChannel(0);             // Channel 0 auslesen (Wert 0...1023)
          OCR1A = (adc_value / 35 ) + 8;       // PWM-Vergleichswert setzen, werte müssen zwischen 8 und 32 liegen
     }
   }
   return 0;
 } 

// Auslesen des ADC

uint16_t ReadChannel(uint8_t mux_adc_channel)
{  
   ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1)| (1<<ADPS0);   // Frequenzvorteiler auf 32 setzen und ADC aktivieren
   ADMUX = mux_adc_channel;                           // übergebenen Kanal waehlen
   ADMUX |= (0<<REFS1) | (1<<REFS0);                   // interne Referenzspannung nutzen
   
//dummy readout
   ADCSRA |=(1<<ADSC);          // start ADC Conversio
   while( ADCSRA & (1<<ADSC) ) {};      // auf abschluss von Wandlung warten
   ADCSRA &= ~(1<<ADEN);                // ADC deaktivieren ("Enable-Bit" auf LOW setzen)
 
  return ADCW;
}

[Magnus M. (magnetus)]

Vergiss deinen Plan den Servo über den Arduino besaften zu wollen und 
gönne dem Servo seine eigene Stromversorgung mit ausreichend Strom!

[servomoto (Gast)]

Gut, danke. Werde es demnächst ausprobieren, hab nun aber noch 2 weitere 
Probleme :D

Und zwar: Soll über UART die aktuelle Grad Position gesendet werden, so 
dass der PC User immer weiß welche Stellung der Servo gerade hat. Dies 
funktioniert ebenfalls bereits, jedoch unterbricht die Datenübertragung 
immer wieder nach unterschiedlicher Zeit. Mittels _delay_ms(1000) sollte 
mir die Schnittstelle am PC jede Sekunde die aktuelle Position senden.

Hier der UART-Code und die Umrechnung auf Grad in dem ich die Werte vom 
Poti (0-1023) auf 0-180° umrechne (/5,68).

//UART
void uart_init (uint32_t baudrate)
{
  uint16_t  ubrr = (F_CPU / 8 / baudrate) - 1;     
                            
  UBRR0H = (uint8_t) (ubrr >> 8);      
  UBRR0L = (uint8_t) (ubrr & 0xff);    

    UCSR0A |= (1<<U2X0);  
                    
    UCSR0B |= ( 1<<TXEN0);   
  UCSR0B |= ( 1<<RXEN0);   
}

void uart_transmit (uint8_t data)
{
  while ( (UCSR0A & (1 << UDRE0)) == 0)  ;    
  UDR0 = data;              
}

uint8_t uart_receive ()
{
  while ( (UCSR0A & (1 << RXC0)) == 0)  ;   
  return(UDR0);                
}

void int_to_string ( uint16_t number, char *targetString )  
{
  int8_t digit;

  for (digit = 3; digit >= 0; digit--)
  {
    targetString[digit]= number%10 + '0';  
    number = number/10;
  }
  targetString[4] = 0;
}

void uart_sendstring ( char * str )
{
  while ( * str != 0 )
  {
    uart_transmit ( * str);
    str++;
  }
}

// MAIN
int main(void)
{
   char sendString [3];
   uart_init(115200);

   TCCR1A =  (1<<WGM11)|(1<<COM1A1) ;                  // 9-Bit PWM Modus Auflösung 1024, NICHT invertiert
   TCCR1B = (1<<WGM13) | (1<<WGM12)|(1<<CS12)|(1<<CS10);    // Prescale 1024, Mode 14 (CTC)
   DDRB |= (1<< PB1);                                // PB1(OC1A) als Ausgang definieren
   
   ICR1 = 312;
   
  while(1)
     {  
        adc_value = ReadChannel(0);                    // Channel 0 auslesen (Wert 0...1023)
        OCR1A = (adc_value / 35 ) + 8;                 // PWM-Vergleichswert setzen, werte müssen zwischen 8 und 32 liegen

      ADCSRA |= (1<<ADSC);

    while (ADCSRA & (1<<ADSC));

    uint16_t result = ADCL;
    result = result + (ADCH<<8);

    valuetosend = result / 5.68;

    int_to_string (valuetosend, sendString);
    uart_sendstring (sendString);
    uart_sendstring ("Grad ");

    PORTB ^= (1<<5);

    _delay_ms(1000);
   }
 return 0;
 }

[holger (Gast)]

>hab nun aber noch 2 weitere Probleme :D

Löse erst mal dein erstes Problem. Weitere Probleme
sind solange das nicht geschehen ist nicht wichtig.

[servomoto (Gast)]

Hab jetzt aber leider keine 5V Versorgung bei der Hand und würde gerne 
die anderen Probleme noch beseitigen. Ich bin leider alles schon zu oft 
durchgegangen und anscheinend verlese ich mich immer wieder an einer 
Stelle, da beides ja schon ziemlich gut funktioniert würde ich sagen, 
kann es nur an einer Kleinigkeit liegen. Kennt sich von euch zufällig 
jemand gut mit UART aus und verwendet ev. auch HTerm als 
Schnittstellensoftware?

[holger (Gast)]

>kann es nur an einer Kleinigkeit liegen.

Nein, nur an deiner Unfähigkeit.

>   char sendString [3];
>    int_to_string (valuetosend, sendString);

void int_to_string ( uint16_t number, char *targetString )  
{
  int8_t digit;

  for (digit = 3; digit >= 0; digit--) // digit wird hier negativ, sendstring hat nur drei Byte, der erste Zugriff ist auf Byte vier
  {
    targetString[digit]= number%10 + '0';  
    number = number/10;
  }
  targetString[4] = 0; // sendstring hat nur drei Byte. Hier wird auf das fünfte zugegriffen.
}

[servomoto (Gast)]

Danke für den Hinweis. Hab leider schon unzählige verschiedene 
Code-Versionen an denen ich rumbastle. Bin jetzt der Meinung dass die 
Versorung einfach zu wenig ist, somit die Verbindung verloren geht und 
daher dann auch das Schnittstellenprogramm nicht mehr arbeitet.

Das einzige was noch fehlt:

Der Servo soll durch Eingabe in HTerm (Dez.) (0-180°) an die gewünschte 
Position fahren. Bekommt der uC nun also eine Eingabe, so soll er den 
ADC deaktivieren (sodass Änderung mittels Poti kurzzeitig nicht mehr 
möglich ist), und an die gewünschte Position fahren. Ist dies 
abgearbeitet, so soll er den ADC wieder aktivieren.

Ich habe oben schon ein Interrupt geschrieben. Teste ich das ganze mit 
einer Hilfsvariable, so bekomm ich immer einen Wert gesendet, obwohl der 
ADC deaktiviert ist, und erst ein Wert kommen dürfte wenn ich eine 
Eingabe getätigt habe. Hat hierzu jemand vielleicht einen 
Lösungsvorschlag, oder gar einen Weg?

LG