Motor-Treiber

Hallo..

für meinen ROV bastele ich gerade an einem Motortreiber und zwar sehr einfach und Logik-Level angesteuert.
Hier meine Planung..

Bild hier  

Warum ?
Ich habe versucht, den BTS 432 direkt zu nutzen (funktionierte auch), aber es funktionierte erst wirklich gut bei 6V. Und er produzierte sehr viel Hitze..

Jetzt will ich versuchen ihn als Driver für den IRFP150N zu nutzen.
Meine Fragen:
Ist das ok und ohne große Gefahr ohne Kühlung unter Wasser nutzbar ?
Und gibts es andere Stellen, die man verbessern müsste (bin elektrotechnisch nicht so geübt - ist eine terassenschaltung in der sonne entstanden) ? O:)

Danke im Voraus !

MfG
ngb

Nein, ist so nicht wirklich sinnvoll. Den IRFP kannst Du auch direkt treiben, sämtliche Schutzfunktionen des BTS sind so ausser Kraft. Ausserdem fehlt eine Freilaufdiode. Allerdings würde ich vermuten, dass 5V für den IRFP als Vgs nicht ausreichen, zumindest nicht für vernünftig niedrigen Rds_on. Nimm lieber einen Logic-Level-MOSFET (IRLZ3x/4x, mal gucken, was Reichelt hat und dann Datenblätter wälzen, was passt)

Hallo,

was willst du mit der Kombination aus BTS432 und dem Mosfet erreichen? Der BTS432 ist zum direkten Ansteuern gemacht (und ist in diesem Fall auch ausreichend dimensioniert). Allerdings verwendet man den BTS432 normalerweise nur dann, wenn man aus irgendeinem Grund unbedingt die (positive) Versorgungsspannung und nicht Masse schalten will.

Wenn du nur die Motorleistung regeln willst und die Drehrichtung nicht geändert werden muss, dann reicht ein einfacher Logic Level Mosfet ( für diese Anwendung z.B. IRLZ34N ), der über einen Gatewiderstand (z.B. 100 Ohm) am µC angeschlossen wird. Dazu benötigt man natürlich noch eine Freilaufdiode.

Gruss
Jakob

wie/was wo willst du damit ansteuern ?
nur vorwärts - aus - rückwärts, oder getaktet ?

unter wasser geht kühlung sehr gut:
Kühlfläche elektrisch isolieren (glimmer o.ä.), und an ne metallene aussenwand setzen!
besser gehts fast nicht..

Schau dir mal den hier an:
(Wenns auch 6V sein könne, drunter geht der auch nicht wirklich=>under-voltage lockout)
http://www.conrad.de/goto.php?artikel=153814

edit:
als logic-level fet hab ich an meinem pic für pwm den
irl3803

edit2:
siehe anhang..
wenn der pin high wird, schaltet der mosfet durch, wenn low aus.
wnn der motor nen 3A stromschluck nimmt, muß der ic nat. passend entstört sein, damit er nicht abstürzt.

Hey..

danke für die antworten ..
das problem mit dem IRFP150N war bei direkter ansteuerung, dass er stark nachgelaufen ist..
ich hab den Pin auf 0 gesetzt beim µC und er ist manchmal einfach weitergelaufen (sollte ja heißen, dass das gate noch geladen ist)
ich hab dann über den BTS432 gelesen und bestellt und probiert und der schaltete den motor sofort ab..
als ich den BTS432 mit 5V betrieben habe, stellte ich fest, dass er sehr warm wurde und nur 1,3 A durchgelassen hat. also kühlkörper dran gebaut und der strom blieb derselbe.. bin allerdings auf 6V gegangen als Vcc lief der BTS432 sauber. Problem: ich werde an board des Roboters keine 6V zur Verfügung haben und will auch keine haben (klingt vielleicht blöd, ist aber so..)

mein ziel ist es, einen motortreiber zu bauen der worwärts und rückwärts und das mit pwm kann (die richtungsumkehr fehlt noch komplett [man könnte ja auch einfach zwei MOSFETs nehmen])
mit der freilaufdiode habe ich etwas gehardert..
ich will ja eingentlich keinen freilauf oder ich habe die idee dahinter falsch verstanden..

für den einen oder anderen tipp wäre ich dankbar..
ich hab viele schaltpläne im inet gewälzt, aber die haben mit viel zu viele funktionen die ich gar nicht brauche..

ein weiterer vorschlag wäre einfach den IRFP150N mit einem Treiber zu nutzen... mal sehen..

MfG
ngb

P.S.: mit welchem programm machst du diese schaltpläne ??

