JVC Fernbedienung - Protokoll?

[Marco (Gast)]

Hallo µC-Gemeinde!

Ich habe hier ne kleine JVC RM-RK50 IR-Fernbedienung liegen und wollte 
mein Radio mit ner uC-Schaltung steuern. Habe zuerst versucht, das 
Drücken der Knöpfe der Fernbedienung von Extern über Kurzschluss der 
entsprechenden Pin-Kombinationen zu erreichen, allerdings ist das IC 
komisch verschaltet (2x4 Pin-Kombinationen für 5 Tasten) und meine 
Versuche schlugen fehl.

20-Pin IC:
Aufschrift:
ET611
F3H0A

4 MHz Resonator


Bei LIRC gibt es ein Code-Profil:

#
# this config file was automatically generated
# using lirc-0.6.5(any) on Thu Sep 16 00:40:47 2004
#
# contributed by
#
# brand:                       JVC
# model no. of remote control: RM-RK50
#

begin remote

  name  JVC_RM-RK50
  bits            8
  flags SPACE_ENC|NO_HEAD_REP|CONST_LENGTH
  eps            30
  aeps          100

  header       8462  4229
  one           498  1601
  zero          498   558
  ptrail        501
  pre_data_bits   8
  pre_data       0xF1
  gap          46649
  toggle_bit      0


      begin codes
          Att                      0x0000000000000071
          Sound                    0x00000000000000B1
          Disc+                    0x0000000000000029
          Disc-                    0x00000000000000A9
          Track+                   0x0000000000000049
          Track-                   0x00000000000000C9
          Source                   0x0000000000000011
          Vol+                     0x0000000000000021
          Vol-                     0x00000000000000A1
      end codes

end remote





Ich hatte jetzt gedacht, wenn es von "außen" nicht klappt, warum dann 
nicht gleich die Fernbedienung nachbauen und das Protokoll nutzen? Aus 
den Infos von LIRC werde ich nicht schlau, da ich von 8 Bit-Befehlen 
(s.o.) noch nie was gehört habe.

Leider habe ich kein Oszi und nach längerer Suche keine Schaltung 
gefunden, mit der ich die Befehle (z.B. über Soundkarte) auslesen kann. 
Da es nur 5 Knöpfe sind, die ich "nachprogrammieren" muss, glaube ich, 
wird das die schnellste Lösung sein, die Bitmuster einfach auszulesen 
und in nem tiny zu implementieren.

Vielleicht weiß ja jemand von euch, um was es sich hier handelt.


Vielen Dank für die Hilfe,

Marco

[Gast (Gast)]

Vielleicht hilft es weiter:
http://www.techdesign.be/projects/011/011.htm
http://eldo.gotdns.com/yard/index.html

Gruß
  Mathias

[Marco (Gast)]

Ich habe hier auch was gefunden:

http://www.sbprojects.com/knowledge/ir/jvc.htm


Das scheint ganz gut zu passen. Jetzt geht es nur noch um die 
Implementierung in den uC...

Ich habe mir überlegt, alles "händisch" selbst zu machen und die 38kHz 
selbst zu erzeugen. Das mache ich mit dem Timer und in der ISR frage ich 
verschiedene Variablen ab und Toggle den Ausgang für die IR-LED (der 
Timer läuft 2*38000 Mal pro Sekunde über) in der vorgegebenen Sequenz:


1. 320 Zyklen "1" und 160 Zyklen "0"

dann eine 16 Bit-Sequenz, in der jeweils pro Bit 20 Zyklen "1" und 
darauf für
2. Logisch-0: 20 Zyklen "0"
3. Logisch-1: 60 Zyklen "0"

gesendet werden.

Ich habe jeweils an eine Schleife gedacht, in der pro Durchlauf 
hochgezählt und der Ausgangspin getoggelt wird.

D.h. für jede Sequenz 1.-3. gibt es eine eigene While-Schleife, die 
durch Fallunterscheidung durchgegangen werden. Schleife 1 zum Beginn 
nach dem Drücken einer Taste und 2. bzw. 3. beim bitweisen Durchgehen 
der Protokollcodes.


Ich bin ein wenig skeptisch, ob ich damit auf dem richtigen Weg bin. Wie 
mache ich das am elegantesten? Wo rufe ich die "Verarbeitungsfunktionen" 
am besten auf?


Gruß

[Marco (Gast)]

Nachtrag:

Mir kam eben noch die Idee, die LED zwischen zwei Pins zu hängen: Der 
eine Pin wird kontinuierlich von dem Timer-ISR auf 38kHz getoggled und 
das Ein- und Ausschalten des anderen Pins wird einfach aufmoduliert.

Nehme ich dafür dann besser einen zweiten Timer (wie wird seine ISR dann 
mit den zu sendenden Daten "von Außen" gefüttert?) oder mache ich das 
ganz primitiv ala asm-"NOP" bzw. _delay_us / _delay_ms ??

Gruß

Marco

[Marco (Gast)]

Kann jemand was mit der Idee anfangen?

Habe nochmal in den Büchern nachgelesen zur sinnvollen PWM Steuerung, 
komme aber nicht auf eine bessere Lösung.

[Abdul K. (ehydra)]

Ich erbarme mich mal:
Die Idee ist gut. Schalte zur LED antiparallel eine Diode und dazu im 
Ganzen in Serie einen Widerstand. Wenn die Diode Teil einer 
zweifarben-LED ist, hast du dann die Wahl zwischen:
- rot
- grün
- gelb
- aus

Das dann noch blinkend in beliebiger Kombination möglich.


Gruß -
A.

[Klotz (Gast)]

Bau doch einfach eine RC5 Routine aus der Codesammlung um.

Wenn du den Träger per ISR erzeugst und ein bisschen nachrechnest wirst 
du feststellen, dass die Zeiten alle Vielfache voneinander sind. Dann 
brauchst Du nur noch ein paar Zählschleifen.
Und vergiss das Stoppbit nicht!

Viel Erfolg!

[Klotz (Gast)]

Äh, verwechselt mit NEC

[ich (Gast)]

@ Marco:
Hi,
hast du deine Idee nun in die Tat umgesetzt. Bin auch an dem Projekt 
interessiert, könntest du helfen?
MfG