µC um Modellbauservos und DC-Motoren anzusteuern

[Waspy (Gast)]

Hallo

Ich suche einen möglichst kleinen, leichten und natürlich günstigen 
8-Bit µC, der 4 PWM-Signalausgänge hat (für DC und Servos), sowie einen 
Analog-Digital Wandler als Eingang. Sprache sollte C sein.

Vielen Dank für eure Hilfe
Grüsse Waspy

[Klaus (Gast)]

Waspy schrieb:
> natürlich günstigen

Was ist für dich günstig? Wenn der Chip halbsoviel wie das Porto kostet? 
Oder weniger als der Extrakäse auf der Piza oder ein Kaffee Latte?

MfG Klaus

[Der Andere (Gast)]

Waspy schrieb:
> 4 PWM-Signalausgänge

Jeder I/O Pin kann als PWM Signalausgang benutzt werden. Alles eine 
Frage der Software.

Waspy schrieb:
> 4 PWM-Signalausgänge hat (für DC und Servos)

Was bitte ist PWM für DC und Servos? PWM ist PWM, was man damit macht 
ist doch Sache der nachfolgenden Elektronik.

[Witkatz :. (wit)]

PIC12F1501 erfüllt die genannten Anforderungen.

[Thomas E. (picalic)]

Waspy schrieb:
>
> 8-Bit µC, der 4 PWM-Signalausgänge hat (für DC und Servos), sowie einen
> Analog-Digital Wandler als Eingang.

Sicher, daß der eine AD-Eingang die komplette Eingabeseite ist oder hast 
Du in der Spec noch die Eingänge für Taster, RC-Signaleingänge oder eine 
serielle Schnittstelle vergessen? Dann würde nach der o.a. Spec z.B. ein 
PIC12F1840 o.ä. im 8-Pin DFN-Gehäuse entsprechen.

[Thomas E. (picalic)]

Ok, der 1501 ist ggf. noch besser, da er auch schon 4 Hardware-PWMs hat. 
(naja, läuft bei mir unter "o.ä." ;))
Allerdings ist fraglich, ob die 4 PWM Einheiten zum gleichzeitigen 
Ereugen des niederfrequenten Servo PWM-Signals und der hohen 
PWM-Frequenz für den "DC" (ich nehme an, das soll wohl ein DC-Motor 
sein?) geeignet sind oder die Servo-Signale nicht ohnehin eher per 
Software erzeugt werden müssen.

[Stefan F. (Gast)]

Ein konkretes beispiel für 10 Servo Kanäle mit nur einem einfachen Timer 
(keine PWM Hardware) findest du hier:

http://stefanfrings.de/servocontroller/index.html

PWM Kanäle brauchst du also nur für direkten Anschluss von DC Motoren.

[Harald W. (wilhelms)]

Waspy schrieb:

> 4 PWM-Signalausgänge für Servos

Die kann man über einen einzigen Pin ansteuern. Als Dekodierer
reicht da ein 4017. Auch (fast beliebig grosse)Motore kann man
so über sog. Fahrtregler steuern.

[Waspy (Gast)]

Hallo
Erstmal danke für die Antworten.
Um das ganze ein wenig zu präzisieren: Ich möchte das Signal das der 
Empfänger normalerweise direkt ans Servo sendet auslesen, was dann ein 
zeitgesteuertes Programm laufen lässt. Das PWM-Signal für die Servos 
möchte ich verwenden da ich es so gelernt habe und anderweitig schon 
genug Probleme auftauchen werden.
Vielleicht noch: Programmieren möchte ich am PC also ohne irgendwelche 
Eingabegeräte (Eclipse kenne ich bis jetzt)

Grüsse Waspy

[Karl H. (kbuchegg)]

Waspy schrieb:

> Das PWM-Signal für die Servos
> möchte ich verwenden da ich es so gelernt habe und anderweitig schon
> genug Probleme auftauchen werden.

Na ja. das ist jetzt aber nicht wirklich ein Argument.
Mehrere Servos mit nur einem einzigen Timer anzusteuern ist simpel, 
solange du einen einzigen Timer mit einem Compare Interrupt hast und das 
ganze so einstellen kannst, dass du mit den Pulszeiten hin kommst. Die 
Servos werden dann im Hintergrund angesteuert und das auf beliebigen 
Ausgabepins. Für das restliche Progamm sind die Servos einfach nur ein 
Array von Werten, in das sie die Servopositionen schreiben und um den 
Rest kümmert sich der (simple) Interrupt. Das kann praktisch jeder 
heutige µC. Und das, wenn es genügend Ausgabepins gibt, problemlos bis 
hoch zu 10 bis 12 Servos. Mit jedem weiteren Timer kommen dann wieder 
maximal 10 bis 12 Servos dazu, wobei man dann allerdings einen kleinen 
Jitter (abhängig von der Taktfrequenz des µC) wohl in Kauf nehmen muss.
Nicht so simpel ist es hingegen, einen µC zu finden der 4 PWM erzeugen 
kann, ohne dass du dir dabei die halbe µC-Hardware dadurch blockierst 
und dann auch noch die Ausgänge pinmässig dort hast, wo du dir das 
Platinendesign einfach machen kannst.