1. die Freilaufdiode schützt die Halbleiter vor induzierter Spannung und muss in offensichtlicher oder versteckter Form immer vorhanden sein, ob Du willst oder nicht.
2. zum Ansteuern der MOSFETs braucht Du einen Treiber, der Strom liefern wie senken kann, nachlaufen wird da nichts, wenn Du nicht systematisch falsch steuerst.
3. für eine PWM brauchst Du mehr Treiberleistung (Strom) als ein uC-Ausgang ihn liefern kann
4. für Richtungsumkehr brauchst Du vier MOSFETs oder einen plus Relais.
Das alles mag Dir nicht gefallen, wird die Technik aber nicht sonderlich interessieren. Ach ja, mit den 5V kommst Du u.U. auch nicht für alle Anforderungen aus.

1. Könnte es sein, dass der MOSFET eine freilaufdiode integriert hat ?
2. das direkte ansteuern war ja auch nur ein test.. im schaltplan den PsiQ gepostet läuft die ansteuerung ja auch direkt..
3. deshalb ja die idee mit dem BTS432 als treiber..
4. eigentlich müssten 2 reichen oder ? so wie 2 relais, von denen nur eines aktiv sein kann und die dann verdreht an den motor angeschlossen sind..

und wegen dem gefallen.... deshalb frage ich ja ob jemand ne idee hat.. und mir damit als grundlage die 5V erhalten bleibt..

MfG
ngb

#Das Programm zum zeichnen heißt "Eagle Layout Editor"
kostenlose freeware ausgabe, mit einschränkungen, die man eigentlich als anfänger nicht bemerkt ;-) (einlagige platine, begrenzte maximalgröße..)
http://www.cadsoft.de/download.htm

#sowohl der buz11
als auch der irl3803 haben eine integrierte freilaufiode,allerdings ist die langsamer als "optimal", da kann dir vorher schon der ic kaputtgehen.

#Ein vorwärts rückwärts fahrtregler funktioniert nur mit 4 transistoren/mosfets, siehe Datenblatt hier,schaltplan weiter hinten:
http://www2.produktinfo.conrad.com/d...ahrtregler.pdf

alternativ nur volle pulle vorwärts rückwärts würde mit einem mosfet und einem umpolrelais gehen (und ner freilaufiode..)

"Freilaufdiode"
Bei induktiven Lasten wie spulen, oder motorwicklungen wird durch den stromfluß ein magnetfeld induziert.
Wenn die stromzufuhr unterbrochen wird, entlädt sich das magnetfeld in umgedrehter richtung, die spule wird umgepolt. (Energieerhaltung)
Weil aber der stromkreis unterbrochen wurde, steigt die spannung solange an, bis es zu einem übertritt kommen kann.. Hochspannungsfunken.
So funktioniert auch die zündung am PKW.
Diese umgepolte spannung kann dir leicht deinen ic und sonstige schaltungsteile zerstören.

Die Freilaufiode wird so eingebaut, dass sie die umgepolte Spannung ableitet.
Die Sannung steigt dann nur noch bis zur durchlasspannung der diode
(ca 0,3 .. 0,7V je nach diodentyp) und entlädt sich dann "intern" über die diode.
Die restliche Schaltung wird nicht mehr beeinflusst.
Deswegen sollten auch an relaisspulen immer freilaufdioden verwendet werden.



#PWM am IC
Ich hab eine sitzheizungsregelung zusammengebastelt, welche mit pwm (670Hz) 2 mosfets ansteuert. über diese mosfets werden heizmatten angetaktet.

Da ich logic-level-fets (durchschalten bei 5V) wie den irl3803 benutzt habe, konnte ich den mosfet direkt an den PIC-Prozessor setzen.
aufgrund der niedrigen frequenz (eigentlich schon zu hoch für motoren)
bleibt der stromfluß aus den pic ports (mit widerstand) unter 25mA welche die ports maximal können.
Die mosfets werden trotzdem voll durchgeschaltet.
Bei Bedarf müssen die Äusgänge jeweils mit 2 transistoren ergänzt werden, über welche das mosfet gate dann abwechselnd an high und low geschaltet wird.
Somit muß der µC nur noch die transistoren ansteuern (kleiner strom), und nicht mehr den mosfet direkt.
Die Stromproblematik ergibt sich daraus, dass bei 670Hz das gate (Kapazität wie kondensator) 670 mal pro sekunde geladen und entladen werden können muß.

wenn du von 5 auf 6V gehst , ist alles viel einfacher ;-)
dann kannst du den tle5205 benutzen, hast vorwärts, rückwärts freilaufdioden,kurzschluß, überlast, übertemp etc alles mit drin, und mußt die ports nur auf high und low setzen wie du willst..
(es wäre sogar langsames pwm möglich..)

