Mehrere RC Signale einlesen und mehrere Servos ausgeben

[Searcher]

Die Ausschläge des Servozucken gingen zurück, oft ist es auch nur noch hör- und fühlbar, ohne sichtbare Ausschläge. Ich denke, auf der Grundlage läßt sich das weitere Programm aufbauen.

Prima, dann kann man schon fast anfangen kaputtzuoptimieren

Mir gefiel nicht, daß bei der Umrechnung auf 8-Bit der Wert der Wordvariable "Impulslänge_" während des Zugriffs im Hauptprogramm durch die ISR verändert werden könnte. Bascom muß ja da auch immer Low-Byte und High-Byte in verschiedenen Schritten holen, die von einem Interrupt unterbrochen werden können.

Ist eine potentielle Zuckquelle, denke ich. Andere Zuckquellen sind wahrscheinlich die Interrups, die sich gegenseitig aufhalten und deshalb zu Ungenauigkeiten bei Messung und Ausgabe führen.
Ist der Einsatz eines oder mehrerer weiterer µC eine Option?

Statt im Hauptprogramm für die Zeit des Zugriffs auf Impulslänge die Interrupts zu disablen, wird nun in der ISR schon auf 8 Bit-Wert umgerechnet und steht schon als Bytewert in der Hauptschleife zur Verfügung.

Dadurch ist die ISR wieder um ca 1µs länger geworden aber das oben genannte mögliche Problem empfinde ich als schwerwiegender.

Hab diesmal nur die wichtigsten Teile eingefügt. Die Variablen Impulslänge_x sollten als Byte Variable deklariert werden. Berechnung_x können auch Byte sein. Rest des ungeposteten Programms bleibt unberührt gegenüber der letzten Version.

Gruß
Searcher

'======================================================
'Hauptprogramm
'======================================================

Do

'Umrechnung erstes RC Signal auf 8-Bit
'Berechnung_1 = Impulslaenge_1 / 8       'ergibt Werte zwischen 125 und 250

Berechnung_1 = Impulslaenge_1           'Berechnung kann und Impulslaenge SOLLTE als Byte declariert werden

'If Berechnung_1 > 255 Then              'zu hohe Werte abfangen  'kann nicht mehr höher als 255 werden
'   Berechnung_1 = 255
'End If

If Berechnung_1 < 120 Then              'zu kleine Werte abfangen
   Berechnung_1 = 120
End If


'Umrechnung zweites RC Signal auf 8-Bit
'Berechnung_2 = Impulslaenge_2 / 8       'ergibt Werte zwischen 125 und 250

Berechnung_2 = Impulslaenge_2           'Berechnung kann und Impulslaenge SOLLTE als Byte declariert werden

'If Berechnung_2 > 255 Then              'zu hohe Werte abfangen   'kann nicht mehr höher als 255 werden
'   Berechnung_2 = 255
'End If

If Berechnung_2 < 120 Then              'zu kleine Werte abfangen
   Berechnung_2 = 120
End If

Servoausgabe_1 = 256 - Berechnung_1     'Servoausgabe_ zum direkten Laden in TCNT0 vorbereiten (Cmd Load umgangen)
Servoausgabe_2 = 256 - Berechnung_2     'Servoausgabe_ zum direkten Laden in TCNT0 vorbereiten (Cmd Load umgangen)
Servoausgabe_3 = 190
Servoausgabe_4 = 190

Loop




'======================================================
'ISR
'======================================================

Rc_eingang_1:
 $asm
   sbis pinb , 1                        'Skip next Instr if PINBx = 1
   rjmp pulslaenge1                     'Spring zur Berechnung von Impulslaenge
   push r17                             'Register auf Stack sichern
   in r17 , tcnt1l                      'Timer1 low Byte holen
   sts {Rc_signal_1_start} , r17        'Speichere Timer1 low Byte nach Rc_signal low Byte
   in r17 , tcnt1h                      'Timer1 high Byte holen
   sts {Rc_signal_1_start} + 1 , r17    'Speichere Timer1 high Byte nach Rc_signal high Byte
   pop r17                              'Register vom Stack zurückholen
   rjmp ende1                           'Springe zum Ende
  Pulslaenge1:
   push r16                             'Register auf Stack sichern
   in r16,sreg                          'Statusregister holen und halten
   push r17                             'Register auf Stack sichern
   push r18                             'Register auf Stack sichern
   push r19                             'Register auf Stack sichern
   in r17 , tcnt1l                      'Timer1 low Byte holen
   lds r18 , {Rc_signal_1_start}        'Hole Rc_signal low Byte
   Sub R17 , R18                        'Subtrahiere Rc_signal low Byte von Timer1 low Byte
   in r18 , tcnt1h                      'Timer1 high Byte holen
   lds r19 , {Rc_signal_1_start} + 1    'Hole Rc_signal high Byte
   sbc r18 , r19                        'Subtrahiere Rc_signal high Byte von Timer1 high Byte
   'divison durch 8 durch dreimaliges rechts shiften des 16bit ergebnisses
   lsr r18                              'logical shift right von ergebnis high byte, lsb wandert ins carry flag
   ror r17                              'rechts rollen von ergebnis low byte, msb kommt aus carry flag
   lsr r18                              'logical shift right von ergebnis high byte, lsb wandert ins carry flag
   ror r17                              'rechts rollen von ergebnis low byte, msb kommt aus carry flag
   lsr r18                              'logical shift right von ergebnis high byte, lsb wandert ins carry flag
   ror r17                              'rechts rollen von ergebnis low byte, msb kommt aus carry flag
   sts {Impulslaenge_1} , r17           'Speichere durch 8 dividiertes Resultat in Impulslaenge
   pop r19                              'Register vom Stack zurückholen
   pop r18                              'Register vom Stack zurückholen
   pop r17                              'Register vom Stack zurückholen
   Out Sreg , R16                       'Statusregister zurückspeichern
   pop r16                              'Register vom Stack zurückholen
  Ende1:
 $end Asm