> möchte ich verwenden da ich es so gelernt habe

D.h. du hast bereits einen µC mit dem du umgehen kannst?
Wenn der 1 Timer hat mit einem Compare Interrupt, dann hast du bereits 
den Fuss in der Tür. Jetzt musst du dich nur noch von der Idee trennen, 
dass alle Servos gleichzeitig ihren Puls kriegen müssen, sondern dass es 
auch völlig ausreichend ist, wenn die reihum ihren Puls zeitversetzt 
kriegen und dass die 20ms so ziemlich das aller unwichtigste an der 
ganzen Sache ist und in 20 Minuten ist deine Servoansteuerung fertig.

am Beispiel eines 16 Bit Timers

volatile uint16_t ServoPosition[4];

....
CompareInterrupt() 
{
  static uint8_t aktuellesServo = 0;
  
  if( aktuellesServo == 0 )
    schalte Ausgang für Servo 0 auf 0
  else if( aktuellesServo == 1 )
    schalte Ausgang für Servo 1 auf 0
  else if( aktuellesServo == 2 )
    schalte Ausgang für Servo 2 auf 0
  else if( aktuellesServo == 3 )
    schalte Ausgang für Servo 3 auf 0

  aktuellesServo++;
  if( aktuellesServo == 10 )
    aktuellesServo = 0;

  if( aktuellesServo == 0 )
    schalte Ausgang für Servo 0 auf 1
  else if( aktuellesServo == 1 )
    schalte Ausgang für Servo 1 auf 1
  else if( aktuellesServo == 2 )
    schalte Ausgang für Servo 2 auf 1
  else if( aktuellesServo == 3 )
    schalte Ausgang für Servo 3 auf 1

  if( aktuellesServo < 4 )
    Compare Wert += ServoPosition[aktuellesServo];
  else
    Compare Wert += CompareWert für ca 2 ms;
}

....

// Wann immer eine Servo auf eine Position fahren soll, wird der
// CompareWert dafür anhand der bekannten Timertaktung ausgerechnet
// und das Ergebnis davon in ServoPosition geschrieben.
// Achtung: ev. ist dafür ein atomarer Zugriff notwendig

abhängig von den Pin-Positionen bzw. der Verteilung der Pins auf Ports, 
sind da noch Vereinfachungen möglich, zb im setzen der Servoausgänge auf 
0 das als 'Rundumschlagaktion' dann einfach alle 4 Ausgänge auf einmal 
auf 0 setzen kann.
Ich lass die Servo Anzahl bis 10 hochlaufen, damit sich eine 
Pulswiederholung für ein einzelnes Servo von ca. 20ms ergibt. Aber wie 
gesagt: die 20ms sind nicht kritisch. Ob das jetzt 15 oder 18 oder 20ms 
sind, ist den Servos ziemlich gleichgültig. Das muss nicht genau sein 
und wenn die Zeit so ungefähr stimmt, dann passt das schon.

[Mitlesa (Gast)]

Waspy schrieb:
> Vielleicht noch: Programmieren möchte ich am PC also ohne irgendwelche
> Eingabegeräte (Eclipse kenne ich bis jetzt)

Das dürfte schwierig werden, so ohne Tastatur, Maus, Tablet,
Touchscreen, Touchpad ....

[Waspy (Gast)]

Mitlesa schrieb:
> Waspy schrieb:
>> Vielleicht noch: Programmieren möchte ich am PC also ohne irgendwelche
>> Eingabegeräte (Eclipse kenne ich bis jetzt)
>
> Das dürfte schwierig werden, so ohne Tastatur, Maus, Tablet,
> Touchscreen, Touchpad ....

Man kann auch überall das Haar in der Suppe finden
Sry aber nächstes mal bevor du so ne Antwort gibst überlegst du dir 
bitte nochmals ob mir das hilft oder nicht

[Hä? (Gast)]

Waspy schrieb:
> Programmieren möchte ich am PC also ohne irgendwelche
> Eingabegeräte (Eclipse kenne ich bis jetzt)

Was ist denn hier mit Eingabegeräte gemeint? Also die vom PC 
(Maus,Tastatur) können es ja nicht sein, so weit bin ich schon...

[Stephan G. (Firma: privat) (morob)]

eigentlich macht das jeder arduino, da sind die biblotheken vorhanden.

[Waspy (Gast)]

Sry für den Doppelpost

@ Karl Heinz
ja ich hab ein bischen schon mit Mikrocontroller gearbeitet aber ich 
würde meine Kenntnisse jetzt nicht als ausreichend einschätzen um so was 
ohne Anleitung hinzukriegen und um mich noch gross in etwas 
reinzuarbeiten fehlt mir eigentlich das Interesse am Mikrocontroller.