für einen ic brauchst du sowieso stabile 5V, also brauchst du mehr als 5V
..eigentlich mehr als 6V ..

warum bist du auf 5V begrenzt/fixiert?



edit:
Was für einen ic hastd du benutzt?
Für ein sicheres abschalten bei ic-crash sollte immer ein pulldwon (oder up)
widerstand eingebaut sein, welcher den mosfet/transistor ganz abschaltet,
wenn kein steuersignal anliegt.

Hey..

erstmal allen einen schönen feiertag..
ich hab mal einige der ideen umgesetzt und mir einige dioden, transistoren und den logic level mosfet IRLZ34N besorgt.
der funktioniert von der idee her auch wunderbar..
nur mein altes problem bleibt..
wenn ich den mosfet an meinen atmega8 hänge (mit 100 Ohm dazwischen), läuft der motor nicht..
setzte ich den pin auf "1" läuft der motor wunderbar an..
setzte ich den port wieder auf "0" läuft der motor weiter, bis ich den conroller eingang am mosfet direkt mit Masse verbinde und so das gate leere..
mein verdacht ist, dass der atmega den port nicht auf masse setzt sondern einfach auf gar nichts.. (wenn das geht), denn, wenn ich das richtig verstanden habe, ist das gate ja eine art kondensator und der scheint aufgeladen zu bleiben sprich keinen kontakt zu masse zu bekommen...

Für jede Art von lösungsvorschlag oder tipp wäre ich sehr dankbar, da das ganze jetzt endlich ins wasser soll... (wenigstens ein erster test)

das ist genau dasselbe problem das ich schon mit dem IRFP150N hatte und als ich dann zusätzlich den BTS432 einsetzte muss dieser das gate immer richtig geleert haben..

MfG
ngb

Hi!
Poste doch mal den Abschnitt deines Programmes, in dem du den Pin auf High bzw. Low legst. Kann ja sein das du den Pin auf Tri-State setzt statt auf Gnd (also Hochohmig statt 0V).
Das ganze kann wunderbar mit 5V funktionieren, mit der H-Brücke aus RN-Wissen ist sogar schon ne Vorlage gegeben (https://www.roboternetz.de/wissen/in...en_Ansteuerung Punkt Nummer 2). Dort einfach noch Logik Level N-MOS-FETs und P-MOS-FETs einsetzten und fertig ist die Laube!
Als P-MOS-FET sollte ein IRF7416 (gibt's bei Reichelt) ausreichen, 35mOhm bei 4,5V Vgs...zwar nur für 2,8A Dauerstrom Spezifiziert, aber die kurze Anlaufphase sollte der gut wegstecken können.
Wenn der N-FET auch im SO-8 Gehäuse untergebracht sein soll, würde ich hier den IRF7413 empfehlen.

Aber bevor es mit den Transistoren weitergeht, Poste zuerst deinen Code bzw. den relevanten Abschnitt!

MfG

also normalerweise sollte der pulldown per software funktionieren.

ich habe allerdings bisher bei meinen schaltungen mit mosfets immer noch hochohmige pulldown oder pullup widerstände mit ans gate gesetzt, um ein undefiniertes schalten zu verhindern wenn mal der ic nichts mehr macht. quasi eine analoge sicherung

also bei n-mosfets z.B. einen pulldown mit 20k
bei p-fets einen entsprechenden pullup widerstand.

so bleibt der mosfet ausgeschaltet, solange der ic nichts tut.

edit:
mit dem p-fet irf4905, reichelt glaub 1,30euro wären bei 5V gatespannung auch schon 15A möglich..
http://www.ortodoxism.ro/datasheets/irf/irf4905.pdf

als n-fet zum schalten ist der irl3803 sehr schön O:)


edit: ich seh grad, da oben hab ich das ja schonmal so etwa geschreiben :-b

Hi!
Das mit den Pullup bzw Pulldown ist ne gute Lösung um die Schaltung bei einem Fehler zu schützen, aber ne PWM kriegt man auf die Art und Weise nicht effektiv zum laufen!
Ich bin mal gespannt auf den Programmausschnitt!

Der IRF4905 bzw. IRF3803 gehen natürlich auch, wobei der IRF3803 bei Reichelt nicht erhältlich ist (das ist bei mir immer das KO Kriterium).

Bast

Reichelt hat den IRF3803 deshalb nicht, weil es keinen IRF3803 gibt ;)
Das Ding heist IRL3803 und kostet Eur 1,20 bei Reichelt.

Gruss Tobias

Hey..