Return


Rc_eingang_2:
 $asm
   sbis pinA , 7                        'Skip next Instr if PINBx = 1
   rjmp pulslaenge2                     'Spring zur Berechnung von Impulslaenge
   push r17                             'Register auf Stack sichern
   in r17 , tcnt1l                      'Timer1 low Byte holen
   sts {Rc_signal_2_start} , r17        'Speichere Timer1 low Byte nach Rc_signal low Byte
   in r17 , tcnt1h                      'Timer1 high Byte holen
   sts {Rc_signal_2_start} + 1 , r17    'Speichere Timer1 high Byte nach Rc_signal high Byte
   pop r17                              'Register vom Stack zurückholen
   rjmp ende2                           'Springe zum Ende
  Pulslaenge2:
   push r16                             'Register auf Stack sichern
   in r16,sreg                          'Statusregister holen und halten
   push r17                             'Register auf Stack sichern
   push r18                             'Register auf Stack sichern
   push r19                             'Register auf Stack sichern
   in r17 , tcnt1l                      'Timer1 low Byte holen
   lds r18 , {Rc_signal_2_start}        'Hole Rc_signal low Byte
   Sub R17 , R18                        'Subtrahiere Rc_signal low Byte von Timer1 low Byte
   in r18 , tcnt1h                      'Timer1 high Byte holen
   lds r19 , {Rc_signal_2_start} + 1    'Hole Rc_signal high Byte
   sbc r18 , r19                        'Subtrahiere Rc_signal high Byte von Timer1 high Byte
   'Divison durch 8 durch dreimaliges rechts shiften des 16bit ergebnisses
   lsr r18                              'logical shift right von ergebnis high byte, lsb wandert ins carry flag
   ror r17                              'rechts rollen von ergebnis low byte, msb kommt aus carry flag
   lsr r18                              'logical shift right von ergebnis high byte, lsb wandert ins carry flag
   ror r17                              'rechts rollen von ergebnis low byte, msb kommt aus carry flag
   lsr r18                              'logical shift right von ergebnis high byte, lsb wandert ins carry flag
   ror r17                              'rechts rollen von ergebnis low byte, msb kommt aus carry flag
   sts {Impulslaenge_2} , r17           'Speichere durch 8 dividiertes Resultat in Impulslaenge
   pop r19                              'Register vom Stack zurückholen
   pop r18                              'Register vom Stack zurückholen
   pop r17                              'Register vom Stack zurückholen
   Out Sreg , R16                       'Statusregister zurückspeichern
   pop r16                              'Register vom Stack zurückholen
  Ende2:
 $end Asm
Return


Rc_eingang_3:
$asm
   sbis pinb , 2                        'Skip next Instr if PINBx = 1
   rjmp pulslaenge3                     'Spring zur Berechnung von Impulslaenge
   push r17                             'Register auf Stack sichern
   in r17 , tcnt1l                      'Timer1 low Byte holen
   sts {Rc_signal_3_start} , r17        'Speichere Timer1 low Byte nach Rc_signal low Byte
   in r17 , tcnt1h                      'Timer1 high Byte holen
   sts {Rc_signal_3_start} + 1 , r17    'Speichere Timer1 high Byte nach Rc_signal high Byte
   pop r17                              'Register vom Stack zurückholen
   rjmp ende3                           'Springe zum Ende
  Pulslaenge3:
   push r16                             'Register auf Stack sichern
   in r16,sreg                          'Statusregister holen und halten
   push r17                             'Register auf Stack sichern
   push r18                             'Register auf Stack sichern
   push r19                             'Register auf Stack sichern
   in r17 , tcnt1l                      'Timer1 low Byte holen
   lds r18 , {Rc_signal_3_start}        'Hole Rc_signal low Byte
   Sub R17 , R18                        'Subtrahiere Rc_signal low Byte von Timer1 low Byte
   in r18 , tcnt1h                      'Timer1 high Byte holen
   lds r19 , {Rc_signal_3_start} + 1    'Hole Rc_signal high Byte
   sbc r18 , r19                        'Subtrahiere Rc_signal high Byte von Timer1 high Byte
   'divison durch 8 durch dreimaliges rechts shiften des 16bit ergebnisses
   lsr r18                              'logical shift right von ergebnis high byte, lsb wandert ins carry flag
   ror r17                              'rechts rollen von ergebnis low byte, msb kommt aus carry flag
   lsr r18                              'logical shift right von ergebnis high byte, lsb wandert ins carry flag
   ror r17                              'rechts rollen von ergebnis low byte, msb kommt aus carry flag
   lsr r18                              'logical shift right von ergebnis high byte, lsb wandert ins carry flag
   ror r17                              'rechts rollen von ergebnis low byte, msb kommt aus carry flag
   sts {Impulslaenge_3} , r17           'Speichere durch 8 dividiertes Resultat in Impulslaenge
   pop r19                              'Register vom Stack zurückholen
   pop r18                              'Register vom Stack zurückholen
   pop r17                              'Register vom Stack zurückholen
   Out Sreg , R16                       'Statusregister zurückspeichern
   pop r16                              'Register vom Stack zurückholen
  Ende3:
 $end Asm
Return