-
nee nehm das summensignal.. wenn du die einzelnen kanäle nimmst bracht du erstens viele pins, und 2. ist es auch gar nich so einfach die dann alle einzulesn, wuesst jetz nicht wie das machbar waere, brahct ja jedesmal nen interruptpin, und die quasseln sich dann alle gegenseitig rein..
am einfachsten ist summensignal und dann die ienzelnen kanäle hochzählen, habe ich auch so geamcht:
https://www.roboternetz.de/phpBB2/ze...143&highlight=
die servos ansteurn macht der controller "nebenher", da kannst du also ruig noch paar taster und sensoren dranhängen..
das mit dem knop ist kein problem, du kannst sogar mehrer knöpfe an die funke machen, die alle auf einem kanal laufen und jeweils einen anderen wert senden.. im programm dann einfach mit ner case schleife abfragen in welchem berecih der gesendet wert liegt und dementesprechend ein programm starten.. gehen locker 10 taster pro kanal,..
-
Ok,
da ich wie oben beschrieben ja eigentlich Joysticks als Funke verwende, kommt mir das mit den Tastern sehr recht...
Ich kann doch also auf insgesamt 2 Kanälen alle Taster meiner Joysticks laufen lassen, oder?
dann brauche ich nurnoch 6 Kanäle, um die x-, y- und z-Achsen der beiden abzufragen...
da ich eine gebrauchte Funke dafür bei ebay suche, muss ich also ne 7- oder 8-Kanal-Funke kaufen, oder?
könnte ich theoretisch auch die Taster irgendwie auf die anderen Kanäle zuschalten, denn ich hätte schon ne 6-Kanal-Funke im Auge, oder soll ich die 6-Kanal-Funke kaufen und zusätzlich noch so ne billige 2-Kanal-Funke für die Taster??
MfG Pr0gm4n
-
wofuer genau braucsht du denn 6 kanäle ?? 3 achsen und dann.... ??
-
ich habe oben (glaube ich) schon erwähnt, dass es sich um 2 Joysticks handelt, einer rechts und einer links. Das sind dann 6 Achsen (Kanäle) und alle Taster, die ich auf 2 Kanäle schalten will, da man sonst immer nur einen drücken könnte. Wenn ich 2 gleichzeitig drücken würde, dann würde nur der eine reagieren, der den niedrigeren Widerstand hat.
MfG Pr0gm4n
-
ok, dann brauchst du 6 + 1 oder 2 kanalele...
naja du kannst wenn du die widerstände sinnvollvoll anordnest an den tastern, auch mehrer gleichzeitig nutzen, zum beispiel wenn der erste 1 kohm hat der 2. zwei, dann ist 1 und 2 gedrückt 3 kohm, der nexte wert darf dann erst bei 4 leigen.. muss halt so sien, dass sich nichsts ueberschneidet..
aber mit 2 kanaälen ist es auf jedenfall einfacher,..
-
Ok,
ich muss jetzt das Geld beantragen und wenn ich es bewilligt kriege, dann wird bestellt und dann gebaut
MfG Pr0gm4n
PS: also reicht Controllermässig der Mega8 und der Mega8535, oder?
-
Also was die servos betrifft hätte ich ein vorschlag.
Hab hier noch ne Software PWM rumliegen die theoretisch 32 Servos steuern kann.
Problem dabei sie nur das die auf 8Mhz ausgelegt ist (ebenfalls der atmega8535). Ist zwar nicht ganz so stilvoll gehalten aber sie funktioniert ^^.
Um mehr Rechenleistung verwenden zu können müsstest du lediglich den umrechnungswert hochsetzen.
Funktioniert so das mit 50Hz ein Timer läuft und von einer mS aufwärts die Ports abgeschalten werden. In den maximal 2mS ist der Atmega in der Timer schleife drin und kann nix machen aber die restlichen 18mS reichen im grunde für alle berechnungen aus.
Wenn du mehr als 8 Servos brauchst musst du 2 Bytes einrechnen wobei du die anderen noch als input verwenden kannst.
8 Servos = 30% des speichers max 16Servos =49%.
Ich habe gerade noch eine wo ein String mit 8 Werten verarbeitet wird wobei es sich empfehlen würde einen 2. Atmega zu nehmen der über i2c einen String erhält bzw die einzelnen Positionen.
Bei jeder der beiden möglichkeiten muss ein 8Mhz Quarz verwendet werden (wie gesagt einstellen ist möglich)
Code:
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'----------------------------- Software PWM ------------------------------------
'------------------------------ 16 Servo's -------------------------------------
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'------- Voreinstellungen
'-------------------------------------------------------------------------------
$regfile = "m8535.dat" 'ATMega8535
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 8000000 'Quarz: 8.0000 MHz
$baud = 9600
'-------------------------------------------------------------------------------
'------- Timer 0
'-------------------------------------------------------------------------------
Print "16 Servo Steuerung"
Print "2 Beiniger Roboter"
Print "by MC Gyver Games"
Print "Programm Start"
Config Timer1 = Timer , Prescale = 256 'Konfiguriere Timer1
Enable Timer1 'schalte den Timer1 ein
On Timer1 Isr_von_timer_fuer_f 'verzweige bei Timer1 überlauf zu Isr_von_Timer1
Enable Interrupts
Load Timer1 , 625 '64911 'Timer1 soll schon von 625 wegzählen
Enable Interrupts '50hz Schleife
'-------------------------------------------------------------------------------
'------- Output
'-------------------------------------------------------------------------------
Config Porta = Output
Config Portc = Output
Config Portb.1 = Output 'LED
Config Portb.2 = Output 'LED
Config Portb.3 = Output 'LED
'-------------------------------------------------------------------------------
'------- Servo Variablen
'-------------------------------------------------------------------------------
Dim Servos(8) As Word
Dim Servos_a(8) As Word
Dim Servos_b(8) As Word
'------- Umrechnungsvariablen 1...8 zu 2^1...8
Dim Input_aw As Byte
Dim Output_aw As Byte
Dim Rech_aw As Byte
'-------------------------------------------------------------------------------
'------- Wait Variablen
'-------------------------------------------------------------------------------
Dim Z As Word 'Zähl Variable als waitus ersatz ;P
Dim W_s(8) As Word 'Waitzeiten Save für übergabe vorgerechnet
Dim Wa(8) As Word
Dim Wb(8) As Word
Dim Wa_s(8) As Word
Dim Wb_s(8) As Word
'-------------------------------------------------------------------------------
'------- Berechnungsvariablen
'-------------------------------------------------------------------------------
Dim Rech(20) As Word ' rechen Variable
Dim Nr_a(20) As Byte 'Port nummer
Dim Nr_b(20) As Byte 'Port nummer
Dim Index As Byte
Dim Wert As Word
Dim Index_plus As Byte
Dim Nr As Byte
Dim Durchgang As Byte 'gibt an welche stelle des bytes grade berechnet wird: 1 - 8
Dim Durchgang_plus As Byte 'durchgang + 1
Dim Durchgang_minus As Byte
Dim Save_rech(10) As Word
Dim Port_s(8) As Byte 'Port Save = Zwischenspeicher von port Byte's
Dim Port_s_a(8) As Byte 'Port Save = Zwischenspeicher von port Byte's
Dim Port_s_b(8) As Byte 'Port Save = Zwischenspeicher von port Byte's
Dim Akt_byte As Byte
Akt_byte = 0
'-------------------------------------------------------------------------------
'------- Variablen des Hauptprogramms
'-------------------------------------------------------------------------------
Dim A As Byte 'durchlauf Variable
Dim B As Word '50Hz Schleifen Variable
Dim C As Word '50Hz Schleifen Variable
A = 0
B = 0
C = 0
'-------------------------------------------------------------------------------
'------- Hauptprogramm
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
Servos_b(1) = 0
Servos_b(2) = 0
Servos_b(3) = 0
Servos_b(4) = 0
Servos_b(5) = 95
Servos_b(6) = 75
Servos_b(7) = 75 '83
Servos_b(8) = 0 '100
'-------------------- Byte A
Servos_a(1) = 60 '60
Servos_a(2) = 80 '80 'hoch nach links / runter nach rechts
Servos_a(3) = 130 '130
Servos_a(4) = 100 '100 'rechts = hoch / Links = runter
Servos_a(5) = 35 '35 'rechts = hoch / links = runter
Servos_a(6) = 48 '48
Servos_a(7) = 83 '83
Servos_a(8) = 105 '110 'Pa7
'-------------------- Byte B
'Servos_a(4) = 10 '110 'rechts = hoch / Links = runter
'Servos_a(6) = 10 '110 'rechts = hoch / Links = runter
Do
'-------------------------------------------------------------------------------
If C = 1 Then
'-------------------------------------------------------------------------------
If B = 100 Then
Servos_b(5) = 180
End If
If B = 200 Then
Servos_b(5) = 10
End If
If B = 300 Then
Servos_a(3) = 180
Servos_a(4) = 140
Servos_a(7) = 55
Servos_a(8) = 110
End If
If B = 5000 Then B = 0
End If
Toggle Portb.2
Berechnung:
'-------------------------------------------------------------------------------
'------- Byte übergabe
'-------------------------------------------------------------------------------
Incr Akt_byte
If Akt_byte = 3 Then Akt_byte = 1
If Akt_byte = 1 Then
Servos(1) = Servos_a(1)
Servos(2) = Servos_a(2)
Servos(3) = Servos_a(3)
Servos(4) = Servos_a(4)
Servos(5) = Servos_a(5)
Servos(6) = Servos_a(6)
Servos(7) = Servos_a(7)
Servos(8) = Servos_a(8)
End If
If Akt_byte = 2 Then
Servos(1) = Servos_b(1)
Servos(2) = Servos_b(2)
Servos(3) = Servos_b(3)
Servos(4) = Servos_b(4)
Servos(5) = Servos_b(5)
Servos(6) = Servos_b(6)
Servos(7) = Servos_b(7)
Servos(8) = Servos_b(8)
End If
'-------------------------------------------------------------------------------
'------- Umrechnen der 0 - 180 werte auf 0 - 390 (390 = maximaler Schleifenwert)
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
For Nr = 1 To 8
Rech(nr) = Servos(nr) * 217
Rech(nr) = Rech(nr) / 100
Next Nr 'Rechnung klappt perfekt
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'------- Berechnen der Ausgangswerte
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'Input = rech 1 - 8 des wars
'output = Die Byte werte der 50 HZ schleife
'Zu rechnen:
'1. kleinster Wert mit Index
'2. vergleich auf anderer index mit gleichen werten und auf 1000 setzen
'3. alle Werte mit 1000 vom Byte abziehen
'4. Nun muss die Schleife von vorne beginnen und besagte werte ignorieren
' Zu Beachten: Alle Werte müssen verstellbare Var's sein um eine große Schleife
' zu verwirklichen was weniger speicher braucht als ein Byte komplett zu
' scripten und den uC unnötig aufzuhalten.
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'------- Übergabe von Rech auf Rech_save
'-------------------------------------------------------------------------------
For Save_rech(10) = 1 To 8
Save_rech(save_rech(10)) = Rech(save_rech(10))
W_s(save_rech(10)) = 0
Next Save_rech(10)
Save_rech(9) = 500
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
For Durchgang = 1 To 8 'Variable die angibt welche Stelle berechnet wird
'-------------------------------------------------------------------------------
Durchgang_plus = Durchgang + 1
Durchgang_minus = Durchgang - 1
Wert = 500
Rech(9) = 500
'-------------------------------------------------------------------------------
'------- Berechnen der niedrigsten Zahl und des Index
'------- Die namen erklären sich von selbst ^^
'-------------------------------------------------------------------------------
'Größenvergleich der aktuellen Zahl (nr) und der nachfolgenden Zahl (index_plus)
'Falls Rech(nr) unter der aktuellen niedrigsten zahl ist wird der niedrigste
'Wert aktualisiert. Der index ist einfach die NR des durchgangs
'Der WERT wird bei jedem neuen Durchgang (var: Durchgang) auf 500 gesetzt.
'Um damit den alten Wert zu löschen und die 2...7 niedrigste Zahl zu berechnen
For Nr = 1 To 8
Index_plus = Nr + 1
If Rech(nr) < Rech(index_plus) Then
If Rech(nr) < Wert Then
Wert = Rech(nr)
Index = Nr
End If
End If
Next Nr
'-------------------------------------------------------------------------------
'------- Erste Wait Zeit = Niedrigster Wert somit Rech(index)
'-------------------------------------------------------------------------------
'Da Rech(1...8) ja auf 1000 gesetz werden muss dessen eigentliche werte in
'Save_rech gespeichert werden
'-------------------------------------------------------------------------------
Save_rech(durchgang) = Rech(index)
If Durchgang = 1 Then
W_s(1) = Rech(index)
Else
If Save_rech(durchgang_minus) = Rech(index) Or Rech(index) = 1000 Then
W_s(durchgang) = 0
Else
W_s(durchgang) = Rech(index) - Save_rech(durchgang_minus)
End If
End If
'-------------------------------------------------------------------------------
'------- Auf gleiche Werte überprüfen und ggf auf 1000 setzen
'-------------------------------------------------------------------------------
Port_s(durchgang) = 255
'-------------------------------------------------------------------------------
For Nr = 1 To 8
'-------------------------------------------------------------------------------
'------- Auf gleiche Werte Testen
'Alle werte die mit rech(index) identisch sind auf 1000 setzen
'-------------------------------------------------------------------------------
If Rech(nr) = Rech(index) Then
If Nr <> Index Then
Rech(nr) = 1000
End If
End If
Next Nr
Rech(index) = 1000
'-------------------------------------------------------------------------------
'------- Ende Vergleich es folg Ausgangsbyte 1000er vergleich
'------- Alle Werte die 1000 sind vom byte abziehen
'-------------------------------------------------------------------------------
'Print "Ende Vergleich es folg Ausgangsbyte 1000er vergleich"
'-------------------------------------------------------------------------------
For Nr = 1 To 8
If Rech(nr) = 1000 Then
Input_aw = Nr
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'Eingang: Input_aw 1 - 8
'Ausgang: Output_aw 1,2,4,8,16,32,64,128
'-------------------------------------------------------------------------------
'Werte umrechnen
Input_aw = Input_aw - 1
Output_aw = 1
'Berechnungsschleife
For Rech_aw = 1 To Input_aw
Output_aw = Output_aw * 2
Next Input_aw
'-------------------------------------------------------------------------------
Port_s(durchgang) = Port_s(durchgang) - Output_aw
'-------------------------------------------------------------------------------
End If
Next Nr
'-------------------------------------------------------------------------------
'------- Neuer Berechnungszyklus
'-------------------------------------------------------------------------------
Next Durchgang
'-------------------------------------------------------------------------------
'------- Berechnung Fertig => Wert Übergabe
'-------------------------------------------------------------------------------
'Print "Berechnungs Ende => Wertuebergabe"
'-------------------------------------------------------------------------------
'Erst fertig berechnete Werte schnellstmöglich übergeben
If Akt_byte = 2 Then
For Nr = 1 To 8
Wb_s(nr) = W_s(nr)
Port_s_b(nr) = Port_s(nr)
Next Nr
For Nr = 1 To 8
Wa(nr) = Wa_s(nr)
Wb(nr) = Wb_s(nr)
Nr_a(nr) = Port_s_a(nr)
Nr_b(nr) = Port_s_b(nr)
Next Nr
End If
If Akt_byte = 1 Then
For Nr = 1 To 8
Wa_s(nr) = W_s(nr)
Port_s_a(nr) = Port_s(nr)
Next Nr
End If
C = 1
'-------------------------------------------------------------------------------
'------- Schleifen Ende
'-------------------------------------------------------------------------------
Loop
'-------------------------------------------------------------------------------
'------- ENDE
'-------------------------------------------------------------------------------
Print "ENDE"
End
'-------------------------------------------------------------------------------
'------- ISR TImer 1 (theoretische 50Hz Schleife hab kein Oszi^^)
'-------------------------------------------------------------------------------
Isr_von_timer_fuer_f:
Enable Interrupts
Load Timer1 , 625 'Timer1 soll schon von 625 wegzählen
Incr B
Porta = 255
Waitus 520
'-------------------------------------------------------------------------------
'------- Byte A
'-------------------------------------------------------------------------------
For Z = 1 To Wa(1)
Next Z
Porta = Nr_a(1)
For Z = 1 To Wa(2)
Next Z
Porta = Nr_a(2)
For Z = 1 To Wa(3)
Next Z
Porta = Nr_a(3)
For Z = 1 To Wa(4)
Next Z
Porta = Nr_a(4)
For Z = 1 To Wa(5)
Next Z
Porta = Nr_a(5)
For Z = 1 To Wa(6)
Next Z
Porta = Nr_a(6)
For Z = 1 To Wa(7)
Next Z
Porta = Nr_a(7)
For Z = 1 To Wa(8)
Next Z
Porta = Nr_a(8)
'-------------------------------------------------------------------------------
'------- Byte C
'-------------------------------------------------------------------------------
Portc = 255
Waitus 520
For Z = 1 To Wb(1)
Next Z
Portc = Nr_b(1)
For Z = 1 To Wb(2)
Next Z
Portc = Nr_b(2)
For Z = 1 To Wb(3)
Next Z
Portc = Nr_b(3)
For Z = 1 To Wb(4)
Next Z
Portc = Nr_b(4)
For Z = 1 To Wb(5)
Next Z
Portc = Nr_b(5)
For Z = 1 To Wb(6)
Next Z
Portc = Nr_b(6)
For Z = 1 To Wb(7)
Next Z
Portc = Nr_b(7)
For Z = 1 To Wb(8)
Next Z
Portc = Nr_b(8)
Return
'-------------------------------------------------------------------------------
'------- ENDE
'-------------------------------------------------------------------------------
End
Jeder Servo um 1° einstellbar
Du kannst auch anstatt "0 ...180" => 0...217 benutzen. Aber 0..180 war mir lieber ;P
mfg
-
jipp die sontroller solltens tun..
-
also wie gesagt, ich bin ein richtiger Anfänger, was ich schon gemacht habe ist mit dem RP6 und seiner Library rumspielen...
Wenn ich jetz den gleichen µC wie beim RP6 verwende kann ich theoretisch glaube ich sogar die enthaltene Library verwenden
Ich werd das mit dem Software PWM dann mal durcharbeiten und hoffe, es zu verstehen...
MfG Pr0gm4n
-
hi,
für die Servoansteuerung kannst du auch nen SD20 http://www.roboter-teile.de/datasheets/sd20.pdf
nehmen. Das ist n vorprogrammierter PIC und den kann man auch über I²C ansteuern. Das ist, finde ich, das einfachste, denn die Beschaltung ist n Kinderspiel und du kannst bis zu 20 Servos steuern. Allerdings solltest du für die Servos und die Elektronik auf jeden fall getrennte Spannungsversorgungen einrichten.
Gruß
Jigger