Hier der Code...
Ich habe gerade nur einen etwas anderen teil zur verfügung..
der einzige unterschied ist nur, dass statt dem Ausgang mit einer LED der ausgang mit dem Gate genutzt wird (habt den code angepasst, könnte aber minimale abweichungen vom verwendeten haben - den poste ich heut abend - sorry)

Hoffe das hilft bei der lösung

MfG
ngb

Code:

---


//-----------------------------------------------------------------------------------------//
//-----------------------------------------------------------------------------------------//
//                        RS485- Implementierung mit MAX 485                              //
//                      Autor: Niels Göran Blume 2007 für ROUVus                          //
//                              www.hardegser-sv.de/rov                                  //
//-----------------------------------------------------------------------------------------//
//-----------------------------------------------------------------------------------------//
/*
  Hardware- Konzessionen:
  Atmega8 mit UART an PORTD0 und PORTD1 und Switch Receive/Send für MAX 485 an PORTD2
  Halb-Duplex
*/

/*    Protokoll- Definition:
  Das Protokoll ist auf den One-Master-Multi-Slave-Betrieb ausgelegt.
  Bei entsprechender Programmierung ist auch ein eingeschränkter
  Multi-Master-Betrieb möglich.
 
  Standard: Jede Nachricht startet mit "!".
  Es folgt die Adresse des Ziels in einem Byte.
  Nun folgen 5 Datenbytes, die beliebig gefüllt werden können (Erweiterung einfach möglich).
  Am Ende steht in der Zielmaschine ein char- Array bereit, dass alle Bytes seit dem "!"
  (sprich Adresse und 5 Datenbytes) enthält.
 
  | ! | a | L | E | D | 1 | 1 | als Beispiel...
 
  An Adresse "a" ergeht die Nachricht "LED11", was vielleicht als "LED1 auf Status 1 setzen"
  interpretiert werden könnte.
*/

#define F_CPU      16000000UL

#include <avr/io.h>
#include <inttypes.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <string.h>
#include "rs485.c"

int main(void)
{
    rs485_init();                                //USART initialisieren (8 Datenbits, no Parity, 1 Stopbit)
                                            //Baud: 19200
  DDRD = (1<<DDD2)|(1<<DDD3);                    //Output DDD2 setzen für Send/Receive- Wechsel
                                            //DDD3 für ne LED
  warte(5000);
 
  rs485_puts('a',"Melde mich zum Dienst ! Meine Adresse: b");
 
  sei();                                      //Interrupts enablen
 
  PORTD &= ~(1 << 1);                          //Gate-Port ausschalten
 
  while(1)                                    //Reaktion in Schleife
  {
      if (befehl_fertig == 1)                    //Befehl vorhanden
      {
        warte(5000);                          //Zeit damit ich den Sende-Mode am PC mit der Maus beenden kann
        if(strcmp(buffer, "bpwm11") == 0)            //Beispielkommando als Vergleichsgrundlage
        {                                   
            PORTD |= (1 << 1);                    //mit einzelnem Byte (&buffer[i]) | Gate an
        };
        if(strcmp(buffer, "bpwm10") == 0)            //Beispielkommando als Vergleichsgrundlage
        {                                   
            PORTD &= ~(1 << 1);                    //mit einzelnem Byte (&buffer[i]) | Gate an
        };
        befehl_fertig = 0;                        //Befehl abgearbeitet - Status zurücksetzen
      }
  };
}

---

Hey..

hier der richtige code..
hoffe der hilft bei der lösung

Code:

---

//-----------------------------------------------------------------------------------------//
//-----------------------------------------------------------------------------------------//
//                        RS485- Implementierung mit MAX 485                              //
//                      Autor: Niels Göran Blume 2007 für ROUVus                          //
//                              www.hardegser-sv.de/rov                                  //
//-----------------------------------------------------------------------------------------//
//-----------------------------------------------------------------------------------------//
/*
        Hardware- Konzessionen:
        Atmega8 mit UART an PORTD0 und PORTD1 und Switch Receive/Send für MAX 485 an PORTD2
        Halb-Duplex
*/

/*        Protokoll- Definition:
        Das Protokoll ist auf den One-Master-Multi-Slave-Betrieb ausgelegt.
        Bei entsprechender Programmierung ist auch ein eingeschränkter
        Multi-Master-Betrieb möglich.
       
        Standard: Jede Nachricht startet mit "!".
        Es folgt die Adresse des Ziels in einem Byte.
        Nun folgen 5 Datenbytes, die beliebig gefüllt werden können (Erweiterung einfach möglich).
        Am Ende steht in der Zielmaschine ein char- Array bereit, dass alle Bytes seit dem "!"
        (sprich Adresse und 5 Datenbytes) enthält.
       
        | ! | a | L | E | D | 1 | 1 | als Beispiel...
       
        An Adresse "a" ergeht die Nachricht "LED11", was vielleicht als "LED1 auf Status 1 setzen"
        interpretiert werden könnte.
*/