Bei deinem Code sehe ich jetzt nicht wie du jedes Servo einzel 
ansteuerst. So wie ich dich jetzt verstanden habe erzeugst du ein PWM 
Signal und verteilst das auf unterschiedliche Ausgänge oder?

[Waspy (Gast)]

Hä? schrieb:
> Was ist denn hier mit Eingabegeräte gemeint? Also die vom PC
> (Maus,Tastatur) können es ja nicht sein, so weit bin ich schon...

k.A was es alles so gibt hab mal vermutet das es so kleine mobile 
handprogrammiergeräte gibt oder so...

[Karl H. (kbuchegg)]

Waspy schrieb:
> Sry für den Doppelpost
>
> @ Karl Heinz
> ja ich hab ein bischen schon mit Mikrocontroller gearbeitet aber ich
> würde meine Kenntnisse jetzt nicht als ausreichend einschätzen um so was
> ohne Anleitung hinzukriegen und um mich noch gross in etwas
> reinzuarbeiten fehlt mir eigentlich das Interesse am Mikrocontroller.
>
> Bei deinem Code sehe ich jetzt nicht wie du jedes Servo einzel
> ansteuerst. So wie ich dich jetzt verstanden habe erzeugst du ein PWM
> Signal und verteilst das auf unterschiedliche Ausgänge oder?

Man könnte es so sagen.
Aber viel simpler ist es, zu sagen, dass der Compare Interrupt so 
eingestellt wird, das er auslöst wenn die Pulszeit für ein bestimmtes 
Servo abgelaufen ist. Dann wird der zugehörige Ausgang für dieses Servo 
auf 0 geschaltet und der Ausgang für das nächste Servo auf 1. Dessen 
Pulszeit beginnt dann zu laufen und der Compare Wert vom Timer wird so 
eingestellt, dass der Timer sich mittels Interrupt wiedder meldet wenn 
diese Pulszeit abgelaufen ist. Und so geht das immer weiter. Der 
Timerinterrupt kommt immer dann, wenn die Pulszeit für ein Servo zu Ende 
ist und dann beginnt der Puls für das nächste Servo.

                    +------+
                    |      |
  Servo 0      -----+      +----------------------------------

                           +----+
                           |    |
  Servo 1      ------------+    +-----------------------------

                                +--------+
                                |        |
  Servo 2      -----------------+        +--------------------

                                         +------+
                                         |      |
  Servo 3      --------------------------+      +-------------

                   ^
                   | Interrupt

                           ^
                           | Interrupt

                                ^
                                | Interrupt
 
                                         ^
                                         | Interrupt

                                                ^
                                                | Interrupt

Der Timer-Interrupt findet an den Pulsflanken statt. D.h. eigentlich 
umgekehrt: Der Interrupt findet statt wenn Zeiten abgelaufen sind. Die 
Flanken an den entsprechenden Pins sind dann die Reaktion des Programms 
darauf.

[Karl H. (kbuchegg)]

Waspy schrieb:

> um mich noch gross in etwas
> reinzuarbeiten fehlt mir eigentlich das Interesse am Mikrocontroller.
>

Oooops. Hab ich beim ersten mal lesen überlesen.

Dann noch einen schönen Tag. Da fehlt nämlich mir das Interesse daran, 
zu versuchen jemandem etwas beizubringen, der keine Lust dazu hat etwas 
zu lernen.

[Mitlesa (Gast)]

Karl H. schrieb:
> der keine Lust dazu hat etwas zu lernen.

Na, das passt doch zu den "Eingabegeräten" .....

[Waspy (Gast)]

was neues lernen heisst ja nicht das man das was man bereits weiss nicht 
auch anders anwenden kann...
danke trotzdem das dus versucht hast
an die anderen: bin mir ja einiges gewohnt von Foren aber wenn 50% der 
Posts einfach Bullshit ist da einfach nicht genau gelesen oder was weiss 
ich und mir nur einer wirklich zu helfen versucht sry dann ists wirklich 
das schlechteste Forum in dem ich war

[Witkatz :. (wit)]

Waspy schrieb:
> an die anderen: [..] Bullshit

Na suuper, vielen Dank. Und dafür habe ich für dich das Microchip 
Produktverzeichnis durchforstet um den passenden µC herauszusuchen.

[Mitlesa (Gast)]

Waspy schrieb:
> dann ists wirklich das schlechteste Forum in dem ich war

Für dich gibt es sicher noch viel besser geeignete Foren.

[Jan H. (jan_m_h)]

In dem Forum hier ist halt die Qualität der Antworten noch stärker als 
üblich von der Qualität der Frage abhängig.

Waspy schrieb:
> ohne Anleitung hinzukriegen und um mich noch gross in etwas
> reinzuarbeiten fehlt mir eigentlich das Interesse am Mikrocontroller.

Und damit macht man sich hier keine Freunde, die meisten Leute hier 
wollen etwas lernen oder den Leuten beim lernen helfen. Jemand anders 
die Arbeit abnehmen tut nunmal mehr oder weniger niemand freiwillig für 
einen Fremden.