Projekt Mähroboter

[Feuerring]

Hallo zusammen,

würde gerne mein Projekt Mähroboter ( Planung und Umsetzung ) hier vorstellen, derzeit bin ich noch in der Planungsphase ...

Habe in den letzten Wochen viel Zeit damit verbracht, die Projekte von den Pionieren hier im Forum und im RN-Wissen zu studieren.

Zu meinem Projekt:

- Mähroboter

31764 31763
Um möglichst gut in die Ecken zu kommen haben ich mich entschieden vorn zwei Mähwerke zu setzen,
dazwischen ein Servo-gelegtes Rad 100 mm, hinten ein drittes Mähwerk.
Als antrieb kommen hinten zwei 260 mm Räder, die getrennt angetrieben werden.
Je nach Einschlag der Lenkrolle werden die Antriebsmotoren unterstützend verschieden stark angetrieben.
Die drei Mähwerke sitzen auf einer Trägerplatte, diese kann zur Grundplatte in verschieden höhen arretiert werden.
Die Akkus kommen hinten unter die Grundplatte bei der Achse, um den Schwerpunkt möglichst tief zu halten ...

- Schleifen-Begrenzung

In Anlehnung an der Schaltung Begrenzungsschleife_-_Induktionsschleife (http://rn-wissen.de/wiki/index.php?title=Begrenzungsschleife_-_Induktionsschleife)
habe ich mir folgendes Überlegt:
31765
Ein Netzteil lädt über einen Widerstand ein Hochstrom-Kondensator, dieser wird über einen MOS-FET an die Schleife gelegt,
je nach länge (ca. 100m) und Durchmesser (1-1,5 mm²) soll ein Strom (Piek) von 10-20 Ampere durchfieseln,
durch die Entladung des Kondensator aber rech schnell dann zusammenbrechen und nicht stetig anliegen,
ich möchte damit die Induktive Rückenbespannung in der Empfängespule minimieren.

- Positionserkennung auf der Begrenzungs-Schleife
Ich möchte an /auf der Schleife Fix-Punkte positionieren, die eine Orientierung des Bot zu erleichtern.
eine erste Überlegung war an wichtigen Poritionen IR-Sender in den Boden einzulassen und am Bot-Boden ein IR-Empfänger.
Eine andere Überlegung ist es den Induktions-Draht mit zwei-drei Windungen 90° dreht zur Induktionsschleife darunter zu positionieren,
ein waagerecht dazu aufgerichteter Empfänger(Spule) kann so beim Überfahren dessen Ausrichtung ermitteln ...
Der Bot bekommt 6 bzw 7 Empfänger(Spulen) für die Induktionsschleife 2x vorn, 2x Mitte und 2x hinten und eine in der Mitte(waagerecht ausgerechtet) um die Fix-Punkte zu erkennen.
Die 6 Empfänger an den Ecken / Mitte sollen nicht nur detektieren ob der Empfänger(Spule) innerhalb oder außerhalb sich der Schleife befinden, sondern bei der Schleifen-Fahrt auch den Draht genau mittig durch die Feldstärke ermitteln / positionieren.
31766

- Funktionen
Der Bot bekommt eine Funkstrecke zu einem PC (Server 24x7) um seine Aktivitäten / Positionen zu übermitteln, von dort bekommt er auch seine Befehle, wie dieser wo und wie zu mähen hat (Mähprogramme)
Der ganze Bot bekommt eine Gummi-Puffer gelagerte Haube die knapp bis zum Boden reicht, um ein anstoßen ringsum bzw. ein anheben zu detektieren.

Die Ladestation wird durch ein FIX-Punkt auf der Begrenzungs-Schleife angezeigt und soll dann Rückwarts angefahren werden ...

Das ganze soll ein Winter-Projekt werden und im nächsten Jahr(Sommer) seine Dienst leisten ...

Gruß Ralf

- - - Aktualisiert - - -

hier noch mal die Bilder ...

[Rabenauge]

Erster Kritikpunkt: das Dreirad.
Das Ding wird sich in jedem Mauseloch recht zuverlässig fest fahren.
Bei anderen Unebenheiten hast du dann öfter mal die Messer im Dreck- ich hab _einmal_ mit nem dreirädrigen Mäher arbeiten "dürfen"- nach ner Stunde war ich mit dem Ding durch.

[Feuerring]

Hallo Sly,

in der ersten Planung habe ich ein 100 mm Rad mit entsprechender Breite 3-4 cm vorgesehen, irgendwas mit Vollgummi und Profil, soll ja auch zum lenken verwendet werden.

wenn ich vorn zwei Lenkräder verwendet Zeichnung (3) verliere ich die Möglichkeit beim mähen vernünftig in die Ecke zu kommen ...
mein Rasen ist bereits mit einer 10cm breiten Mähkante eingefasst ... durch den Schleifen-Draht und einer Rand-Mäh-Funktion möchte ich mir ein nachschneider der Ränder ersparen.

In der Zeichnung (2) habe ich meinen ersten Entwurf Zeichnung (1) noch mal angepasst, grösseres Lenkrad (Mitte) ca. 140 und zwei kleinere Mähwerke vorn,
das Mähwerk in der Mitte muss dann aber grösser werden ... die Mähwerke kommen auf eine eigene Trägerplatte, so kann ich auch später noch Anpassungen vornehmen,
ohne gleich den ganzen Bot neubauen zu müssen, er Bot wird erstmal ohne Mähwerk / Trägerplatte aufgebaut ohne die aber aus den Augen zu verlieren.
Als erstes muss der Bot vernünftig fahren und die Schleife (Begrenzung) erkennen und auch dieser optimal folgen können ...

31777

Bin auch am Überlegen das nicht angetriebene Lenkrad als Referenz-Rad für Wegstrecken Ermittlung mit zu nehmen.

[Feuerring]

Bin gerade dabei das Lenkrad und dessen Lenk-Antrieb zu planen ...

es gibt mehrere Möglichkeiten:

1. DC-Schnecken-Getriebe-Motor und ein Poti um die Position des Rades zu ermitteln.
2. Schritt-Motor mit Planeten-Getriebe und einem RNST01-I2C / L289 Treiber.

Ich benötige einen Lenkwinkel von 180° (+/- 90°) während der Fahr sollte so gut wie keine Kräfte auf den Lenk-antrieb wirken.
Die Stellzeiten bei 180° werde ich mit max 2 Sekunden ansetzen / 30-40 RPM am Getriebeausgang.

Bin gerade noch die vor und nachteile abzuwiegen und dabei noch unschlüssig ...

Vor und Nachteile:
Lösung (1a) DC-Motor mit Poti und einem M51660L als PWM-Positions-Treiber ... bin mir aber nicht sicher wie die PWM-Auflösung für ein Servo dann damit ist.
Lösung (1b) DC-Motor mit Poti und einem MC33030 als -Treiber der vergleicht zwei-Spannungen(Poti und z.B. ein DA-Ausgang) und stellt danach den Motor über eine H-Brücke
Lösung (1C) DC-Motor mit Poti direkt von der CPU über eine H-Brücke gesteuert und einem analogen Eingang um das Poti abzufragen

Zu Lösung(2) exakte Positionierung, benötigt aber immer einen Haltestrom und muss auch immer mal wieder per Endschalter justiert werden, wegen möglicher Schrittverluste ...

Favorisiere derzeit noch 1b

[damfino]

Bei dem Design hast das meiste Gewicht auf dem Lenkrad. Das wird bremsen, einsinken, und die Antriebräder drehen durch.

Absolut kein Schutz vor den Messern möglich, wenn der dir über die Zehen fährt macht er sofort Hackfleisch.
Bei Robotern sollte man mehr Sicherheit als bei normalen Rasenmähern vorsehen, man weiß nie was zB Besucher machen.

Zum lenken nimm doch ein Modellbauservo...

[Feuerring]

Hallo damfino,


besten Dank für die Anregungen ...


Bei dem Design hast das meiste Gewicht auf dem Lenkrad. Das wird bremsen, einsinken, und die Antriebräder drehen durch.

hinten zwischen den Rädern kommen die Akkus, die kann ich so verschieben, so das das Lenkrad optimal belastet wird, ein gewisser Druck ist aber auch von Nöten.



Absolut kein Schutz vor den Messern möglich, wenn der dir über die Zehen fährt macht er sofort Hackfleisch.

Das ist natürlich klar, um die Mähwerke hatte ich vor eine Reihe von langen 4M Schrauben an der Mäh-Trägerplatte zu schrauben ... so eine Art von Kamm,
so lang das die Messer dahinter laufen, der ganze Bot bekommt ein Cover, der bis knapp über den Boden reicht und auf Verschiebungen zur Grundplatte reagiert.

Also auf anstoßen an allen Seiten, anheben oder auffahren reagiert ...


Zum lenken nimm doch ein Modellbauservo
Darüber habe ich schon nachgedacht, möchte aber an der Achse, das Lenkrad direkt befestigen, dafür sind diese Servos nicht ausgelegt ...


Üpdate ...

habe mir heute Gedanken über den Antrieb gemacht ...

31782
Hatte erst für die Hinterräder einen Scheibenwischer-Motor mit Schnecken-Getriebe in betracht gezogen,
hat aber nachteile in der symmetrischen Befestigung, desweiteren müssen die beiden Motore immer in entgegen gesetzter Richtung laufen und das tuen Sie nun mal mit unterschiedlicher Leistung ...

Nach längerem suchen habe ich einen Faulhaber-Motor mit Getriebe und Encoder (Servo-Motor) gefunden.
Jeder der Beiden Motoren hat 12V und 17W mit 120 U/min , der Inkrementale AB-Drehgeber liefert dabei 768 CPR an der Antriebswelle.
Die Räder(26cm) werden über eine Kette mit einer Untersetzung von 40/8 angetrieben ...

So ist bei 100% Motor-Leistung eine Geschwindigkeit von 19,6 Meter / Minute bei einem Drehmoment von ca. 8,5 Nm möglich.
Die Geber-Auflösung ergibt sich dabei mit 4706 Impulse / Meter.
Die Inkremental-Drehgeber will ich zu einem für die Wegstrecken Ermittlung verwenden und eins der beiden Signale um die Drehzahl des jeweiligen Motor zu regeln ...

Das Lenkrad 120-125 mm bekommt noch einen zusätzlichen Inkrementalen AB-Drehgeber mit einer Auflösung von 400 CPR was auf einen Meter dann 1062 Impulse / Meter ergibt und so unabhängig vom Antrieb funktioniert.

[damfino]

Habe den Akku hinter den Rädern, und trotzdem fast zu viel Gewicht auf den Vorderrädern.

Die Kette muss gekapselt werden, es ist unglaublich was sich alles an Schmutz und Staub sammelt.


Darüber habe ich schon nachgedacht, möchte aber an der Achse, das Lenkrad direkt befestigen, dafür sind diese Servos nicht ausgelegt ...
Dafür ist die Achse eine DC Motors aber auch nicht geeignet. Die zulässigen Axiallasten sind meist recht gering.
Daher besser die Lenkachse massiv ausführen und lagern, daran kann man immer noch den Servo anflanschen

[Feuerring]

Habe den Akku hinter den Rädern, und trotzdem fast zu viel Gewicht auf den Vorderrädern.
Gehe mal davon aus, das Du Schleppräder vorne hast, da mag es bei zu viel Gewicht störend sein,
denn die müssen ja immer in Ihre Richtung gedrängt werden, bei ungünstiger Stellung benötigt man da sehr viel kraft.


Die Kette muss gekapselt werden, es ist unglaublich was sich alles an Schmutz und Staub sammelt.
Danke für den Tipp, muss ich in meiner Planung mit einbeziehen ...


Dafür ist die Achse eine DC Motors aber auch nicht geeignet. Die zulässigen Axiallasten sind meist recht gering.
Daher besser die Lenkachse massiv ausführen und lagern, daran kann man immer noch den Servo anflanschen

Möchte den Aufwand natürlich so gering wie Möglich halten, habe einen Winkel-Getriebemotor mit zweifach gelagerter 10mm Welle in der Auswahl,
werde aber das Lenkrad als Modul auslegen, Falls doch eine Nachbesserung von Nöten ist ...

[Feuerring]

Update ...

habe heute meine beiden Funk-Module (HC-11 433MHz (https://www.roboter-bausatz.de/136/hc-11-433mhz-funkmodul-seriell-rs232-uart-transceiver)) bekommen und gleich mal ausprobiert,
Aus meinem Büro im Haus, habe ich die Funkverbindung über das gesamte Grundstück ausgetestet und mit einem mobilen Modul alles abgelaufen ...

Später soll der Funk-Transmitter für den PC dann draußen am Haus (Grundstück-Mitte) angebracht werden, um eine 100% Abdeckung zu gewährleisten.

Habe aber Probleme mit dem SET-Mode ... wollte mal mit der Einstellung der Kanäle spielen ,
also Funk-Modul Pin(5) auf GND gelegt, dann an das entsprechende Modul über die TTL-Schnittelle AT bzw ATV gesendet ... keine Reaktion

Sobald ich Pin(5) wieder auf HIGH schalte, funktioniert das Modul nach wie vor und kommuniziert mit dem anderen und überträgt bzw. empfängt Daten ...

Hat da einer einen Tipp für mich ... was mache ich falsch

[Feuerring]

Update ...

habe mir mal Gedanken über die Module und dessen Funktionen / Verkabelung gemacht ...

31786

Ist nur erst mal ein Grund-Konzept ... Details folgen dann bei der Umsetzung.

Es wird eine MASTER_STOP_Leitung geben, wird diese auf LOW gezogen schalten alle Motor_Treiber ab,
diese Leitung kann dann von verschiedenen Modulen auf LOW gezogen werden ( NOT-AUS-Taster / Cover wird angehoben / Störung im System usw. )

Die Stromversorgung der verschiedenen Module (Nano) kann vom Master abgeschaltet werden z.B. Standby in der Ladestation / neustart bei Störung ...

Der Master bekommt ein Watchdog und muss auch im Standby immer laufen, die Verbindung zum PC ist zwingend, bei einem Time-out geht der Bot in Standby ...

[Feuerring]

Update ...

im Anhang noch mal das Grund-Konzept in einer besseren Auflösung.

Beschreibung der Baugruppen (Module) von links nach rechts

Lenk-Modul:
Nano als I2C-Slave

schreiben 1 Byte ' Drehrichtung und Winkel vom Lenkrad

76543210
Rwwwwwww

R = Richtung 1=Rechts / 0=Links
w = Wert als Winkel 0-90°


lesen 4 Byte ' Raum-Koordinate x / y 16Bit 65535 x 65535 cm ( +/- 320m )

Antrieb-Modul
Nano als I2C-Slave

schreiben 2 Byte

76543210 | 76543210
Raaaaaaa | Rbbbbbbb

R = Richtung 0=vorwärts / 1=Rückwärts
a = Motordrehzahl geregelt (linker-Motor) 0-127 / 0-100%
b = Motordrehzahl geregelt (rechter-Motor) 0-127 / 0-100%

bei Motordrehzahl =0 Motor-Brake

Weg-Strecke-Modul
Nano als I2C-Slave

lesen 6 Byte ' Zähler 24 Bit je Motor +/- 8388608 mm (~ +/- 8300m)

76543210 | 76543210 | 76543210 | 76543210 | 76543210 | 76543210
Vaaaaaaa | aaaaaaaa | aaaaaaaa | Vbbbbbbb | bbbbbbbb | bbbbbbbb

V = Vorzeichen 1=Negativ 0=positiv
a = 23 Bit Wert Motor(links)
b = 23 Bit Wert Motor(rechts)

schreiben 4 Byte ' Weg-Vorgabe 16Bit je Motor als Interrupt-Ausgang
76543210 | 76543210 | 76543210 | 76543210
aaaaaaaa | aaaaaaaa | bbbbbbbb | bbbbbbbb

a = 16 Bit Wert Motor(links)
b = 16 Bit Wert Motor(rechts)
Wert = 0 kein Interrupt, ansonsten wird ein Interrupt ausgegeben wenn ein Wert als Differenz erreicht wird

Mähwerk-Modul
Nano als I2C-Slave

Ansteuerung der Burshless-Treiber mit Drehzahlregelung und Sense für Strom

schreiben 1 Byte
76543210
abcwwwww

a = Mähwerk_1 vorn_links 1=an 0=aus
b = Mähwerk_2 vorn_rechts 1=an 0=aus
c = Mähwerk_3 Mitte 1=an 0=aus
w = Wert 0-31 Drehzahl-Vorgabe für alle Motoren

lesen 3 Byte ' je Motor 8Bit Status / Strom

Schleifen-Modul
Nano als I2C-Slave

lesen 8 Byte ' Status und Feldstärke
76543210 | 76543210 | 76543210 | 76543210 | 76543210 | 76543210 | 76543210 | 76543210
xxiiiiii | xxaaaaaa | P1111111 | P2222222 | P3333333 | P4444444 | P5555555 | P6666666

x = nicht verwendet
i = 1= Sensor in der Schleife 0= Sensor nicht in der Schleife
a = 1= Sensor außerhalb der Schleife 0= Sensor nicht außerhalb der Schleife
p = Polarität 0=positiv 1=negativ
1-6 = Wert Feldstärke 0-127 für jeden Sensor
zum einfachen erkennen der Schleife brauchen nur die ersten beiden Byte eingelesen werden
für die exakte Schleifen-Fahrt können noch die weiteren 6 Byte für die Feldstärke der Sensoren eingelesen werden.

Master-Modul
Nano als I2C-Master

Steuert die I2C-Slave_Module und hält die Verbindung zum PC
Führt Remote-Befehle vom PC halbautomatisch aus, bzw. Funktion Zufall-mähen / Schleifen-Rand-Fahrt(mähen) Vollautomatisch aus

jedes I2C-Slave-Modul bekommt ein Interrupt-Ausgang dieser wird einzeln oder als Sammelleitung vom Master abgefragt,
um so schnell auf Events der Slave zu reagieren ohne diese permanent über I2C zu pollen ...

PCF 8574 (I2C)
Zusätzliche Ein / Ausgänge für den Master

Der BOT bekommt als Eingabe ein Schlüssel-Schalter EIN-AUS-Reset und einen NOT-AUS-Botton,
als Ausgabe nur ein paar Status-LEDs und einen Summer(Hupe)

Zusätzliche Funktionen
z.B. Abstandsmessung können durch zusätzliche Module (I2C) problemlos nachgerüstet werden ...

Durch den Aufbau mit I2C-Nano-Modulen, kann ich die Einzelnen Funktionen am PC über einen I2C-Adapter super in Ihrer Funktion testen und fertig programmieren,
es werden auch so Zeitkritische Funktionen voneinander getrennt ...








- - - Aktualisiert - - -

Teil_Bilder Grund-Konzept ...

[Feuerring]

Update ...

habe mich heute mit der Motor-Ansteuerung befasst ... Es funktioniert auf jeden Fall schon mal ...

noch über die RS232 angesteuert, später über I2C-Slave ...

Mit den Gebern am Motor wird die Drehzahl über die Interrupt-Eingänge INT0 / INT1 und den Timer0 erfasst ( Frequenzmessung ).

Über RS232 kann ich die Geschwindigkeit Test-weise vorgeben (0 / 25 / 50 / 100 / 130 )

Der Motor-Treiber wird über ein PWM angesteuert und entsprechend nachgeregelt ... da muss ich aber noch mal ran und die Beschleunigungskurve anpassen ...

Da ich Bascom und Nano Neuling bin hat es mich doch schon ein wenig gefordert ... zum Einstieg genau das richtige





' ------------ Bascom - Parameter ------------------------$regfile = "m328pdef.dat"
$crystal = 16000000
$hwstack = 100
$swstack = 100
$framesize = 100
$baud = 19200


Print "Start_Main"


' ------------ Timer_0 ------------------------
Config Timer0 = Timer , Prescale = 256
On Ovf0 Tim0_isr
Enable Timer0


' ------------ PWM (Timer_1) -------------------
Config Portb.1 = Output
Config Portb.2 = Output
Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 64


' ------------ RS232 - Input ------------------------
Config Serialin = Buffered , Size = 40


' ------------ DIM ------------------------
Dim Na As String * 30 'RS232-Input-String
Dim Si As Byte 'RS232 Input
Dim Z0 As Integer
Dim Z1 As Integer
Dim Z0x As Word
Dim Z1x As Word
Dim Tx As Byte
Dim Tmx As Byte
Dim P1 As Byte
Dim P2 As Byte
Dim V1 As Word
Dim V2 As Word


' -------- Interrupt
Config Int0 = Falling
Config Int1 = Falling
Enable Int0
Enable Int1
On Int0 Int0_sub
On Int1 Int1_sub


Enable Interrupts

' -------- Hauptschleife ----------------------
Print "Start_Main Hauptschleife"
Do
' Hauptschleife
If Ischarwaiting() <> 0 Then
Si = Inkey()
If Si <> 13 And Si <> 10 And Len(na) < 30 Then
Na = Na + Chr(si)
Else
If Ucase(na) = "STATUS" Then
Print "ACK;STATUS"


Print "Status Z0x=" ; Z0x ; " Z1x=" ; Z1x
Elseif Ucase(na) = "ON" Then
Print "ACK;ON"
Print "ON;"
Elseif Ucase(na) = "OFF" Then
Print "ACK;OFF"
Print "OFF;"
Elseif Ucase(na) = "0" Then
Print "ACK"
V1 = 0 : V2 = 0
Print "V= " ; V1
Elseif Ucase(na) = "25" Then
Print "ACK"
V1 = 25 : V2 = 25
Print "V= " ; V1
Elseif Ucase(na) = "50" Then
Print "ACK"
V1 = 50 : V2 = 50
Print "V= " ; V1
Elseif Ucase(na) = "100" Then
V1 = 100 : V2 = 100
Print "V= " ; V1
Elseif Ucase(na) = "130" Then
V1 = 130 : V2 = 130
Print "V= " ; V1
Else
Print "NAK;" ; Na
End If
Na = ""
End If
End If
Loop


Tim0_isr:
' ---- Timer_0
Incr Tx


If Tx > 31 Then
Tx = 0
Incr Tmx
Z0x = Z0
Z0 = 0
Z1x = Z1
Z1 = 0


If V1 < Z0x And P1 < 255 Then
P1 = P1 + 5
End If


If V1 > Z0x And P1 > 0 Then
P1 = P1 - 5
End If


If V2 < Z1x And P2 < 255 Then
P2 = P2 + 5
End If


If V2 > Z1x And P2 > 0 Then
P2 = P2 - 5
End If


Compare1a = P1
Compare1b = P2


End If


If Tmx > 9 Then
Print "Status Z0x=" ; Z0x ; " Z1x=" ; Z1x ; " P1=" ; P1 ; " P2= " ; P2
Tmx = 0
End If
Return
Return




Int0_sub:
Incr Z0
Return
Return




Int1_sub:
Incr Z1
Return
Return

[Feuerring]

Update ...

bin einen guten Schritt weiter gekommen ...

Das Antriebs-Modul ist weitgehend fertig, Das Modul wird wie alle anderen Module dann auf eine BUS-Platine gesteckt,
dadurch kann ich flexibel auch spätere Erweiterungen nachrüsten.

31843 31844 31845

Meine Test-Umgebung:
31846 31847

Das Modul steuere ich derzeit über einen IO-Warrior (I2C) und dem Programm All-In-One,
zur Auswertung von Parametern nehme ich die RS232-Schnittstelle und einem einfachen eigenen PC-Programm.

Das Antriebs-Modul steuert die Motoren über Treiber-Module per PWM/DIR/Brake,
die Drehzahl und Drehrichtung der beiden Motore wird über die Tacho-Einheit ausgewertet.

Dank der Hilfe im Bascom-Forum, konnte ich recht schnell die TWI-Hardware-Lösung ohne LIB umsetzen ... siehe hier (http://bascom-forum.de/showthread.php?7298-I2C-Slave-LIB-auf-einem-Nano(ATMega328p)-nutzen)

Das Modul wird wie folgt über TWI(I2C) angesprochen

schreiben:
ADR|Mode|W1|W2|Wn
lesen:
ADR|Mode|R1|R2|Rn

Funktionen
Mode=0 ( schnelles bremsen ) ... funktioniert sicher
schreiben:
ADR|00 ... beide Motoren fahren schnell Ihre Drehzahl runter
lesen:
ADR|00|FF ... keine Daten außer Mode, Rest wir mit FF gefüllt

Mode=1 ( Speed ) ... funktioniert sicher
schreiben:
ADR|01|DR|V0|V1 ... beide Motoren werden beschleunigt bzw. abgebremst um auf die vorgegeben Drehzahl zu kommen und halten diese konstant.
lesen:
ADR|01|DR|V0|V1|P0|P1
DR = Drehrichtung 1= Motor_0 rückwärts / 2=Motor_1 rückwärts / 0= vorwärts beide / 3= rückwärts beide ... kann nur bei stehenden Motoren geändert werden
V0 = Drehzahl-Vorgabe Motor_0 0=Null / 150 = 7500 U/min ( Werte für die Faulhaber-Motoren)
V1 = Drehzahl-Vorgabe Motor_1 0=Null / 150 = 7500 U/min ( Werte für die Faulhaber-Motoren)
P0 = PWM-Wert Motor_0 ( nur lesen )
P1 = PWM-Wert Motor_1 ( nur lesen )

Mode=2 ( Strecke) .... noch nicht implementiert ... eine Wegstrecke wird mit Vmax gefahren ... auch Kurven oder drehen ist möglich.
schreiben:
ADR|02|DR|VM|S0|S0|S1|S1
lesen:
ADR|02|DR|VM|V0|V1|P0|P1

DR = Drehrichtung 1= Motor_0 rückwärts / 2=Motor_1 rückwärts / 0= vorwärts beide / 3= rückwärts beide
VM = Vmax
S0 = Strecke für Motor_0
S1 = Strecke für Motor_1

.....
zischen den Mode-1 und Mode-2 kann nicht direkt umgeschaltet werden nur über Mode-0 ... je nach Mode kann auch nur die dafür vorgegeben Werte gelesen werden.

ist das Modul am beschleunigen oder bremsen oder fährt die vorgegeben Wegstrecke wird die Leitung Ready auf LOW gelegt,
so muss der Master nicht immer über I2C pollen.

Wird die NOT-AUS-Leitung (BUS) auf LOW gelegt werden die Motoren über die Gatter sofort deaktiviert und das Modul fährt die Werte intern runter.

-----

derzeitiger Code:


' Projekt Mäh-Roboter
' R. Greinert
' (CC) 07 / 2016
'
' Antrieb_Steuerung Ver.008
'
'
' ------------ Bascom - Parameter ------------------------
$regfile = "m328pdef.dat"
$crystal = 16000000
$hwstack = 100
$swstack = 100
$framesize = 100
$baud = 19200


Print "Start_Main"


' ------------ Timer_0 Zeitvorgabe ------------------------------
Config Timer0 = Timer , Prescale = 256
On Ovf0 Timer0_ovf
Enable Timer0


' ------------ Output ------------------------------
Config Portb.0 = Output ' Ready-Leitung
Config Portb.3 = Output ' DIR Motor_0
Config Portb.4 = Output ' DIR Motor_1
Config Portb.5 = Output ' Herzschlag
Config Portd.4 = Output ' Break Motor_0
Config Portd.5 = Output ' Break Motor_1
Config Portd.7 = Output ' I2C-Data-Anzeige


Portb.0 = 0 ' NOT-Ready = LOW
Portb.3 = 0 ' DIR Motor_0 0=vorwärts 1=Rückwärts
Portb.4 = 0 ' DIR Motor_1 0=vorwärts 1=Rückwärts
Portd.4 = 0 ' Break Motor_0 low-aktiv
Portd.5 = 0 ' Break Motor_1 low-aktiv
Portd.7 = 1 ' I2C-LED aus


' ------------ Input ------------------------------
Config Pinc.2 = Input ' Motor_0 Decoder Q2
Config Pinc.3 = Input ' Motor_1 Decoder Q2
Config Pinc.0 = Input ' Abfrage NOT-AUS LOW-Aktiv
Config Pinc.1 = Input ' Abfrage RS232-Enabled


' ------------ PWM ----------------------
Config Portb.1 = Output ' PWM Motor_0
Config Portb.2 = Output ' PWM Motor_1
Portb.1 = 0
Portb.2 = 0
Config Timer1 = Pwm , Pwm = 8 , Compare_a_pwm = Clear_up , Compare_b_pwm = Clear_up , Prescale = 64


' ------------ RS232 - Input ------------------------
Config Serialin = Buffered , Size = 40


' ------------ I2C-Slave ------------------------
Dim Twi_status As Byte
Dim Twi_control As Byte
Dim Twi_dn As Byte


Twsr = 0
Twdr = 255
Twar = 180
Twcr = &B11000100


' ------------ DIM ------------------------
Dim Na As String * 30 ' RS232 Input-String
Dim Nax As String * 30 ' RS232 Input-UCASE-String
Dim Si As Byte ' RS232 Input Zeichen
Dim Z0 As Integer ' Zähler Motor_0
Dim Z1 As Integer ' Zähler Motor_1
Dim Z0x As Word ' Zähler cache Motor_0
Dim Z1x As Word ' Zähler cache Motor_1
Dim Tx As Byte ' Zähler ms
Dim Tmx As Byte ' Zähler sec
Dim P0 As Byte ' PWM_Motor_0 Stellwert
Dim P1 As Byte ' PWM_Motor_1 Stellwert
Dim Px As Byte ' Temp-Wert Stellwert_diff soll
Dim Pt As Word ' Temp-wert Stellwert_diff Ist
Dim Vx As Integer ' Temp-Wert Drehzahl_Diff
Dim V0 As Byte ' Vorgabe Drehzahl Motor_0
Dim V1 As Byte ' Vorgabe Drehzahl Motor_1
Dim R_0 As Byte ' Vorgabe Richtung Motor_0
Dim R_1 As Byte ' Vorgabe Richtung Motor_1
Dim Sx As Boolean ' Ready 1=fertig 0=atwork
Dim S0 As Long ' Streckenzähler Motor_0
Dim S1 As Long ' Streckenzähler Motor_1
Dim Xmode As Byte ' Funktion-Mode 0=Stop 1=Speed 2=Strecke
Dim Xt1 As Byte ' temp1
' ------ Split -------
Dim Sb As Byte ' Split_Zähler
Dim Sbx(5) As String * 10 ' Split_Array


' -------------- Declare Sub ----------------




' -------------- Interupt-Eingänge ----------------
Config Int0 = Falling ' Motor_0 Decoder Q1
Config Int1 = Falling ' Motor_1 Decoder Q1
Enable Int0
Enable Int1
On Int0 Int0_sub
On Int1 Int1_sub


Enable Interrupts


Print "Start_Hauptschleife"
Do
' --------------- Hauptschleife ------------------
If Ischarwaiting() <> 0 Then
Si = Inkey()
If Pinc.1 = 0 Then ' abfrage ob rs232 enabled
If Si <> 13 And Si <> 10 And Len(na) < 30 Then
Na = Na + Chr(si)
Else
Nax = Ucase(na)
Sb = Split(nax , Sbx(1) , "|")
Print Sb
If Nax = "STATUS" Then
Print "ACK|STATUS"
Print "Status|Z0x=" ; Z0x ; "|Z1x=" ; Z1x


Elseif Nax = "STOP" Then
Xmode = 0
Print "ACK|STOP"
Elseif Left(nax , 5) = "SPEED" Then
If Sb = 5 Then
Print "ACK|SPEED"
Xmode = 1
R_0 = Val(sbx(2) )
V0 = Val(sbx(3) )
R_1 = Val(sbx(4) )
V1 = Val(sbx(5) )
Else
Print "NAK|" ; Na
End If
Else
Print "NAK|" ; Na
End If
Na = ""
End If
End If
End If


' ----------------- TWI ------------------
Twi_control = Twcr And &H80 ' Bit7 von Controlregister
If Twi_control = &H80 Then
' TWI Transfer
Portd.7 = 0
Twi_status = Twsr




If Twi_status = &H80 Or Twi_status = &H88 Then
' -------- Daten von TWI erhalten
If Twi_dn = 0 Then
If Twdr = 1 Then
Xmode = 1
Elseif Twdr = 2 Then
Xmode = 2
Else
Xmode = 0
End If
Elseif Twi_dn = 1 Then
If Xmode = 1 Then
' Richtung
Xt1 = Twdr And 1
R_0 = Xt1
Xt1 = Twdr And 2
If Xt1 = 2 Then
R_1 = 1
Else
R_1 = 0
End If
Elseif Xmode = 2 Then
' ---- kommt noch
End If
Elseif Twi_dn = 2 Then
If Xmode = 1 Then
V0 = Twdr
Elseif Xmode = 2 Then
' ---- kommt noch
End If
Elseif Twi_dn = 3 Then
If Xmode = 1 Then
V1 = Twdr
Elseif Xmode = 2 Then
' ---- kommt noch
End If
Elseif Twi_dn = 4 Then


Elseif Twi_dn = 5 Then


End If
Incr Twi_dn
Elseif Twi_status = &HB0 Or Twi_status = &HB8 Then
' ------- Daten an TWI übergeben
If Xmode = 0 Then
If Twi_dn = 0 Then
Twdr = Xmode
Else
Twdr = 255
End If
Elseif Xmode = 1 Then
If Twi_dn = 0 Then
Twdr = Xmode
Elseif Twi_dn = 1 Then
Xt1 = 0
If R_0 = 1 Then Xt1 = 1
If R_1 = 1 Then Xt1 = Xt1 + 2
Twdr = Xt1
Elseif Twi_dn = 2 Then
Twdr = V0
Elseif Twi_dn = 3 Then
Twdr = V1
Elseif Twi_dn = 4 Then
Twdr = P0
Elseif Twi_dn = 5 Then
Twdr = P1
Else
Twdr = 0
End If
Elseif Xmode = 2 Then
If Twi_dn = 0 Then
Twdr = Xmode
Else
Twdr = 255
End If
Else
Twdr = 0
End If


Incr Twi_dn
Elseif Twi_status = &HA0 Or Twi_status = &HC0 Then
' TWI Transfer beendet
Portd.7 = 1
Twi_dn = 0
End If
Twcr = &B11000100
End If
Loop


Timer0_ovf:
' ---- Timer_0 ----- Interrupt alle 1 mS ----------------
Timer0 = 194 ' Resrwert = 61
Incr Tx
If Tx = 80 Then Portb.5 = 0 ' Herzschlag-LED (ein)


If Tx > 99 Then
' -------- Zeitbasis 100 mS ------------------
Sx = 1 ' Ready-Leitung =1
Tx = 0
Incr Tmx
Z0x = Z0
Z0 = 0
Z1x = Z1
Z1 = 0


If P0 = 0 And P1 = 0 Then
' ------ Richtung setzen wenn Motoren stehen
If R_0 = 0 Then Portb.3 = 0 Else Portb.3 = 1
If R_1 = 0 Then Portb.4 = 0 Else Portb.4 = 1
End If


If Xmode = 0 Then
' ------ Mode - Stop ----------
If P0 > 30 Then
P0 = P0 - 30
Sx = 0
Else
P0 = 0


End If
If P1 > 30 Then
P1 = P1 - 30
Sx = 0
Else
P1 = 0
End If
Elseif Xmode = 1 Then
' ------ Mode - Speed ----------
If V0 > Z0x And P0 < 255 And Pinc.0 = 1 Then
Px = 1
Vx = V0 - Z0x
If Vx > 6 Then
Px = 5
Sx = 0
End If
If Vx > 30 Then
Px = 20
End If
Pt = P0 + Px
If Pt > 255 Then
P0 = 255
Else
P0 = P0 + Px
End If
End If


If V1 > Z1x And P1 < 255 And Pinc.0 = 1 Then
Px = 1
Vx = V1 - Z1x
If Vx > 6 Then
Px = 5
Sx = 0 ' Ready-Leitung =0
End If
If Vx > 30 Then
Px = 20
End If
Pt = P1 + Px
If Pt > 255 Then
P1 = 255
Else
P1 = P1 + Px
End If
End If


If V0 < Z0x And P0 > 0 Or Pinc.0 = 0 Then
Px = 1
Vx = Z0x - V0
If Vx > 3 Then
Px = 6
Sx = 0
End If ' Ready-Leitung =0
If Vx > 35 Then
Px = 30
End If
If Px > P0 Then
P0 = 0
Else
P0 = P0 - Px
End If
End If


If V1 < Z1x And P1 > 0 Or Pinc.0 = 0 Then
Px = 1
Vx = Z1x - V1
If Vx > 3 Then
Px = 6
Sx = 0
End If ' Ready-Leitung =0
If Vx > 35 Then
Px = 30
End If
If Px > P1 Then
P1 = 0
Else
P1 = P1 - Px
End If
End If
Elseif Xmode = 2 Then
' ---- Mode-Strecke ------------------
End If


' ------ NOT - STOP ---- und Treiber auf null setzen ----
If V0 = 0 And Z0x = 0 And P0 > 0 Or Pinc.0 = 0 Then P0 = 0
If V1 = 0 And Z1x = 0 And P1 > 0 Or Pinc.0 = 0 Then P1 = 0


' ------ Treiber-Bremse -------
If P0 > 0 Then
Portd.4 = 1
Else
Portd.4 = 0
End If


If P1 > 0 Then
Portd.5 = 1
Else
Portd.5 = 0
End If


' ----- PWM-Wert setzen ---------
Compare1a = P0
Compare1b = P1


Portb.0 = Sx ' Ausgabe Ready-Leitung
End If


If Tmx > 9 Then
' ------------- Zeitbasis 1 Sec -------------------
Tmx = 0
If Pinc.1 = 0 Then ' abfrage ob rs232 enabled
Print "Status XM=" ; Xmode ; " Z0x=" ; Z0x ; " Z1x=" ; Z1x ; " P0=" ; P0 ; " P1=" ; P1 ; " S0=" ; S0 ; " S1=" ; S1 ; " NA=" ; Pinc.0
End If
Portb.5 = 1 ' Herzschlag-LED (aus)


End If
Return
Return


Int0_sub: ' Interrupt Motor_0 Decoder_Q1
Incr Z0
If Pinc.2 = 0 Then ' Abfrage Motor_0 Decoder_Q2 ( Drehrichtung )
Incr S0
Else
Decr S0
End If
Return
Return


Int1_sub: ' Interrupt Motor_1 Decoder_Q1
Incr Z1
If Pinc.3 = 0 Then ' Abfrage Motor_1 Decoder_Q2 ( Drehrichtung )
Incr S1
Else
Decr S1
End If
Return
Return

[Feuerring]

Update ...

habe angefangen die BUS-Platine aufzubauen,
auf der Platine gibt es zwei PCF-8574,
einmal adr(64) Input für Ready-Meldungen und adr(66) Output für Power-Abschaltung von jedem Modul.

Bei jeder Modul kann über zwei Kommandos 21=Ready-HIGH / 20=Ready-LOW die Ready-Leitung direkt gesteuert werde,
so kann das Master-Modul erkennen, auf welchem Steckplatz welches Modul(adr) sich befindet.

31860 31861

Auf der Bus-Platine gibt es noch zwei Spannungs_Regler (LM317) einer für 5V (Dauer) und einer für 8,5V(Vin-Nano)

Zum testen der TWI (I2C) verbindung habe ich erst mal ein Master mit einem einfach Programm gesteckt,
dieser Master setzt RS232-Kommandos als I2C-Master um und sendet eingelesenen I2C-Daten über RS232 zurück.



$regfile = "m328pdef.dat"$crystal = 16000000
$hwstack = 100
$swstack = 100
$framesize = 100
$baud = 19200


' ------------ DIM ------------------------
Dim X As Byte
Dim T1x As Byte ' Zähler 1/1000
Dim T2x As Byte ' Zähler 1/100
Dim T3x As Byte ' Zähler 1/10


' ------------ I2C-Master ------------------------
$lib "i2c_twi.lbx"
Config Scl = Portc.5
Config Sda = Portc.4
I2cinit
Config Twi = 100000
Dim Tw_buf(20)as Byte
Dim Tw_x As Byte
Dim Tw_s As Byte
Dim Tw_n As Byte
Dim Xout As String * 250


' ------------ RS232 - Input ------------------------
Dim Na As String * 30
Dim Nax As String * 30
Dim Si As Byte
Config Serialin = Buffered , Size = 40


' ------ Split -------
Dim Sb As Byte ' Split_Zähler
Dim Sbx(20) As String * 10 ' Split_Array


' ------------ Timer_0 Zeitvorgabe ------------------------------
Config Timer0 = Timer , Prescale = 256
On Ovf0 Timer0_ovf
Enable Timer0


Enable Interrupts


Print "Start_Main"


Do
If Ischarwaiting() <> 0 Then
Si = Inkey()
If Si <> 13 And Si <> 10 And Len(na) < 30 Then
Na = Na + Chr(si)
Else
Nax = Ucase(na)
Sb = Split(nax , Sbx(1) , "|")
If Sbx(1) = "STATUS" Then
Print "ACK|STATUS"
Print "Status|"
Elseif Sbx(1) = "TW_W" Then
' ------------ TW zum slave senden ----
Print "ACK|" ; Nax
If Sb > 2 Then
Tw_s = Val(sbx(2) )
Tw_n = Sb - 2
For X = 3 To Sb
Tw_buf(x -2) = Val(sbx(x) )
Next X
I2csend Tw_s , Tw_buf(1) , Tw_n
Else
Print "ERROR"
End If
Elseif Sbx(1) = "TW_R" Then
' ------------ TW vom slave lesen ----
Print "ACK|" ; Nax
If Sb = 3 Then
Tw_s = Val(sbx(2) )
Tw_n = Val(sbx(3) )
I2creceive Tw_s , Tw_buf(1) , 0 , Tw_n
Xout = "TW_R|DATA"
For X = 1 To Tw_n
Xout = Xout + "|" + Str(tw_buf(x))
Next X
Print Xout
Else
Print "ERROR"
End If
Else
Print "NACK"
End If
Na = ""
End If
End If
Loop


Timer0_ovf:
' ---- Timer_0 ----- Interrupt alle 1 mS ----------------
Timer0 = 194 ' Resrwert = 61
Incr T1x
If T1x > 9 Then
' -------- Zeitbasis 10 mS ------------------
Incr T2x
T1x = 0
If T2x = 8 Then Portb.5 = 0 ' Herzschlag-LED (ein)
If T2x > 9 Then
' -------- Zeitbasis 100 mS ------------------
Incr T3x
T2x = 0
If T3x > 9 Then
T3x = 0
' ------------- Zeitbasis 1 Sec -------------------
' Print "Status "
Portb.5 = 1 ' Herzschlag-LED (aus)
End If
End If
End If
Return
Return


Hier kann man die Kommandos am PC-Programm(RS232) und die eingelesenen Daten sehen
31862

[Feuerring]

Update ...

habe gestern mit mehreren Arduino(Nano) als I2C-Slave und einem Arduino(Nano) als I2C-Master verscheide Situationen durchgespielt,
um zu sehen wie sicher der I2C-BUS ist.
Dabei habe ich festgestellt, das ich was wichtiges übersehen habe, ein abgeschaltetes Modul zieht über die Schutzdioden des 329p den I2C-BUS (SDA/SCL) runter,
bedeutet ich muss diese PINs sowie die Not-AUS-Leitung beim deaktivieren des Modul von der BUS-Platine trennen, dazu werde ich die Level-Shift-Schaltung (https://www.eeweb.com/company-blog/nxp/level-shifting-techniques-in-i2c-bus-design) von NXP nehmen
die Gates der drei MOSFET (IRLML2402) werden dann mit über den BUS-Anschluss POWER(EN) im jeweiligem Modul mit geschaltet geschaltet.

Damit der Master handlungsfähig bleibt bekommt er einen Festen Platz auf der Bus-Platine, diese Slot kann über eine direkte Steuerleitung vom restlichen TWI-Bus getrennt werden,
die beiden "PCF-8574" sind da aber von nicht betroffen und bleiben mit dem Master direkt verbunden.

Sollte es zu einer Störung auf dem I2C-Bus kommen, wird über direkt gestaltete Leitung (NOT-AUS) alle Aktoren erst mal abgeschaltet,
dann kann der Master, das oder die störenden Module abschalten (neu-starten) ...

Auch musste ich festgestellten, das die Bascom Befehle ( I2creceive / I2csend ) mir mehrmals die Hauptschleife do / Loop zum stehen gebracht haben, ohne das eine Aktivität auf dem BUS vorlag ...
werde deswegen den I2C-Master ebenfalls direkt über die TWI-Register ansprechen, so wie ich es bei den TWI-Slave auch schon umgesetzt habe,
werde mich dabei an der hervorragenden Beschreibung TWI-Praxis (http://rn-wissen.de/wiki/index.php?title=TWI_Praxis) orientieren.

So kann ich besser auf Fehler-Situationen reagieren und auch selber Timeouts festlegen ... Das Projekt mit den aufgeteilten Funktionen über Module, Fällt oder Steht mit der sicheren Kommunikation der Module ...

[Ceos]

Auf was für einem Controller basiert der Arduino? Hört sich nach einem Atmel Problem an .... der I2C benutzt SMBus Logik und erfordert als Slave sog. Clock Stretching! Wenn der Slave seine Adresse hört und ein Datenbyte empfangen wurde, hält er die Clock Leitung auf Low bis die Programmlogik das Byte aus dem Empfangsregister kopiert ... das geht maximal 25mS gut, danach zwingt der Master wegen SMBus Logik ein erneutes Senden und hängt sich dabei weg ... während der Slave munter auf weitere Bytes wartet, der Bus ist dann in einem Konfliktzustand

[Feuerring]

Auf was für einem Controller basiert der Arduino?
Atmega 328p(16MHz) mit TWI-Hardware Unterstützung


Clock Stretching!

dabei zieht der Slave SCL runter um den Master zum warten zu zwingen ... in meinem Fall waren aber alle Leitungen auf HIGH und der Master hat gehangen.

Genauso hat der Master mit ( I2creceive / I2csend ) auch schon alle Slave gleichzeitig angesprochen, obwohl eine Adresse übergeben wurde, da ist einer der Bascom-Befehle mit Adresse und Daten durcheinander gekommen ...
denke mal das die Befehle ( I2creceive / I2csend ) nicht sauber umgesetzt worden sind, z.B. fehlende Timeouts beim warten auf (TWINT)...

Das verwenden der TWI-Register aus Bascom ist jetzt auch nicht besonders schwer, deswegen werde ich das selber umsetzen, dann weiß ich wenigstens was da abläuft und kann auf Störungen reagieren ...


danach zwingt der Master wegen SMBus Logik ein erneutes Senden und hängt sich dabei weg
wie will denn der Master da was erzwingen ... SCL ist LOW, da muss der Master warten, bis der Slave diese wieder frei gibt, erst dann kann der Master ein neues Byte übertragen ...

Die von mir über die Register programmierten TWI-Slave habe ich mit einem IOWarrior (I2C 50 / 100 / 400 ) zuvor getestet, da liefen diese ohne Probleme ...

[Ceos]

wie will denn der Master da was erzwingen ... SCL ist LOW, da muss der Master warten, bis der Slave diese wieder frei gibt, erst dann kann der Master ein neues Byte übertragen ...
ich hab mal einen Widerstand in Serien gehangen weil mir auf dem Oszi ein flackern aufgefallen war .... er wiederholt nach 25ms CLK stretch einfach das Byte, er knattert volles Programm die Bits auf den Bus und geht in Fehler, während der Slave nach dem freigeben der CLK fröhlich auf neue Bytes wartet
Du musst also in diesem Falle erstmal ein künstliches Restart und dann Stop auf den Bus legen damit der Slave aufhört zu Empfangen (und im Slave den Fehler erkennen) und dann die TRansmission neu starten

[Feuerring]

er wiederholt nach 25ms CLK stretch einfach das Byte

Jetzt stellt sich die Frage wer "ER" ist, Programm / Befehl / Hardware .... zum übertragen eines Daten-Byte muss der CLK aber HIGH sein ...

CLK wird vom Master vorgegeben und kann vom Slave bei LOW lang-gezogen werden ... kann es sein das dein Master da auch nicht sauber programmiert war ?!

Wenn ein Slave beim Clock Stretching sich aufhängt, hängt der BUS ... das muss der Master erkennen und z.B. den BUS-Zweig über I2C-Schalter abtrennen,
oder den Slave über eine Reset-Leitung neu starten ...

Man kann aber auch im Slave ein Watchdog mitlaufen lassen, der ein hängen in der TWI-Schleife erkennt und den Slave neu startet,
genau so kann ein Master beim übertragen einfach abrechnen, das muss der Slave erkennen.

Werde den Bus ausgiebig mit externen und internen Störungen testen ...

In meinem Fall scheint aber die in Bascom umgesetzten Befehle ( I2creceive / I2csend ) das Problem zu haben, möglicherweise wurden Fehler-Meldungen vom TWI-Controller nicht abgefangen und werden deswegen ignoriert.

[Ceos]

kann es sein das dein Master da auch nicht sauber programmiert war

glaube er mir, ich programmiere hier Industriesensoren und ich habe mir extra einen ultra billigen script gemacht der nix besseres tut als permanent 2 byte daten von einem slave zu lesen, wobei der slave diese 25ms stretch(witzigerweise undokumentiert bis ich es beanstanded habe) locker überschritten hat!

es ist die SMBus Logic im Atmega Controller und wenn du dir das Manual mal genaudurchließt steht es auch explizit drin dass nur ein stretch von max. 25ms gestattet ist, was danach passiert habe ich experimentell ermittelt

PS: Das Ende vom Lied, wir haben den Sensorhersteller(also Messgeber) mehr oder minder zusammengestaucht für die unvollständige Dokumentation und dann für einen anderen Zulieferer entschieden

[Feuerring]

es ist die SMBus Logic im Atmega Controller und wenn du dir das Manual mal genaudurchließt steht es auch explizit drin dass nur ein stretch von max. 25ms gestattet ist,
was danach passiert habe ich experimentell ermittelt

Danke für diese wichtige Info, muss mir die Doku noch mal genau durchlesen ... habe mir bislang auch nur die Slave Abarbeitung, so weit wie ich es brauchte angesehen ...


PS: Das Ende vom Lied, wir haben den Sensorhersteller(also Messgeber) mehr oder minder zusammengestaucht für die unvollständige Dokumentation und dann für einen anderen Zulieferer entschieden

Bin jetzt kein Hersteller, habe aber meinen TWI-Slave so schlank es geht gehalten, nur Daten übergeben / übernehmen und nach der Übernahme werden die Daten erst verarbeitet ....

muss ich mal versuchen nach zu messen, wie lange so eine Übergabe beansprucht und wie lange bzw. ob der CLK gestretcht wird ... 25 ms ist aber auch ganz schön lang ...
wenn man bedenkt das ein Takt gerade mal 0,01 mS (100kHz) dauert ... werde auf jeden Fall weiter über Erfolge und Rückschläge berichten ...

[Feuerring]

Update ...

muss mich korrigieren ... die Bascom Befehle ( I2creceive / I2csend ) arbeiten zuverlässig !!!

wenn man wie ich aber die Befehle mit falsch dimensionierte Variablen verwendet, muss man sich nicht wundern das diese sich aufhängen.

Habe zum testen mehrere zigtausend mal die Module über I2C angesprochen (schreiben und lesen) ... alles ohne Probleme ...

[Ceos]

gestern hatte mir ein Kollege einen Tipp gegeben, cih sollte mir eine Quietscheente an den Arbeitsplatz legen
immer wenn ich ein Problem habe weil etwas nicht funktioniert wie es soll, soll ich der Qietscheente erzählen was mein Problem ist um dann von selber auf Lösung zu kommen :D


iss aber manchmal wirklich so ... Stunde um Stunde versenkt .. dann mal mit nem Kollegen drüber reden und plötzlich sieht man den Wald wieder den man vorher vor lauter Bäumen einfach nicht gefunden hat

[021aet04]

Beim Messen mit dem Oszi muss man ebenfalls aufpassen. Bei mir war die Eingangskapazität des Tastkopfes das Problem.

MfG Hannes

[Feuerring]

dann mal mit nem Kollegen drüber reden und plötzlich sieht man den Wald wieder den man vorher vor lauter Bäumen einfach nicht gefunden hat

manchmal braucht man einfach nur eine andere Info " z.B. ... wieso macht Du das denn so umständlich ?" ... wenn man sich fest gebissen hat, sieht man oft die alternativen nicht mehr ...

Habe im Bascom-Forum leider deswegen ein Rüffel bekommen ... wollte unbedingt die I2C-Slave-Routine als Interrupt laufen lassen, und es wollte einfach nicht klappen ...

Im Zuge der Umsetzung habe ich aber festgestellt das es gar nicht so Vorteilhaft war, da noch andere Zeitkritische Interrupt-Routinen dann gestört werden ... also blieb es beim pollen in der Hauptschleife ...

[Feuerring]

Update ...

heute habe ich mich noch mal mit dem Power_Management der Module beschäftigt ...

Der Master kann darüber die Module einzeln abschalten und so auch bei Störungen dieses neu starten,
zum Glück habe ich heute eine Lieferung MosFet bekommen,
denn alle Ports vom Modul müssen vor dem Abschalten vom System-BUS getrennt werden.
Der abgeschaltete Controller zieht sonst alle Leitungen runter.

Schaltet der Master das Modul ein Power_EN = HIGH wird das Modul und alle angeschlossenen Baugruppen mit Strom versorgt,
der PIN PD6 wird als Ausgang geschaltet und auf 1 gesetzt, durch das Power_EN am FET wird dieser PIN aber auf LOW gezogen.

Schaltet der Master nun auf Power_EN = LOW werden alle Leitungen vom BUS getrennt, am PIN PD6 liegt nun HIGH an und erhält so die Stromversorgung für das Modul, in einer Timer-Routine wird dieser PIN abgefragt, ist dieser HIGH wird zu einem Label (Abschalten ) gesprungen,
alle wichtigen Parameter können nun ins EEProm geschrieben werden, danach wird PD6 auf LOW gesetzt, die abschalt Routine wartet nun
in einer do / Loop Schleife solange bis das Modul aus ist ...


31883

[Feuerring]

Update ...

habe das Bus-Konzept noch mal überarbeitet und die Module entsprechen angepasst.
Die Module haben alle eine Grundschaltung die das abtrennen vom BUS beim abschalten beinhaltet und einheitliche LED-Anzeigen
für ( POWER / I2C-Transfer / Ready-Event / NOT-AUS )

31892 31893





hier ein kleines Video, wo man mal die BUS-Funktion und das fertige Modul(Antrieb) sehen kann... VIDEO (https://youtu.be/3Go9VXH1fk0)

[Feuerring]

Update ...

da ich mich als nächstes mit den Schleifen-Sensoren und dessen Modul beschäftigen möchte,

brauche ich erstmal einen Schleifen-Strom Generator ...

Die Leiterplatte wird auch gleich später noch die Steuerung der Basis-Station (Garage) übernehmen,
dieses Basis-Modul kann über den gleichen RS-232 Transmitter wie der PC und der Bot mit diesen dann auch kommunizieren.

Aufbau Basis-Modul mit vorerst nur dem Schleifen-Strom Generator:

31903

Der Schleifen-Strom-Kondensator wird über ein MosFet(P-Kanal) geladen, wobei die Ladespannung vom MCU überwacht wird und beim erreichen des Soll-Wert
abgeschaltet wird, dann wird die Strom-Schleife an den geladenen Kondensator geschaltet über ein MosFet(N-Kanal) ...
Die beiden mosfets werden über spezielle Treiber angesteuert, um die Flanken möglichst steil zu bekommen ...
Die Nand-Gatter dienen allein nur der Verriegelung, so das immer nur ein mosfet durchgesteuert werden kann ...

Das dazugehörige Test-Programm, kann über die RS-232 mit folgenden Befehlen gesteuert werden,
LOOP_OFF
LOOP_ON|xxx

(xxx = Sollwert CU Lade-Schluss-Spannung)


1
xxx = UC * ------------------
5V/1024 * 3,16




' Projekt Mäh-Roboter
' R. Greinert
' 08 / 2016
'
' Basis-Modul
'
' - Strom-Schleife ( Test-Programm )
'
' ------------ Bascom - Parameter ------------------------


$regfile = "m328pdef.dat"
$crystal = 16000000
$hwstack = 100
$swstack = 100
$framesize = 100
$baud = 19200


' ------------ DIM ------------------------
Dim T1x As Byte ' Zähler 1/1000
Dim T2x As Byte ' Zähler 1/100
Dim T3x As Byte ' Zähler 1/10


Dim Loop_on As Byte


' ------------ ADC ------------------------
Config Adc = Single , Prescaler = Auto
Dim Adc_w As Word ' analog - wert
Dim Adc_s As Word ' AD sollwert


' ------------ Ports-Config ------------------------------
Config Portb.0 = Output ' Laden
Config Portb.1 = Output ' Entladen
Config Portb.5 = Output ' Herzschlag
Portb.0 = 0
Portb.1 = 0


' ------------ RS232 - Input ------------------------
Config Serialin = Buffered , Size = 40
Dim Na As String * 30 ' RS232 Input-String
Dim Nax As String * 30 ' RS232 Input-UCASE-String
Dim Si As Byte ' RS232 Input Zeichen
' ------ Split -------
Dim Sb As Byte ' Split_Zähler
Dim Sbx(5) As String * 10 ' Split_Array


' ------------ Timer_0 Zeitvorgabe ------------------------------
Config Timer0 = Timer , Prescale = 256
On Ovf0 Timer0_ovf
Enable Timer0


Enable Interrupts


Print "Start_Main"


Do
If Ischarwaiting() <> 0 Then
Si = Inkey()
If Si <> 13 And Si <> 10 And Len(na) < 30 Then
Na = Na + Chr(si)
Else
Nax = Ucase(na)
Sb = Split(nax , Sbx(1) , "|")
If Sbx(1) = "STATUS" Then
Print "ACK|" ; Nax
Elseif Sbx(1) = "LOOP_ON" Then
Print "ACK|" ; Nax
Adc_s = Val(sbx(2) )
Loop_on = 1
Elseif Sbx(1) = "LOOP_OFF" Then
Print "ACK|" ; Nax
Loop_on = 0
Portb.1 = 0
Else
Print "NAK|" ; Nax
End If
Na = ""
End If
End If
Loop


Timer0_ovf:
' ---- Timer_0 ----- Interrupt alle 1 mS ----------------
Timer0 = 194 ' Resrwert = 61
Incr T1x
Adc_w = Getadc(7) ' AD_7 einlesen
If Adc_w > Adc_s Then Portb.0 = 0 ' Sollwert(UC) ereicht = Laden abschalten

If T1x > 9 Then
' -------- Zeitbasis 10 mS ------------------
Incr T2x
T1x = 0
If Loop_on = 1 Then
If T2x = 1 Then
' --- entladen ----
Portb.0 = 0
Portb.1 = 1
Elseif T2x = 4 Then
' --- laden ----
Portb.1 = 0
Portb.0 = 1
End If
End If
If T2x = 8 Then Portb.5 = 0 ' Herzschlag-LED (ein)

If T2x > 9 Then
' -------- Zeitbasis 100 mS ------------------
Incr T3x
T2x = 0

If T3x > 9 Then
T3x = 0
' ------------- Zeitbasis 1 Sec -------------------
' Print "AD=" ; Adc_w
Portb.5 = 1 ' Herzschlag-LED (aus)
End If
End If
End If
Return
Return

[Feuerring]

Update ...

benötige da mal die Hilfe der Profis, komme mit meinem Wissen an die Grenze ...

habe die abgebildete Schalung so aufgebaut, das Entladen der ELKOS, derzeit mit 10.000 uF funktioniert super,
der MosFet (N-Kanal) 169A bleibt kalt ... bekomme bereits bei 6-9V Ladung super Sprikes in einer provisorischen
Sensor-Spule ( altes Relais 24V ) in der unmittelbaren Nähe der Schleife recht gute Ergebnisse.
Je nach Ausrichtung der Sensor-Spule zur Schleife sind die Sprikes komplett positiv oder negativ ...

Aufnahme-Leistung je nach Ladeendspannung der Elkos ... 6-12 Watt bei 12V

Was mir aber noch nicht gefällt, der MosFet (P-Kanal) 75A zum laden der Elkos wird recht warm ...
beide MosFet haben einen RDS von 0,02 Ohm ...

Eigentlich sollte der MosFet (P-Kanal) wie der N-Kanal mit diesen FET-Treiber voll durchsteuern, es liegen aber um die 0,5V am besagten Fet(S-D) ...

was habe ich nur übersehen ](*,)](*,)

[Feuerring]

Update ...

habe heute noch mal den Schleifen-Generator überarbeitet ...

die Temperatur-Probleme an den Lade-MosFet habe ich einfach durch einen Kühlkörper beheben können,

Zum testen habe ich RL und Cx noch mal angepasst, RL je 18 Ohm und Cx = 3x 4700 uF.

Strom-Aufnahme des Generator bei 12V Ladespannung(100%) ca. 1,5A

Auch habe ich verschiedene Finder-Relais geopfert ... 24VDC / 24VAC und 230VAC

Mit der 230V Spule mit Kern habe ich die besten Ergebnisse bekommen,
in unmittelbarer Nähe des Schleifen-Draht hatte ich Wert um die 100V Peek, in der Schleife (3m Durchmesser) in der Höhe von 50 cm immer noch mehrere Volt ...

Morgen geht es wenn ich Zeit finde weiter, ansonsten nächste Woche ... jetzt geht es erstmal ins Bett

[Feuerring]

Update ...

den Schleifen-Generator habe ich soweit fertig.

jetzt geht es an die Sensoren, dafür habe ich Relais(60V) bei pollin erstanden,
diese lassen sich gut zerlegen um die Spule heraus zu bekommen ...

Als Auswerte-Schaltung habe ich mir zwei Ausführungen überlegt,
1= mit analogen Ausgang und 2= mit digitalem Ausgang ... die Schaltungen sind noch ungetestet ...

https://www.roboternetz.de/community/attachment.php?attachmentid=32068&stc=1&d=1474588150

[Worker92]

Meiner Erfahrung nach muss man zuerst die Schaltung testen, danach weitere Schritte unternehmen...

[Feuerring]

Meiner Erfahrung nach muss man zuerst die Schaltung testen, danach weitere Schritte unternehmen

Das hatte ich eigentlich auch vor ?!

Bin mir aber noch nicht ganz sicher wie ich diese doch sehr kurzen Impulse, verlässlich auswerten kann ...
benötige für die Schleifen Erkennung ( Sensor innerhalb / außerhalb ) eine Schaltung die mir einen digitalen Wert liefert.

Für die Schleifenfahrt will ich zwei Spulen am Lenkrad vorne befestigen, diese sollen je einen analogen Wert liefern,
so das ich das Lenk-Rad exakt über den Draht ausrichten kann und wie auf einem Leitdraht lang fahren lassen kann ...

Die beiden Schaltungen habe ich geprostet, damit jemand mal ein Blick drauf wirft,
bin mir mit den Schaltungen nicht ganz sicher ...

[Feuerring]

Update ...

beim rumstöbern (eBay) bin ich auf Motore gestoßen die super für die Mähwerke passen dürften :

http://www.ebay.de/itm/282032371317?



12V Gleichstrommotor Bühler 1.13.044.257

Betriebsspannung 12V
Leerlaufdrehzahl 6.849 U/min
Leerlaufstrom ca. 700 mA
gewählter Lastpunkt 18,00 Ncm
Lastdrehzahl 5.502 U/min
Laststrom 12.031 mA
Aufnahmeleistung 144,37 Watt
Abgabeleistung 103,70 Watt
max. Wirkungsgrad 77,5% bei 9,6 Ncm
max. Leistung 164 Watt bei 46,2 Ncm
Haltemoment: 91,5 Ncm
Blockierstrom: 58.300 mA
Kollektor: 12-teilig
Lüfter/Pumpengehäuse
Maße: Länge: 88,6mm / Durchmesser: 51,6mm / Welle A: 15,5mm / Welle B: 7,7mm
Kommutierung durch Kohlebürsten
Kollektor 12- teilig
Lagerung A-Seite: Gleitlager
Lagerung B-Seite: Kugellager
Drehrichtung je nach Anschlußpolarität
Gehäuse korrosionsgeschützt
Lagerschilde beidseitg Zinkdruckguß


32116

Im Leerlauf ziehen die bei 12V ca. 1.5 A und sind sehr laufruhig,
durch das angesetzte Gebläse, ist auch eine Kühlung super möglich ...

Das Zinkdruckguß für den Kompressor, fräse ich ab, an der Seite ist die Welle auch Kugel-gelagert ...

[Unregistriert]

Mega coole Idee!^^ Was ich mir aber immer wieder durch den Kopf gehen lassen würde ist die Sicherheit!
1.) Für dich als Bastler Also was mechanische als auch elektrische Sichereit betrifft. Ich meine du baust hier einen sich mehr oder weniger selbst steuernden Roboter, der über sich drehende Klingen oder etwas ähnliches verfügt. Das hat schon was von einem Kampfroboter von Shows wie Robot Wars. Da sehe ich doch ein gewisses Gefahrenpotential ;). Was das elektrische betrifft hat der erfahrene Roboterbastler natürlich eh einen gewissen Grundrespekt aber du musst auch bedenken, dass er sich sich am ende wahrscheinlich auch mal durch nasses Gras bewegen soll und sich dann in eine Ladestation begibt. Da sollte man schon darauf achten, dass da nichts schlimmes passieren kann. Ein PRCD Schalter (http://elektron-berlin.de/produkte/prcds/personenschutzschalter-prcd-s.html) oder ähnliches wäre zumindest ganz gut.
2) Für Personen die den Garten auch benutzen. Das mag jetzt eher nach etwas für die späteren Phasen klingen wenn we wirklich eigenständig im Garten rumfährt aber ich sehe da einfach tausen Quellen für eine Klage wenn so ein mit Klingen bestückter Prototyp in deinem Garten umherflitzt ;)
Nenn mich paranoid aber ich wollte das nur mal erwähnen bevor dann irgendwas richtig in die Hose geht :)

[Feuerring]

Vor lauter Begeisterung für diese Technik, muss man natürlich auch die Sicherheit berücksichtigen.

Ich plane die rotierenden Klingen hinter ein Art Käfig / Kamm laufen zu lassen, weiterhin bekommt der Bott ein Cover,
dieser wird recht weit runter gezogen und wird mit Gummi-Dämpfer am Grund-Modul befestigt ...
so kann ich rundherum ein anstoßen oder anheben des Cover registrieren und die Mäh-Antriebe sofort stoppen ...
So ein Bot wird nicht gleich beim ersten Lauf zu 100% funktionieren, ist eher ein Projekt was über mehrere Jahre immer wieder überarbeitet werden muss.
Der Bot wird anfänglich immer nur unter Aufsicht laufen, erst wenn ich mir sicher bin das alles 100% funktioniert, kann / soll er auch unbeaufsichtigt seine Arbeit verrichten.

Hat der Bot dann eine Störung schaltet er im GO-HOME Mode um und fährt in seine Garage oder bleibt einfach stehen ...
bei meinem Projekt wird der Bot Rechner (PC) unterstützt funktionieren und immer eine Funk-Verbindung zum selbigen aufrecht halten, die Mäh-Programme werden dann vom PC aus gesteuert ...

[Bernd_Stein]

Hallo,

ich finde ein guter Ansatz, um schneller das Erwünschte zu erreichen kann sein, eine bereits gut funktionierende Plattform zu nutzen. Damit meine ich einen gebrauchten Rasenmähroboter ( RMR ) zu erwerben und diesen nach seinen Wünschen umzugestalten.

Der RoboMow RL500 ist ein äußerst begehrtes Bastelobjekt und es gibt jede Menge Informationen über diesen RMR.

https://www.roboternetz.de/community/threads/58383-Rasenroboter-selber-bauen-Hab-noch-Fragen-zum-Schaltplan-und-zum-Laderegler?p=602229&viewfull=1#post602229


Bernd_Stein

[Feuerring]

ich finde ein guter Ansatz, um schneller das Erwünschte zu erreichen kann sein, eine bereits gut funktionierende Plattform zu nutzen.

Eine bereits vorhandene Plattform zu nehmen schränk aber auch enorm ein, was nütz es denn, wenn man nachher alles umgebaut hat, dann kann man es auch gleich so machen wie man es sich vorstellt ...

[Bernd_Stein]

Eine bereits vorhandene Plattform zu nehmen schränk aber auch enorm ein, ...

Enorm ? Alle RMR machen irgendwo das selbe, die fahren herum und mähen durch rotieren von Messern das Gras. Der eine etwas leiser, der andere mäht besser den Rand usw. Aber am wichtigsten finde ich, das alles gemäht wird und jenes in kürzester Zeit. Und dies ist nunmal die Aufgabe der Steuerung und da bietet z.B. der RoboMow RL500 genügend Platz unter seiner Haube.

Die Steuerung bzw. intelligenz des RMR ist das, worauf der Fokus zu richten ist.

Bernd_Stein

[Feuerring]

Die Steuerung bzw. intelligenz des RMR ist das, worauf der Fokus zu richten ist.

Das ist ja das schöne an einem Bastel-Projekt, jeder hat seinen persönlichen Ansatz, klar zählt am Ende das Ergebnis.
Für mich ist aber auch der Weg dahin wichtig, die gemachten Erkenntnis und Erfahrungen / Rückschläge.

Das ist wie beim Modellbau, die einen nehmen Bausätze, die anderen machen alles selber ...
beide haben am Ende ein Model ... welches Model am Ende das bessere ist, ist doch eigentlich egal, der Weg ist das Ziel.

[petra5566]

Ich habe ebenfalls vor mir einen Mähroboter zu bauen. Könnt ihr mir berichten ob das möglich ist oder ist davon abzuraten? Also sollte man es versuchen oder einen kaufen? Technische Begabung habe ich eigentlich eine ganz gute.^^:confused: (https://produkte-vergleich.com/maehroboter/)

[Feuerring]

möglich ist alles, ist immer eine Frage des Aufwandes ...

möchte man nur einen Rasenmäherbot habe, sollte man auf Bausätze oder Fertig-Geräte zurückgreifen,
möchte man aber was eigenes entwickeln, wergen Spaß am bauen und planen,
kann man so eine Projekt angehen, wird aber nicht ohne Rückschläge und nachbessern klappen ...

[Bucki]

Hey Feuerring, klasse Projekt! Stehe auch gerade vor dem Bau eines Mähroboters. Getriebemotoren + Ansteuerung ist rausgesucht, nun habe ich aber noch das Problem, dass ich nicht weiß wonach ich mich beim Mähwerk richten soll ( außer eine Drehzahl von 3000-5000 1/min ). Hättest du eventuell einen Tipp? Möchte einen einzigen Mähmotor verwenden, 24cm Klinge und 24V Betriebsspannung. Ich danke dir schon jetzt! :)

Grüße, Bucki

[Feuerring]

Hallo Bucki

habe bereit schon auf dein Post geantwortet ... siehe hier https://www.roboternetz.de/community/threads/70330-Motor-f%C3%BCr-M%C3%A4hwerk?p=635860&viewfull=1#post635860