#define F_CPU      16000000UL

#include <avr/io.h>
#include <inttypes.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <string.h>
#include "rs485.c"

int main(void)
{
    rs485_init();                                                                                        //USART initialisieren (8 Datenbits, no Parity, 1 Stopbit)
                                                                                                                        //Baud: 19200
        DDRD = (1<<DDD2)|(1<<DDD3)|(1<<DDB1);                                        //Output DDD2 setzen für Send/Receive- Wechsel
                                                                                                                        //DDD3 für ne LED und DDB1 für PowerMOSFet
        warte(5000);
       
        rs485_puts('a',"Melde mich zum Dienst ! Meine Adresse: b");
       
        sei();                                                                                                        //Interrupts enablen
       
        PORTD &= ~(1 << 3);                                                                        //LED ausschalten
        PORTB &= ~(1 << 1);
       
        while(1)                                                                                                //Reaktion in Schleife
        {
                if (befehl_fertig == 1)                                                        //Befehl vorhanden
                {
                        warte(5000);                                                                        //Zeit damit ich den Sende-Mode am PC mit der Maus beenden kann
                        if(strcmp(buffer, "bled11") == 0)                                //Beispielkommando als Vergleichsgrundlage
                        {                                                                                                //später weitere zum Beispiel als Switch
                                PORTD |= (1 << 3);                                                        //mit einzelnem Byte (&buffer[i]) | LED an
                                rs485_puts('a', "led11");       
                        };
                        if(strcmp(buffer,"bled10")==0)
                        {
                                PORTD &= ~(1 << 3);
                                rs485_puts('a',"bled10");
                        };
                        if(strcmp(buffer,"bpwm11")==0)
                        {
                                PORTB |= (1 << 1);
                        };
                        if(strcmp(buffer,"bpwm10")==0)
                        {
                                PORTB &= ~(1 << 1);
                        };
                        befehl_fertig = 0;                                                                //Befehl abgearbeitet - Status zurücksetzen
                }
        };
}

---

und die rs485.c:

Code:

---

#include "rs485.h"
#define BAUD        19200UL
#define UBRR_BAUD  ((F_CPU/(16UL*BAUD))-1)

char buffer[7];
int buffer_pos = 0;
int befehl = 0;
int address = 0;
int befehl_fertig = 0;

void warte (uint16_t loop) //loop: wartezeit in ms
{
        uint16_t i;
        for(i=0;i<loop;i++) _delay_ms(1);
}

// Empfangene Zeichen werden im Buffer gespeichert und warten dort
SIGNAL (SIG_UART_RECV)
{
        char data;
        int i;
       
        data = UDR;
        if (data == '!')
        {
                befehl = 1;
                address = 0;
                return;
        }
        else
        {
                if(befehl == 1 && address == 0)
                {
                        if (data == 'b')                                                        //Unsere Adresse ?
                        {
                                buffer[buffer_pos] = data;
                                buffer_pos++;
                                address = 1;
                                return;
                        }
                        else
                        {
                                befehl = 0;
                                address = 0;
                                return;
                        };
                };       
               
                if(befehl == 1 && address == 1)
                {
                        buffer[buffer_pos] = data;
                        if (buffer_pos < 5)                                                        //Noch ein Platz frei im Buffer ?
                        {
                                buffer_pos++;                                                        //Dann Zeiger erhöhen
                                return;
                        }
                        else
                        {
                                buffer_pos = 0;                                                        //Wenn Buffer voll, reset an Anfang
                                befehl = 0;                                                                //Befehl fertig...
                                address = 0;
                                buffer[6] = '\0';
                               
                                befehl_fertig = 1;
                                return;
                        };
                };
        };
}

void rs485_init()
{
        // Baudrate einstellen (Normaler Modus)
    UBRRH = (unsigned char) (UBRR_BAUD>>8);
    UBRRL = (unsigned char) (UBRR_BAUD & 0x0ff);

    // Aktivieren des Empfängers, des Senders und des "Daten empfangen"-Interrupts
    UCSRB = (1<<RXCIE)|(1<<RXEN)|(1<<TXEN);

    // Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
    UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
}

// Um das Problem bei RS485 zu umgehen, dass nicht gleichzeitig gesendet und empfangen werden kann (2 Adern),
// nur "direktes" Senden möglich

