DC-Motor ansteuern

luke schrieb:
> Wie meinst du
> "man könnte auch noch einen Kondensator parallel zur Diode anbringen"

10nF Keramisch, möglichst nah am Motor befestigen. Kann man auch 
weglassen.

Ich würde noch einen widerstand von gate nach masse empfehlen. So hat 
der mosfet einen definierten leitzustand (aus) auch wenn der pin des µC 
eventuell mal hochohmig ist.

luke schrieb:
> Ok, danke für eure antworten!
> Den 10nF Kondensator werde ich noch berücksichtigen.
>
> Wie groß sollte der Widerstand von gate nach masse den ca. sein?
> Ziemlich klein, oder?

Ich würde eher sagen: ziemlich groß, damit der Ausgangspin möglichst 
wenig dagegen ankämpfen muss, wenn er das Gate auf Vcc ziehen will.

Ich würde mal so um die 1k oder 10k vorschlagen. Es geht ja nur darum, 
dass es eine Verbindung zu Masse gibt, sollte der 'reguläre Eingang' 
noch kein sinnvolles Eingansgssignal erhalten.

was zwischen 5kOhm und 10kOhm dürften reichen.

Ja, das sieht gut aus. Ich sehe keinen grund, warum es nicht 
funktionieren sollte.

Viel glück bei der inbetriebnahme xD. Schreib uns, ob alles geklappt 
hat.

Falls du noch Probleme beim µC bekommst, kannst du die Versorgungen für 
Controller und Motor mit jeweils einem LC-Glied entkopplen.
Als Richtwert: 47µH für die Motorseite, 1µH für die µC-Seite.

luke schrieb:

> habe nun eine Frage zur Programmierung.
> Die Erzeugung eines PWM - Signal funktioniert soweit. Verwende dazu die
> 8Bit "Phase-Correct-PWM".
> Das PWM - Signal möchte ich nun verändern (0-254) um unterschiedliche
> Drehzahlen des Motors zu erhalten. Dies soll mit Hilfe des UART und
> einer kleinen C# Anwendung geschehen.

Ehe du einen 2 Frontenkrieg aufmachst, solltest du erst mal eine 
Verbdindung von einem Terminalprogramm aus herstellen.
Da weißt du zunächst mal, dass das Terminalprogramm auf PC_Seite 
tatsächlich funktioniert und auf der eingestellten Baudrate sendet.


>   while(1)
>   {
>     pwmlevel = usart_receive();
>   }

OK.
Das erhaltene Zeichen (was auch immer das war), wird an pwmlevel 
zugewiesen.
Nur: wie kommt es von dort ins Register OCR1A?

die PWM wird verstellt, indem du in OCR1A einen anderen Wert einträgst. 
Was du an die Variable pwmlevel zuweist, interessiert die PWM einen 
feuchten Kehrricht.

> serialPort1.WriteLine(tb_send.Text);

lass mich raten:
In die Textbox gibst du zb 198 ein, und dann erwartest du, dass sich die 
PWM auf 198 stellt.

Nope. So funktioniert das nicht.
Ein Grund mehr, dass du zunächst mal mit einem Terminalprogramm auf PC 
Seite anfängst.
So wie du den µC programmierst, empfängt der 1 Zeichen und nimmt das als 
Steuerwert für die PWM.
Schau in eine ASCII Tabelle. Jedes 'Zeichen' hat einen bestimmten Code. 
zb ist der Code für 'A' die 0x41, oder dezimal 65. Drückst du am 
Terminal daher die Buchstabentaste 'A' (großes A), dann wird der Code 65 
an den µC geschickt und die PWM stellt sich auf 65 (wenn du die 
Zuweisung richtig stellst und deine UART überhaupt funktioniert). 
Drückst du '~', so hat die den ASCII Code 0x7E oder dezimal 126. Nach 
dem Drücken der Taste stellt sich die PWM auf den Wert 126.


Aber ehe du dich auf nicht sichtbare Funktionalität verlässt (die UART 
wird schon funktionieren), solltest du deren Funktion erst mal sicher 
stellen. Sonst stocherst du schon wieder im Nebel.

Funktionen ohne Übergabeparameter müssen mit void deklariert werden:
uint8_t usart_receive( void )
{
  while
...
Nicht jeder Compiler macht das von alleine.

> Wie gesagt, die PWM läuft, jedoch lässt sich das PWM-Signal nicht
> verändern.
In der while-Schleife in main veränderst du ja auch immer nur die 
Variable pwmlevel, setzt aber das zugehörige Timer-Register nicht.

luke schrieb:

> Der nächste Schritt wär dann, dass ASCII Zeichen in eine dezimalzahl zu
> wandeln.

Nicht 'der nächste' im Sinne von irgendwann mal.
Das ist der nächste Schritt im Sinne von 'das ist jetzt zu tun'

Die System.IO-Klasse stellt für übrigens auch eine Funktion zur 
Verfügung, die dir erlaubt, ein byte oder char zu übertragen, das du 
dann natürlich auch als Hex-Wert angeben kannst.
Dann sparst du dir immerhin schon mal den Umweg beim Senden.
http://msdn.microsoft.com/en-us/library/system.io.ports.serialport.write(v=VS.90).aspx
Außerdem kannst du beim Lesen auch gleich ReadByte verwenden.

Du gehst die Sache von der falschen Seite an.
Die Umrechnung von String zu Zahl findet (sinnvoller Weise) im PC statt, 
nicht im AVR.

Außerdem: Wenn du am PC 145 als PWM-Wert angeben willst, sind das 3 
Chars, nicht eins.
Dein Ansatz auf dem Atmel würde also so einfach nicht funktionieren.

Du wirkst mir im Moment ein bisschen zerstreut. Geh dein Konzept aus dem 
ersten Software-Beitrag nochmal durch - das passt nämlich recht gut.
Es wird ein Byte vom PC zum AVR übertragen und zur Kontrolle wieder 
ein Byte zurückgeschickt.

luke schrieb:
> ASCII - Zeichen von 0-127 bekomme ich in meiner C#-Anwendung angezeigt.
> Werte darüber werden nur als '?' angezeigt. Hier liegt momentan das
> Problem.
Nein, liegt es nicht. Entschuldige ^^

Dem PC ist es egal, wie er dir das Zeichen anzeigen soll - ob als 
ASCII-Zeichen, binär, hex oder dezimal ist ihm völlig einerlei. Intern 
heißt 'A' = 0x41 = 65 immer 0b01000001.
Wichtig ist, dass du die Übertragung des einen Zeichens (= 1 Byte) 
hinbekommst und nicht ein String übertragen wird. Da kann der Compiler 
dann nämlich auch mal ein 2-Byte-Unicode-Zeichen draus machen oder einen 
NULL-Character zum Abschluss dazusenden... Hier passt ein Byte, darum 
nimmt man es auch.

Wenn die Variable am PC dann mal byte ist, gibt es die Funktionen, die 
ich dir weiter oben schon verlinkt habe, zum Senden und Emfpangen.
Zum Umwandeln des am PC im Textfeld eingegebenen Strings in ein byte 
findest du hier eine passenden Funktion:
http://msdn.microsoft.com/en-us/library/bds4fye2.aspx
Die richtige rauszusuchen überlass ich dir =)