// Einzelnes Zeichen senden
void rs485_putc (unsigned char address, unsigned char buffer)
{
        while ( !(UCSRA & (1<<UDRE)));                                //Warten bis UDR leer ist für Senden
        PORTD |= (1 << 2);                                                                //Max485 auf Senden
        UDR = '!';                                                                                //Sendungsanfang
       
        while ( !(UCSRA & (1<<TXC)));                                        //Warten bis Senden abgeschlossen
        UCSRA &= ~(1<<TXC);                                                        //Gesendet-Bit löschen
        UDR = address;                                                                        //Adresse senden
       
        while ( !(UCSRA & (1<<TXC)));                                        //Warten bis Senden abgeschlossen
        UCSRA &= ~(1<<TXC);                                                        //Gesendet-Bit löschen
        UDR = buffer;                                                                        //Daten senden
       
        warte(100);                                                                                //MAX485-Buffer leeren lassen
        PORTD &= ~(1 << 2);                                                        //Max485 auf Empfang
}

// String senden
void rs485_puts (unsigned char address, const char *s)
{
        while ( !(UCSRA & (1<<UDRE)));                                //Warten bis UDR leer ist für Senden                               
        PORTD |= (1 << 2);                                                                //Max485 auf Senden
        UDR ='!';
       
        while ( !(UCSRA & (1<<TXC)));                                        //Warten, bis Senden abgeschlossen wurde
        UCSRA &= ~(1<<TXC);                                                        //Gesendet-Bit löschen
        UDR = address;                                                                        //Adresse senden
       
        while ( !(UCSRA & (1<<TXC)));                                        //Warten bis Senden abgeschlossen
        UCSRA &= ~(1<<TXC);                                                        //Gesendet-Bit löschen
       
        while (*s != '\0')
        {
                loop_until_bit_is_set(UCSRA,UDRE);                        //warte bis Datenregister frei
                UDR = *s;                                                                        //Zeichen nach Sendedatenregister
                s++;                                                                                //Adresse erhöhen
        }       
       
        warte(100);                                                                                //MAX485-Buffer leeren lassen
        PORTD &= ~(1 << 2);                                                        //Max485 auf Emfang
}

---

und die rs485.h:

Code:

---

#ifndef _RS485_H_
#define _RS485_H_

extern void rs485_init();
extern void rs485_putc(unsigned char address, unsigned char buffer);
extern void rs485_puts(unsigned char address, const char *s);
extern void warte(uint16_t loop);

static inline void rs485_flush()
{
        while (UCSRB & (1 << UDRIE));
}

#endif /* _RS485_H_ */

---

vielen dank für alle vorschläge im voraus !

MfG
ngb

Hallo..

hat keiner einen tipp oder einen vorschlag wie man diesem problem mit dem gate herr werden könnte ?
ich hänge da ziemlich..

wäre es theoretisch und praktisch möglich das gate mit einem widerstand mit Ground zu verbinden und davon auszugehen, dass der strom erstmal das gate auflädt..
und wenn der ATMega8- Port auf 0 gesetzt wird die Ladung über den Widerstand auf Ground abfließt ?
und wie ist das mit dem erwähnten Tri-State ?
Hab gerade ein bisschen gesucht, und so wie ich das verstehe kann das nur eintreten, wenn das DDR auf "0" für den Pin gesetzt ist..
ich hab das DDR aber auf "1" für den Pin gesetzt.. (siehe Quellcode)

ich hoffe ihr habt einen keinen tipp für mich !

MfG
ngb

Dass man für die meistens getakteten Anwendungen wie PWM dedizierte Treiber einsetzt wolltest Du ja nicht hören, welchen Rat soll man Dir also noch geben? Erfinde die Physik neu!

wenn shaun sein ok gibt (?)

kannst du mit dieser TREIBERschaltung deinen port-pin entlasten..
aus/in den ic fließen dann nur ca 10mA
die transistoren haben ne verstärkung von mindestens 250..
aber das high-low muß trotzdem richtig rauskommen..

Anstatt dem mosfet kannst du auch was anderes ranhängen, das pwm signal wird so nur "verstärkt"

Die widerstände sind für 5V berechnet..

Wobei ich mich immernoch frage, wie du deinem ic entstörte 5V geben willst, wenn an der gleichen leitung dein motor hängt, alles auf 5V läuft, und du vor dem ic keinen spannungsregler mit beschaltung benutzt..

Könnte es einfach sein, dass dein ic gestört wird?

was fixiert dich auf die 5V ?
PS.:Atmega.. hab ich keine Ahnung von

Hey...

danke für die konstruktive antwort, PsiQ ...
in bezug auf den treiber habe ich ja gerade den IRLZ34N gewählt, weil der laut datenblatt ein logic-level-mosfet (=5V) ist, oder sehe ich da was falsch ?
das sollte doch heißen, dass ich den mit 5V schalten kann..
ich bin aus 2 gründen auf 5V so "fixiert":
1. ich will ein atx-netzteil als stromversorgung verwenden. diese netzteile haben nunmal einfach nur 5V und 12V (jeweils mit hohem stromfluss) und wenn ich so eins noch auf dem Dachboden liegen habe (was der fall ist), wäre es doch dämlich es nicht zu verwenden ..
2. ich habe bei fast allen schaltungen im µC bereich 5v benutzt (atmega, RS485-RS232-wandler, TCM2-modul, ...)

wenn die klare aussage ist, dass es mit einem treiber einfacher geht, dann werde ich darauf zurückgreifen, nur ich dachte eigentlich, dass ich den bei einem logic-level-mosfet weglassen könnte..
und die letzten fragen waren auch mehr des verständnisses wegen (es lebe der genitiv ;-) )..
ich hab noch nicht verstanden, warum der IRLZ34N einwandfrei schaltet, wenn ich das gate direkt mit 5V verbinde und dann zum stoppen direkt mit masse..
wenn das der µC macht (bzw. er macht es ja eher nicht), dann geht das anschalten und dann muss der die 5V vom pin nehmen, dafür aber nicht ground anlegen..
rein um grund für dieses verhalten ging es mir..
wenn es mit einem treiber einfacher geht, greif ich auf meine alte kombination BTS432 und IRFP150N zurück.. (die reicht dann mehr als aus..)

und ich habe das IC eigentlich entstört (laut tutorial - frag nicht welches..)
ich stelle heute abend mal den schaltplan online..

und bei einem stabilisierten netzteil wie einem atx-netzteil sollte es meines erachtens möglich sein, motoren und µC gleichzeitig anzuschließen..
wenn dem nicht so sein sollte, habe ich ein weiteres problem gewonnen.. (im kabel zum rov müssten dann 8 adern daten (cat5e) und 3 adern spannung (5 und 12v und ground) liegen)


MfG
ngb

P.S.
@???: ich habe keinesfalls vor die physik neu zu erfinden.. und das brauche ich auch gar nicht..
denn wenn das mit einem treiber möglich, wie sieht der denn dann aus ? da muss das ja auch funktionieren..
und wenn du findest, dass meine fragen blöd und unsinnig sind, dann ignorier sie doch einfach, aber solche antworten sind, wie auch PsiQ deutlich gemacht hat, ziemlich überflüssig..

Fragen ungeachtet der bereits gegebenen Antworten zu wiederholen auch, aber wir wollen ja trotzdem alle nett zueinander sein und daher spare ich uns auch weitere Kommentare dieser Art, ok?

Die Schaltung von PsiQ ist eine denkbare Variante eines Treibers. Die Transistoren sind als Emitterfolger geschaltet und verstärken den Strom, den der Port liefern kann, sowohl beim Ein- als auch beim Ausschalten hinreichend gut, um das Gate des MOSFET bis zu einigen kHz PWM-Frequenz schnell genug umzuladen. Die Basisvorwiderstände kannst Du zu einem einzelnen zusammenfassen und die Basen direkt verbinden, genau genommen kann er auch entfallen, dass man ihn dennoch häufig einsetzt, zielt auf Schutz des uC, Entkopplung vom Lastkreis, Vermeidung steiler Stromflanken usw ab. Also lass ihn ruhig drin.

Ich hab das @shaun ernst gemeint, weil der mehr ahnung von hat wie ich..

ob ihr euch anzickt is mir erstmal schnuppe, solangs auf hohem niveau bleibt O:)

das problem beim stören liegt ja nicht im netzteil, sondern daran, dass du zwischen netzteil und ic 5m kabel hast = widerstand, zwischen dem motor und dem ic aber nur ein paar centimeter, deswegen bekommt das netzteil das fast nichtmehr mit,der ic aber direkt..

bei den n-mosfets mußt du darauf achten, [+][last][n-fet][-] zu schalten
sonst ist der high pegel (5V) nichtmehr 5V über gnd, sondern entsprechende dem spannugnsteiler last/mosfet..
da die last im vergleich zum mosfet nen hohen widerstand hat, fällt dann am msofet nur wenig spannung ab, und an der last viel,
also last: 4,8V , mosfet 0,2V wenn falschrum, deswegen steuert der dann nicht durch.

bei meinem pic16 hats ohne treiber funktioniert

Wenn das n-fet gate auf 0 bzw gnd liegt, leitet er nicht, bei 5V über dem unteren mosfet-pin leitet er..

Wenn du 12V nimmst, und im "bot" nen 5V Regler (passt komplett auf 2cm²) , ist das besser:
Du kannst komplett frei die h-brücke wählen,
es fließt weniger strom (die hälfte) bei gleicher leistung, und du kannst den ic vor ort versorgen..

auch wenn du mit p und n-fets nen regler mit richtungsänderung machst, ist das besser, weil die fets weiter+schneller durchgeschaltet werden, weil am gate dann ja 12V anliegen, grade die p-fets haben lieber 10V

dein IC wird nicht so viel storm brauchen, dass das extra ne stromleitung lohnt..
Das PC netzteil gibts ja inzwischen für 20euro ;-) ..
Achte auch darauf, dass bei einseitger last nicht die spannung schwankt, also 5V und 12V etwas belasten, mit ner kleinen Lampe oder Lastwiderstand.. kann aber auch ohne probleme einseitig belastet funktonieren.


EDIT:
Entweder ich habs net verstanden oder inzwischen vergessen:
Was wolltest du mit dem FET machen?
den motor direkt ansteuern, oder die rs-motor-h-brücke?
Nur zum ansteuern ist der fet zu teuer, die transistoren kosten mit widerständen grad mal 25cent der mosfets über nen euro.. das wäre plöt..

@shaun: abgehakt..
@PsiQ: also ich bin davon ausgegangen, dass ich nen mosfet als leistungsschalter brauche aber wenn das auch mit einfachen transistoren geht.. um so besser..
also das ziel war einen motor-"treiber" zu basteln (insgesamt werde ich 5 brauchen), der mir die motoren für den bot schalten kann..
in luft ohne last haben die motoren nen anlaufstrom von ~2,5A und dann in leerlauf 1,3A..
ich werde das wochenende nutzen um einen unter wasser test durchzuführen..
und werde ich wohl erstmal das netzteil umbauen müssen, da mein labornetzteil nur bis zu 3 A liefert und ich mal davon ausgehe, dass ich unter wasser nen höheren strom brauchen werde..
vielleicht sollte ich mal motoren suchen, die für den schiffsmodellbau gedacht sind.. die dürften mit stevensrohr und prop schon mal besser geeignet sein als ein einfacher pollin-simpel motor

und genau dieser höhere unterwasserstrom war auch der grund für mich gleich auf einen leistungsschalter zu gehen..
wenn ich das richtig sehe, sollte ich aber bei einer transistoren h-brücke keine unterscheidlichen transistoren brauchen oder (also nicht npn und pnp) ?

eine frage noch: meinst du, PsiQ, jetzt mit "nur zum ansteuern" die motor- direkt-ansteuerung oder die rs-motor-h-brücke ?

MfG
ngb

So wie ichs gezeichnet habe, mit dem N-fet, steuerst du den Motor direkt an. Die LAST also der Strom den der Motor braucht fließt über den Mosfet.

Wenn du eine H-Brücke hinter die Treiberstufe setzt, mußt du keinen FET da einsetzen, weil die Last ja von der H-Brücke getragen wird, und nicht von dem FET, dann tuts auch nur die treiberstufe. in dem Fall läuft der Laststrom über die Transistoren/Mosfets in der H-Brücke.

Wegen der H-brücke ..
der tle5202 würde bei 6V+ immernoch reichen, ist allerdings wegen der langsamen schaltgeschwindigkeit laut forumsvermutungen nur bis 100hz pwm geeignet.. was für nen motor aber auch reicht..

Conrad hat da nen Fahrtregler im angebot, da sieht man die H-brücke im Schaltplan (Datenblatt):
http://www.conrad.de/goto.php?artikel=245232
Siehe anhang, so sieht der Aufbau aus, in sachen "gegen"transistor

Wenn du vorwärts/rückwärts mit nem miniatur 2xUmpol relais umschaltest, brauchste das nicht, dann reicht der FET und das relais vor dem motor.. Die Freilaufiode bleibt vor dem Relais um die Elektronik zu schützen..

EDIT:
Lesbarkeit verschönert
Bild vergrößert


edit2:
Frage @shaun: sehe ich das richtig, dass man den regler von conrad leicht pimpen könnte, wenn man die transistoren durch mosfets ersetzt ?
Im datenblatt des steuer ic steht da was von
Output source current 200mA, sink current 500mA MAX..
ah, nee, müsste nochmal n treiber dazwischen, der macht nur 3,8V als high pegel, das is bissken wenig fürn mosfet ;-)