Terratec (NEC) Fernbedienung mit IRMP

OP #5308006
Lesenswert?

Hallo,

ich habe hier zwei Fernbedienungen, die nur teilweise mit einem 
IRMP-STM32-USB-IR-Empfänger an zwei VDRs funktionieren. Grundsätzlich 
bekomme ich per irw eine Funktion mit allen Tasten aber der VDR reagiert 
nicht auf alle. Interessant finde ich auch, dass wenn ich einen Kanal 
hochschalte zwar hochgeschaltet wird aber ca. 2 Sekunden später wieder 
zurück.

Die eine Fernbedienung ist eine Terratec Cinergy XS. Diese gab es als 
Set incl. USB Bulk und als FB für den USB DVB-T Stick. Die zweite 
Fernbedienung ist von einem COMAG Receiver SL40HD.

1. 
https://www.amazon.de/Terratec-Cinergy-Hybrid-TV-Karte-Analog/dp/B000B48T62/ref=sr_1_11?ie=UTF8&qid=1518027315&sr=8-11&keywords=terratec+fernbedienung

2. 
https://www.amazon.de/COMAG-Fernbedienung-f%C3%BCr-SL-HD25-schwarz/dp/B006KC6MT0


Ich hatte beide Fernbedienungen erfolgreich mit dem Atric Einschalter 
Rev. 5 (Seriell) an zwei VDRs betreiben.

Im VDR Portal hat User seahawk1986 herausgefunden, dass es sich bei 
beiden um Fernbedienungen mit dem NEC Protokoll handelt.

mode2 Ausgabe der Terratec Cinergy Fernbedienung:
1
space 16777215
2
pulse 9050
3
space 4456
4
pulse 610
5
space 524
6
pulse 589
7
space 518
8
pulse 616
9
space 1653
10
pulse 582
11
space 526
12
pulse 606
13
space 1663
14
pulse 582
15
space 526
16
pulse 608
17
space 526
18
pulse 607
19
space 525
20
pulse 591
21
space 1654
22
pulse 609
23
space 1633
24
pulse 614
25
space 519
26
pulse 613
27
space 1631
28
pulse 615
29
space 517
30
pulse 604
31
space 1638
32
pulse 609
33
space 1661
34
pulse 584
35
space 1657
36
pulse 610
37
space 525
38
pulse 586
39
space 522
40
pulse 610
41
space 524
42
pulse 612
43
space 522
44
pulse 590
45
space 1652
46
pulse 614
47
space 521
48
pulse 592
49
space 517
50
pulse 615
51
space 518
52
pulse 605
53
space 1638
54
pulse 606
55
space 1663
56
pulse 584
57
space 1659
58
pulse 608
59
space 1633
60
pulse 612
61
space 523

Die andere Fernbedienung lasse ich erstmal weg.

Die Frage ist, gibt es eine Tuning Möglichkeit von IRMP, um 
Fernbedienungen mit problematischem NEC Protokoll zu konfigurieren?

Danke und Gruß
Obelix
Moderator Persönliche Seite #5309630
Lesenswert?

"T." ". schrieb:
> Die Frage ist, gibt es eine Tuning Möglichkeit von IRMP, um
> Fernbedienungen mit problematischem NEC Protokoll zu konfigurieren?

Was ist denn hier "problematisch"? Das Timing?

Die NEC-Timings findest Du hier:

  https://www.mikrocontroller.net/articles/IRMP#NEC_.2B_extended_NEC

Abgesehen vom Start-Bit haben wir 560µs-Pulse und Pausen von 560µs oder 
1690µs (Space).

Deine FB benutzt jedoch Pulse von ca. 610 µs. Das ist eine Abweichung 
von ca. 10%. Um das in IRMP anzupassen, könntest Du die Werte in 
irmpprotocols.h annähern:
1
#define NEC_START_BIT_PULSE_TIME            9000.0e-6                       // 9000 usec pulse
2
#define NEC_START_BIT_PAUSE_TIME            4500.0e-6                       // 4500 usec pause
3
#define NEC_REPEAT_START_BIT_PAUSE_TIME     2250.0e-6                       // 2250 usec pause
4
#define NEC_PULSE_TIME                      560.0e-6                       //  560 usec pulse
5
#define NEC_1_PAUSE_TIME                    1690.0e-6                       // 1690 usec pause
6
#define NEC_0_PAUSE_TIME                    560.0e-6                       //  560 usec pause

Aber eigentlich sollten die Standard-Werte von IRMP völlig ausreichen, 
um alle Tasten Deiner FB zu erkennen, denn IRMP ist das ziemlich 
tolerant, was das NEC-Protokoll betrifft, siehe irmp.c:
1
#define NEC_PULSE_LEN_MIN            ((uint_fast8_t)(F_INTERRUPTS * NEC_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
2
#define NEC_PULSE_LEN_MAX            ((uint_fast8_t)(F_INTERRUPTS * NEC_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
3
#define NEC_1_PAUSE_LEN_MIN          ((uint_fast8_t)(F_INTERRUPTS * NEC_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
4
#define NEC_1_PAUSE_LEN_MAX          ((uint_fast8_t)(F_INTERRUPTS * NEC_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
5
#define NEC_0_PAUSE_LEN_MIN          ((uint_fast8_t)(F_INTERRUPTS * NEC_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
6
#define NEC_0_PAUSE_LEN_MAX          ((uint_fast8_t)(F_INTERRUPTS * NEC_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)

Das heisst, dass IRMP Abweichungen von bis zu 30% nach unten bzw. oben 
akzeptiert. Bei Deinen 10% sollte es daher kein Problem geben.

Für weitergehende Hilfe brauche ich mehr Infos. Werden bestimmte Tasten 
konsequent nicht erkannt oder nur sporadisch welche nicht erkannt? 
Weicht bei den nicht-erkannten Tasten vielleicht das Timing komplett ab? 
Was läuft sonst noch auf Deinem µC? Gibt es z.B. höher priorisierte 
Interrups? Wie ist bei Dir F_INTERRUPTS eingestellt?

Stelle F_INTERRUPTS mal auf 10000, das reicht für NEC aus.
OP #5318803
Lesenswert?

Hi,

zusammen mit Usern aus dem vdr-portal und easyVDR Forum konnten wir dem 
Problem auf den Grund gehen. Herausgekommen ist, dass der Repeat nach 
einer Pause nicht mit Null weiter geht.

Hier die irw Ausgabe. Die beiden Leerzeilen dienen der besseren 
Übersicht. Dort war die Pause.
1
1518798560.124436: 106545  02eb14001200 f KEY_OK IRMP
2
1518798560.376440: 251  02eb14001200 10 KEY_OK IRMP
3
1518798560.592438: 215  02eb14001200 11 KEY_OK IRMP
4
1518798560.808415: 215  02eb14001200 12 KEY_OK IRMP
5
1518798561.024492: 216  02eb14001200 13 KEY_OK IRMP
6
1518798561.241439: 216  02eb14001200 14 KEY_OK IRMP
7
1518798561.457488: 216  02eb14001200 15 KEY_OK IRMP
8
1518798561.673440: 215  02eb14001200 16 KEY_OK IRMP
9
1518798561.889451: 215  02eb14001200 17 KEY_OK IRMP
10

11

12
1518798573.768359: 11878  02eb14001200 18 KEY_OK IRMP
13
1518798574.020384: 252  02eb14001200 19 KEY_OK IRMP
14
1518798574.236324: 215  02eb14001200 1a KEY_OK IRMP
15
1518798574.453391: 217  02eb14001200 1b KEY_OK IRMP
16
1518798574.669348: 215  02eb14001200 1c KEY_OK IRMP
17
1518798574.885359: 215  02eb14001200 1d KEY_OK IRMP
18
1518798575.101364: 215  02eb14001200 1e KEY_OK IRMP


Gruß

Obelix
OP #5318995
Lesenswert?

Jörg R. schrieb:
> Nein, geht leider nicht.
> In der dritten Spalte von rechts werden die Repeats hochgezählt.
> Es wird also ein neuer Tastendruck nach einer Pause fälschlich als
> Wiederholung erkannt.
>
> 0belix poste mal mode2 von Tastendruck-Pause-derselbe Tastendruck.

Hier die mode2 Ausgabe der Terratec Fernbedienung:
1
space 8080916
2
pulse 9336
3
space 4176
4
pulse 672
5
space 439
6
pulse 683
7
space 434
8
pulse 668
9
space 1579
10
pulse 697
11
space 432
12
pulse 666
13
space 1581
14
pulse 671
15
space 459
16
pulse 669
17
space 454
18
pulse 649
19
space 464
20
pulse 710
21
space 1563
22
pulse 652
23
space 1620
24
pulse 641
25
space 455
26
pulse 662
27
space 1597
28
pulse 663
29
space 454
30
pulse 662
31
space 1595
32
pulse 666
33
space 1566
34
pulse 671
35
space 1611
36
pulse 644
37
space 451
38
pulse 710
39
space 1567
40
pulse 675
41
space 1568
42
pulse 663
43
space 457
44
pulse 664
45
space 450
46
pulse 683
47
space 447
48
pulse 679
49
space 454
50
pulse 662
51
space 451
52
pulse 697
53
space 1580
54
pulse 649
55
space 450
56
pulse 711
57
space 420
58
pulse 680
59
space 1588
60
pulse 675
61
space 1606
62
pulse 610
63
space 1608
64
pulse 665
65
space 1602
66
pulse 675
67
space 1568
68
pulse 635
69

70

71
space 10399963
72
pulse 9337
73
space 4206
74
pulse 666
75
space 473
76
pulse 644
77
space 470
78
pulse 643
79
space 1605
80
pulse 675
81
space 426
82
pulse 671
83
space 1605
84
pulse 649
85
space 462
86
pulse 680
87
space 432
88
pulse 676
89
space 466
90
pulse 650
91
space 1610
92
pulse 648
93
space 1603
94
pulse 648
95
space 456
96
pulse 683
97
space 1567
98
pulse 669
99
space 451
100
pulse 679
101
space 1590
102
pulse 686
103
space 1591
104
pulse 614
105
space 1616
106
pulse 645
107
space 476
108
pulse 662
109
space 1583
110
pulse 665
111
space 1601
112
pulse 649
113
space 450
114
pulse 690
115
space 453
116
pulse 650
117
space 463
118
pulse 671
119
space 451
120
pulse 679
121
space 452
122
pulse 690
123
space 1576
124
pulse 656
125
space 478
126
pulse 638
127
space 463
128
pulse 697
129
space 1569
130
pulse 638
131
space 1615
132
pulse 654
133
space 1593
134
pulse 658
135
space 1594
136
pulse 648
137
space 1593
138
pulse 680
#5319152
Lesenswert?

Mir geht gerade auf: Es werden bei den problematischen Tasten ja sogar 
alle Tastendrücke als Wiederholung erkannt, auch wenn sie neu sind.

0belix poste bitte auch den mode2 von Tastendruck-Pause-derselbe 
Tastendruck bei einer "guten" Taste. Dann sollte man den Unterschied 
sehen können.
Moderator Persönliche Seite #5319170
Lesenswert?

Jörg R. schrieb:
> Mir geht gerade auf: Es werden bei den problematischen Tasten ja sogar
> alle Tastendrücke als Wiederholung erkannt, auch wenn sie neu sind.

Was heisst neu? Unterschiedlich zum Tastendruck davor? Oder ein- und 
dieselbe Taste zweimal hintereinander kurz gedrückt?

Sehr merkwürdig. Wie groß ist denn der Abstand zwischen zwei 
Tastendrücken? IRMP benutzt bei NEC zwei Methoden, um lange Tastendrücke 
zu erkennen:

1. Es wird ein spezieller NEC-Repetition-Frame gesendet -> Wiederholung

2. Die beiden identischen(!) Frames kommen hintereinander mit
   einem Abstand von weniger als x msec rein.

Methode 2 wird nur deshalb zusätzlich angewandt, weil einige 
NEC-kompatible Fernbedienungen keinen NEC-Repetition-Frame beherrschen.
OP #5319173
Lesenswert?

Jörg R. schrieb:
> Mir geht gerade auf: Es werden bei den problematischen Tasten ja sogar
> alle Tastendrücke als Wiederholung erkannt, auch wenn sie neu sind.
>
> 0belix poste bitte auch den mode2 von Tastendruck-Pause-derselbe
> Tastendruck bei einer "guten" Taste. Dann sollte man den Unterschied
> sehen können.

Das ist die Up Taste:
1
space 16777215
2
pulse 9345
3
space 4171
4
pulse 666
5
space 468
6
pulse 649
7
space 464
8
pulse 658
9
space 1596
10
pulse 646
11
space 465
12
pulse 672
13
space 1596
14
pulse 646
15
space 464
16
pulse 672
17
space 459
18
pulse 666
19
space 469
20
pulse 675
21
space 1569
22
pulse 669
23
space 1579
24
pulse 696
25
space 435
26
pulse 665
27
space 1583
28
pulse 669
29
space 460
30
pulse 657
31
space 1591
32
pulse 698
33
space 1571
34
pulse 645
35
space 1621
36
pulse 640
37
space 469
38
pulse 652
39
space 461
40
pulse 697
41
space 422
42
pulse 678
43
space 468
44
pulse 678
45
space 1566
46
pulse 667
47
space 467
48
pulse 649
49
space 465
50
pulse 674
51
space 456
52
pulse 667
53
space 1582
54
pulse 670
55
space 1595
56
pulse 676
57
space 1591
58
pulse 642
59
space 1582
60
pulse 698
61
space 421
62
pulse 679
63
space 1580
64
pulse 671
65
space 1595
66
pulse 676
67
space 1580
68
pulse 653
69

70

71

72

73
space 9043468
74
pulse 9366
75
space 4173
76
pulse 668
77
space 441
78
pulse 666
79
space 469
80
pulse 675
81
space 1555
82
pulse 666
83
space 469
84
pulse 653
85
space 1592
86
pulse 667
87
space 458
88
pulse 661
89
space 452
90
pulse 671
91
space 459
92
pulse 679
93
space 1568
94
pulse 710
95
space 1570
96
pulse 672
97
space 425
98
pulse 684
99
space 1596
100
pulse 674
101
space 425
102
pulse 670
103
space 1609
104
pulse 648
105
space 1595
106
pulse 666
107
space 1584
108
pulse 667
109
space 461
110
pulse 667
111
space 460
112
pulse 683
113
space 425
114
pulse 710
115
space 420
116
pulse 680
117
space 1582
118
pulse 670
119
space 447
120
pulse 679
121
space 460
122
pulse 658
123
space 451
124
pulse 710
125
space 1568
126
pulse 675
127
space 1594
128
pulse 641
129
space 1582
130
pulse 670
131
space 1584
132
pulse 656
133
space 454
134
pulse 682
135
space 1604
136
pulse 665
137
space 1593
138
pulse 646
139
space 1598
140
pulse 664
Moderator Persönliche Seite #5319184
Lesenswert?

Ich habe gerade ein kleines Programm geschrieben, um Euer Space/Pulse 
Log-Format in das IRMP-Log-Format zu konvertieren.

Darauf habe ich den IRMP losgelassen.

Mode2:

00101000110101110110000010011111 p= 2 (NEC), a=0xeb14, c=0x0006, f=0x00
00101000110101110110000010011111 p= 2 (NEC), a=0xeb14, c=0x0006, f=0x00

address: 0xeb14
command: 0x0006

Es wird kein Repetition-Flag gesetzt, denn f = flag ist 0x00.

Up-Taste:

00101000110101110000100011110111 p= 2 (NEC), a=0xeb14, c=0x0010, f=0x00
00101000110101110000100011110111 p= 2 (NEC), a=0xeb14, c=0x0010, f=0x00

address: 0xeb14
command: 0x0010

Auch hier wird kein Repetition-Flag gesetzt, denn f = flag ist 0x00.

Irgendwas macht Ihr falsch bzw. anders.

Bitte die obige Frage beantworten:

Was heisst neu? Unterschiedlich zum Tastendruck davor? Oder ein- und 
dieselbe Taste zweimal hintereinander kurz gedrückt?
#5319197
Lesenswert?

0belix poste bitte die Ausgabe von stm32IRconfig im Monitor-Modus von 
Tastendrücken unterschiedlicher "schlechter" Tasten (also z.B. 0, 1, 2 
...).

Frank, in der Firmware ist ein unverändertes IRMP und andere Protokolle 
funktionieren tadellos, z.B. RC5.
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/patches/irmp.patch
Es werden nur Protokolle aktiviert, und der Port angepasst.
Moderator Persönliche Seite #5319243
Lesenswert?

Jörg R. schrieb:
> https://github.com/j1rie/IRMP_STM32/blob/master/ST...

Okay, was ich da sehe:

Es wird irmp_get_data() aufgerufen. Wenn myIRData.flags gesetzt ist, 
wird RepeatCounter hochgezählt.

Frage 1: Was ist jetzt konkret Dein Problem? Ist bei Deiner Anwendung 
RepeatCounter immer größer als 0?

Weiter unten sehe ich:

memcpy(buf, &myIRData, sizeof(myIRData));
USB_HID_SendData(REPORT_ID_IR, buf, sizeof(myIRData));

Die Datenstruktur wird also in einen buffer "buf" kopiert und 
anschließend die Funktion USB_HID_SendData() aufgerufen, bei der man 
beten muss, dass sie das STM32-typische Alignment der 
IRMP_DATA-Datenstruktur genauestens kennt.

Frage 2: Was hat das alles mit IRSND zu tun? Sendet die Anwendung auch 
etwas über IR? Oder warum sehe ich da dieses:
1
int8_t set_handler(uint8_t *buf)
2
{
3
  /* number of valid bytes in buf, -1 signifies error */
4
  int8_t ret = 3;
5
  uint8_t idx;
6
  uint8_t tmp[SIZEOF_IR];
7
  switch ((enum command) buf[2]) {
8
  case CMD_EMIT:
9
    yellow_short_on();
10
---->>>         irsnd_send_data((IRMP_DATA *) &buf[3], 1);

Frage 3: Kann es sein, dass der IR-Frame, der da reinkommt, von IRSND 
direkt wieder rausgeblasen wird und IRMP den da als Tastenwiederholung 
erkennt? Also: Ist der Sender optisch isoliert vom Empfänger? Oder 
"sieht" der Empfänger vielleicht die selbst rausgeschickten Frames des 
Senders?

Du solltest die IR-LED des Senders mal zukleben, um das zu testen.
Moderator Persönliche Seite #5319265
Lesenswert?

Was ich da noch sehe:
1
    if (!(myIRData.flags)) {
2
      RepeatCounter = 0;
3
    } else {
4
      RepeatCounter++;
5
    }

Es wird also flags auf == 0 geprüft. Das ist so nicht ganz korrekt. 
Richtig wäre:
1
    if (myIRData.flags & IRMP_FLAG_REPETITION)) {
2
      RepeatCounter++;
3
    } else {
4
      RepeatCounter = 0;
5
    }

IRMP nutzt die anderen Bits von flags durchaus für weitere 
Daten-Informationen, z.B. beim KASEIKYO-Protokoll. Sollte bei NEC aber 
zufälligerweise funktionieren.
Moderator Persönliche Seite #5319271
Lesenswert?

Jörg R. schrieb:
> Dann sieht man was über USB vom uC herein kommt. Insbesondere die flags.

Ja, das wäre sehr interessant. Hoffentlich ist das Alignment der 
IRMP-Datenstruktur bei jeder Compiler-Variante und -Version immer 
gleich.

Sauberer wäre es, statt einem memcpy()-Aufruf die Struktur-Elemente 
einzeln an die richtigen Stellen von buf[] zu kopieren.
#5319287
Lesenswert?

Frank M. schrieb:
> Frage 1: Was ist jetzt konkret Dein Problem? Ist bei Deiner Anwendung
> RepeatCounter immer größer als 0?

Davon gehe ich aus. Das Auswertungsprogramm verhält sich jedenfalls so.
100% genau weiß ich das erst, wenn 0belix meine Frage beantwortet hat.

Frank M. schrieb:
> Die Datenstruktur wird also in einen buffer "buf" kopiert und
> anschließend die Funktion USB_HID_SendData() aufgerufen, bei der man
> beten muss, dass sie das STM32-typische Alignment der
> IRMP_DATA-Datenstruktur genauestens kennt.

https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L684
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/usb_hid.c#L50
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/usb_hid.c#L14
Da wird uint8_t + uint16_t + uint16_t + uint8_t in ein uint8_t-Array 
kopiert und in uint8_t-Häppchen übertragen, das ist schon OK so.
OP #5319309
Lesenswert?

Jörg R. schrieb:
> Jörg R. schrieb:
>> 0belix poste bitte die Ausgabe von stm32IRconfig im Monitor-Modus von
>> Tastendrücken unterschiedlicher "schlechter" Tasten (also z.B. 0, 1, 2
>> ...).
>
> Dann sieht man was über USB vom uC herein kommt. Insbesondere die flags.

Hier die Ausgabe. Gedrückt habe ich die Menü Taste und die Tasten 1,2,3 
bis 0
1
read 17 bytes:
2
  01 02 14 eb 42 00 01 00 00 00 00 00 00 00 00 00 00 
3
converted to protocoladdresscommandflag:
4
  02eb14004201
5

6
read 17 bytes:
7
  01 02 14 eb 42 00 01 00 00 00 00 00 00 00 00 00 00 
8
converted to protocoladdresscommandflag:
9
  02eb14004201
10

11
read 17 bytes:
12
  01 02 14 eb 42 00 01 00 00 00 00 00 00 00 00 00 00 
13
converted to protocoladdresscommandflag:
14
  02eb14004201
15

16
read 17 bytes:
17
  01 02 14 eb 42 00 01 00 00 00 00 00 00 00 00 00 00 
18
converted to protocoladdresscommandflag:
19
  02eb14004201
20

21
read 17 bytes:
22
  01 02 14 eb 42 00 01 00 00 00 00 00 00 00 00 00 00 
23
converted to protocoladdresscommandflag:
24
  02eb14004201
25

26
read 17 bytes:
27
  01 02 14 eb 02 00 01 00 00 00 00 00 00 00 00 00 00 
28
converted to protocoladdresscommandflag:
29
  02eb14000201
30

31
read 17 bytes:
32
  01 02 14 eb 02 00 01 00 00 00 00 00 00 00 00 00 00 
33
converted to protocoladdresscommandflag:
34
  02eb14000201
35

36
read 17 bytes:
37
  01 02 14 eb 02 00 01 00 00 00 00 00 00 00 00 00 00 
38
converted to protocoladdresscommandflag:
39
  02eb14000201
40

41
read 17 bytes:
42
  01 02 14 eb 02 00 01 00 00 00 00 00 00 00 00 00 00 
43
converted to protocoladdresscommandflag:
44
  02eb14000201
45

46
read 17 bytes:
47
  01 02 14 eb 02 00 01 00 00 00 00 00 00 00 00 00 00 
48
converted to protocoladdresscommandflag:
49
  02eb14000201
50

51
read 17 bytes:
52
  01 02 14 eb 02 00 01 00 00 00 00 00 00 00 00 00 00 
53
converted to protocoladdresscommandflag:
54
  02eb14000201
55

56
read 17 bytes:
57
  01 02 14 eb 02 00 01 00 00 00 00 00 00 00 00 00 00 
58
converted to protocoladdresscommandflag:
59
  02eb14000201
60

61
read 17 bytes:
62
  01 02 14 eb 03 00 01 00 00 00 00 00 00 00 00 00 00 
63
converted to protocoladdresscommandflag:
64
  02eb14000301
65

66
read 17 bytes:
67
  01 02 14 eb 03 00 01 00 00 00 00 00 00 00 00 00 00 
68
converted to protocoladdresscommandflag:
69
  02eb14000301
70

71
read 17 bytes:
72
  01 02 14 eb 03 00 01 00 00 00 00 00 00 00 00 00 00 
73
converted to protocoladdresscommandflag:
74
  02eb14000301
75

76
read 17 bytes:
77
  01 02 14 eb 03 00 01 00 00 00 00 00 00 00 00 00 00 
78
converted to protocoladdresscommandflag:
79
  02eb14000301
80

81
read 17 bytes:
82
  01 02 14 eb 03 00 01 00 00 00 00 00 00 00 00 00 00 
83
converted to protocoladdresscommandflag:
84
  02eb14000301
85

86
read 17 bytes:
87
  01 02 14 eb 03 00 01 00 00 00 00 00 00 00 00 00 00 
88
converted to protocoladdresscommandflag:
89
  02eb14000301
90

91
read 17 bytes:
92
  01 02 14 eb 03 00 01 00 00 00 00 00 00 00 00 00 00 
93
converted to protocoladdresscommandflag:
94
  02eb14000301
95

96
read 17 bytes:
97
  01 02 14 eb 03 00 01 00 00 00 00 00 00 00 00 00 00 
98
converted to protocoladdresscommandflag:
99
  02eb14000301
100

101
read 17 bytes:
102
  01 02 14 eb 03 00 01 00 00 00 00 00 00 00 00 00 00 
103
converted to protocoladdresscommandflag:
104
  02eb14000301
105

106
read 17 bytes:
107
  01 02 14 eb 03 00 01 00 00 00 00 00 00 00 00 00 00 
108
converted to protocoladdresscommandflag:
109
  02eb14000301
110

111
read 17 bytes:
112
  01 02 14 eb 04 00 01 00 00 00 00 00 00 00 00 00 00 
113
converted to protocoladdresscommandflag:
114
  02eb14000401
115

116
read 17 bytes:
117
  01 02 14 eb 04 00 01 00 00 00 00 00 00 00 00 00 00 
118
converted to protocoladdresscommandflag:
119
  02eb14000401
120

121
read 17 bytes:
122
  01 02 14 eb 04 00 01 00 00 00 00 00 00 00 00 00 00 
123
converted to protocoladdresscommandflag:
124
  02eb14000401
125

126
read 17 bytes:
127
  01 02 14 eb 04 00 01 00 00 00 00 00 00 00 00 00 00 
128
converted to protocoladdresscommandflag:
129
  02eb14000401
130

131
read 17 bytes:
132
  01 02 14 eb 04 00 01 00 00 00 00 00 00 00 00 00 00 
133
converted to protocoladdresscommandflag:
134
  02eb14000401
135

136
read 17 bytes:
137
  01 02 14 eb 04 00 01 00 00 00 00 00 00 00 00 00 00 
138
converted to protocoladdresscommandflag:
139
  02eb14000401
140

141
read 17 bytes:
142
  01 02 14 eb 04 00 01 00 00 00 00 00 00 00 00 00 00 
143
converted to protocoladdresscommandflag:
144
  02eb14000401
145

146
read 17 bytes:
147
  01 02 14 eb 04 00 01 00 00 00 00 00 00 00 00 00 00 
148
converted to protocoladdresscommandflag:
149
  02eb14000401
150

151
read 17 bytes:
152
  01 02 14 eb 04 00 01 00 00 00 00 00 00 00 00 00 00 
153
converted to protocoladdresscommandflag:
154
  02eb14000401
155

156
read 17 bytes:
157
  01 02 14 eb 05 00 01 00 00 00 00 00 00 00 00 00 00 
158
converted to protocoladdresscommandflag:
159
  02eb14000501
160

161
read 17 bytes:
162
  01 02 14 eb 05 00 01 00 00 00 00 00 00 00 00 00 00 
163
converted to protocoladdresscommandflag:
164
  02eb14000501
165

166
read 17 bytes:
167
  01 02 14 eb 05 00 01 00 00 00 00 00 00 00 00 00 00 
168
converted to protocoladdresscommandflag:
169
  02eb14000501
170

171
read 17 bytes:
172
  01 02 14 eb 05 00 01 00 00 00 00 00 00 00 00 00 00 
173
converted to protocoladdresscommandflag:
174
  02eb14000501
175

176
read 17 bytes:
177
  01 02 14 eb 05 00 01 00 00 00 00 00 00 00 00 00 00 
178
converted to protocoladdresscommandflag:
179
  02eb14000501
180

181
read 17 bytes:
182
  01 02 14 eb 05 00 01 00 00 00 00 00 00 00 00 00 00 
183
converted to protocoladdresscommandflag:
184
  02eb14000501
185

186
read 17 bytes:
187
  01 02 14 eb 05 00 01 00 00 00 00 00 00 00 00 00 00 
188
converted to protocoladdresscommandflag:
189
  02eb14000501
190

191
read 17 bytes:
192
  01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00 
193
converted to protocoladdresscommandflag:
194
  02eb14000601
195

196
read 17 bytes:
197
  01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00 
198
converted to protocoladdresscommandflag:
199
  02eb14000601
200

201
read 17 bytes:
202
  01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00 
203
converted to protocoladdresscommandflag:
204
  02eb14000601
205

206
read 17 bytes:
207
  01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00 
208
converted to protocoladdresscommandflag:
209
  02eb14000601
210

211
read 17 bytes:
212
  01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00 
213
converted to protocoladdresscommandflag:
214
  02eb14000601
215

216
read 17 bytes:
217
  01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00 
218
converted to protocoladdresscommandflag:
219
  02eb14000601
220

221
read 17 bytes:
222
  01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00 
223
converted to protocoladdresscommandflag:
224
  02eb14000601
225

226
read 17 bytes:
227
  01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00 
228
converted to protocoladdresscommandflag:
229
  02eb14000601
230

231
read 17 bytes:
232
  01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00 
233
converted to protocoladdresscommandflag:
234
  02eb14000601
235

236
read 17 bytes:
237
  01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00 
238
converted to protocoladdresscommandflag:
239
  02eb14000601
240

241
read 17 bytes:
242
  01 02 14 eb 07 00 01 00 00 00 00 00 00 00 00 00 00 
243
converted to protocoladdresscommandflag:
244
  02eb14000701
245

246
read 17 bytes:
247
  01 02 14 eb 07 00 01 00 00 00 00 00 00 00 00 00 00 
248
converted to protocoladdresscommandflag:
249
  02eb14000701
250

251
read 17 bytes:
252
  01 02 14 eb 07 00 01 00 00 00 00 00 00 00 00 00 00 
253
converted to protocoladdresscommandflag:
254
  02eb14000701
255

256
read 17 bytes:
257
  01 02 14 eb 07 00 01 00 00 00 00 00 00 00 00 00 00 
258
converted to protocoladdresscommandflag:
259
  02eb14000701
260

261
read 17 bytes:
262
  01 02 14 eb 07 00 01 00 00 00 00 00 00 00 00 00 00 
263
converted to protocoladdresscommandflag:
264
  02eb14000701
265

266
read 17 bytes:
267
  01 02 14 eb 07 00 01 00 00 00 00 00 00 00 00 00 00 
268
converted to protocoladdresscommandflag:
269
  02eb14000701
270

271
read 17 bytes:
272
  01 02 14 eb 07 00 01 00 00 00 00 00 00 00 00 00 00 
273
converted to protocoladdresscommandflag:
274
  02eb14000701
275

276
read 17 bytes:
277
  01 02 14 eb 07 00 01 00 00 00 00 00 00 00 00 00 00 
278
converted to protocoladdresscommandflag:
279
  02eb14000701
280

281
read 17 bytes:
282
  01 02 14 eb 08 00 01 00 00 00 00 00 00 00 00 00 00 
283
converted to protocoladdresscommandflag:
284
  02eb14000801
285

286
read 17 bytes:
287
  01 02 14 eb 08 00 01 00 00 00 00 00 00 00 00 00 00 
288
converted to protocoladdresscommandflag:
289
  02eb14000801
290

291
read 17 bytes:
292
  01 02 14 eb 08 00 01 00 00 00 00 00 00 00 00 00 00 
293
converted to protocoladdresscommandflag:
294
  02eb14000801
295

296
read 17 bytes:
297
  01 02 14 eb 08 00 01 00 00 00 00 00 00 00 00 00 00 
298
converted to protocoladdresscommandflag:
299
  02eb14000801
300

301
read 17 bytes:
302
  01 02 14 eb 08 00 01 00 00 00 00 00 00 00 00 00 00 
303
converted to protocoladdresscommandflag:
304
  02eb14000801
305

306
read 17 bytes:
307
  01 02 14 eb 08 00 01 00 00 00 00 00 00 00 00 00 00 
308
converted to protocoladdresscommandflag:
309
  02eb14000801
310

311
read 17 bytes:
312
  01 02 14 eb 08 00 01 00 00 00 00 00 00 00 00 00 00 
313
converted to protocoladdresscommandflag:
314
  02eb14000801
315

316
read 17 bytes:
317
  01 02 14 eb 08 00 01 00 00 00 00 00 00 00 00 00 00 
318
converted to protocoladdresscommandflag:
319
  02eb14000801
320

321
read 17 bytes:
322
  01 02 14 eb 09 00 01 00 00 00 00 00 00 00 00 00 00 
323
converted to protocoladdresscommandflag:
324
  02eb14000901
325

326
read 17 bytes:
327
  01 02 14 eb 09 00 01 00 00 00 00 00 00 00 00 00 00 
328
converted to protocoladdresscommandflag:
329
  02eb14000901
330

331
read 17 bytes:
332
  01 02 14 eb 09 00 01 00 00 00 00 00 00 00 00 00 00 
333
converted to protocoladdresscommandflag:
334
  02eb14000901
335

336
read 17 bytes:
337
  01 02 14 eb 09 00 01 00 00 00 00 00 00 00 00 00 00 
338
converted to protocoladdresscommandflag:
339
  02eb14000901
340

341
read 17 bytes:
342
  01 02 14 eb 09 00 01 00 00 00 00 00 00 00 00 00 00 
343
converted to protocoladdresscommandflag:
344
  02eb14000901
345

346
read 17 bytes:
347
  01 02 14 eb 09 00 01 00 00 00 00 00 00 00 00 00 00 
348
converted to protocoladdresscommandflag:
349
  02eb14000901
350

351
read 17 bytes:
352
  01 02 14 eb 09 00 01 00 00 00 00 00 00 00 00 00 00 
353
converted to protocoladdresscommandflag:
354
  02eb14000901
355

356
read 17 bytes:
357
  01 02 14 eb 09 00 01 00 00 00 00 00 00 00 00 00 00 
358
converted to protocoladdresscommandflag:
359
  02eb14000901
360

361
read 17 bytes:
362
  01 02 14 eb 09 00 01 00 00 00 00 00 00 00 00 00 00 
363
converted to protocoladdresscommandflag:
364
  02eb14000901
365

366
read 17 bytes:
367
  01 02 14 eb 09 00 01 00 00 00 00 00 00 00 00 00 00 
368
converted to protocoladdresscommandflag:
369
  02eb14000901
370

371
read 17 bytes:
372
  01 02 14 eb 0a 00 01 00 00 00 00 00 00 00 00 00 00 
373
converted to protocoladdresscommandflag:
374
  02eb14000a01
375

376
read 17 bytes:
377
  01 02 14 eb 0a 00 01 00 00 00 00 00 00 00 00 00 00 
378
converted to protocoladdresscommandflag:
379
  02eb14000a01
380

381
read 17 bytes:
382
  01 02 14 eb 0a 00 01 00 00 00 00 00 00 00 00 00 00 
383
converted to protocoladdresscommandflag:
384
  02eb14000a01
385

386
read 17 bytes:
387
  01 02 14 eb 0a 00 01 00 00 00 00 00 00 00 00 00 00 
388
converted to protocoladdresscommandflag:
389
  02eb14000a01
390

391
read 17 bytes:
392
  01 02 14 eb 0a 00 01 00 00 00 00 00 00 00 00 00 00 
393
converted to protocoladdresscommandflag:
394
  02eb14000a01
395

396
read 17 bytes:
397
  01 02 14 eb 0a 00 01 00 00 00 00 00 00 00 00 00 00 
398
converted to protocoladdresscommandflag:
399
  02eb14000a01
400

401
read 17 bytes:
402
  01 02 14 eb 0a 00 01 00 00 00 00 00 00 00 00 00 00 
403
converted to protocoladdresscommandflag:
404
  02eb14000a01
405

406
read 17 bytes:
407
  01 02 14 eb 0a 00 01 00 00 00 00 00 00 00 00 00 00 
408
converted to protocoladdresscommandflag:
409
  02eb14000a01
410

411
read 17 bytes:
412
  01 02 14 eb 0a 00 01 00 00 00 00 00 00 00 00 00 00 
413
converted to protocoladdresscommandflag:
414
  02eb14000a01
415

416
read 17 bytes:
417
  01 02 14 eb 0c 00 01 00 00 00 00 00 00 00 00 00 00 
418
converted to protocoladdresscommandflag:
419
  02eb14000c01
420

421
read 17 bytes:
422
  01 02 14 eb 0c 00 01 00 00 00 00 00 00 00 00 00 00 
423
converted to protocoladdresscommandflag:
424
  02eb14000c01
425

426
read 17 bytes:
427
  01 02 14 eb 0c 00 01 00 00 00 00 00 00 00 00 00 00 
428
converted to protocoladdresscommandflag:
429
  02eb14000c01
430

431
read 17 bytes:
432
  01 02 14 eb 0c 00 01 00 00 00 00 00 00 00 00 00 00 
433
converted to protocoladdresscommandflag:
434
  02eb14000c01
435

436
read 17 bytes:
437
  01 02 14 eb 0c 00 01 00 00 00 00 00 00 00 00 00 00 
438
converted to protocoladdresscommandflag:
439
  02eb14000c01
440

441
read 17 bytes:
442
  01 02 14 eb 0c 00 01 00 00 00 00 00 00 00 00 00 00 
443
converted to protocoladdresscommandflag:
444
  02eb14000c01
445

446
read 17 bytes:
447
  01 02 14 eb 0c 00 01 00 00 00 00 00 00 00 00 00 00 
448
converted to protocoladdresscommandflag:
449
  02eb14000c01
450

451
read 17 bytes:
452
  01 02 14 eb 0c 00 01 00 00 00 00 00 00 00 00 00 00 
453
converted to protocoladdresscommandflag:
454
  02eb14000c01
455

456
read 17 bytes:
457
  01 02 14 eb 0c 00 01 00 00 00 00 00 00 00 00 00 00 
458
converted to protocoladdresscommandflag:
459
  02eb14000c01
#5319318
Lesenswert?

Danke für den Hinweis mit der myIRData.flags Auswertung. Das werde ich 
dann so einbauen.

Frank M. schrieb:
> Hoffentlich ist das Alignment der
> IRMP-Datenstruktur bei jeder Compiler-Variante und -Version immer
> gleich.
>
> Sauberer wäre es, statt einem memcpy()-Aufruf die Struktur-Elemente
> einzeln an die richtigen Stellen von buf[] zu kopieren.

Das hatte ich anfangs mal so. Wie es jetzt ist, finde ich aber 
eleganter. Das funktioniert, weil IRMP_DATA ja das _attribute_ 
((_packed_)) hat.
Moderator Persönliche Seite #5319322
Lesenswert?

Jörg R. schrieb:
> Da wird uint8_t + uint16_t + uint16_t + uint8_t in ein uint8_t-Array
> kopiert und in uint8_t-Häppchen übertragen, das ist schon OK so.

Das glaube ich erstmal so nicht. ;-)

Wenn ich es richtig in Erinnerung habe, werden auf einem STM32 i.d.R. 
die Struktur-Elemente auf 32 Bit ausgerichtet.

Dann sieht auf einem STM32 die Struktur physikalisch so aus:
1
1 Byte  protocol
2
3 Byte  Füllbytes
3
2 Byte  address
4
2 Byte  Füllbytes
5
2 Byte  command
6
2 Byte  Füllbytes
7
1 Byte  flags
8
3 Byte  Füllbytes

Wenn man die Struktur allerdings packt (per Pragma oder über 
Compiler-Flag), sieht diese ganz anders aus.

Wird das bei der späteren Auswertung vom uint8_t-Array so 
berücksichtigt?

Beachte bitte auch meine obige Anmerkung zu IRMP_FLAG_REPETITION, was in 
der Auswertung von flags fehlt. Ich empfehle bei dieser Gelegenheit, 
auch nur (flags & IRMP_FLAG_REPETITION) in das uint8_t-Array zu kopieren 
oder bei der späteren Auswertung von flags im uint8_t-Array die 
entsprechende Stelle im Array ausschließlich auf dieses eine Bit zu 
prüfen - falls flags da überhaupt irgendwie inhaltlich ausgewertet wird.
#5319351
Lesenswert?

0belix, bitte poste dasselbe mit RC5, nur um Frank zu überzeugen.

Frank, ich bin mir ziemlich sicher, dass das so richtig ist.
Zumindest funktioniert das seit Jahren, und ich habe das damals genau 
untersucht und war mir der Problematik bewußt.

Das IRMP_FLAG_REPETITION werde ich einbauen, aber du meintest doch bei 
dem Problem hier spielt es keine Rolle?
Moderator Persönliche Seite #5319357
Lesenswert?

Noch etwas ist mir aufgefallen:

usb_hid.h:
1
#define  HID_IN_BUFFER_SIZE  17  /* ((1...64)+1) STM32->PC */
2
#define  HID_OUT_BUFFER_SIZE  17  /* ((1...64)+1) PC->STM32 */

usb_hid.c
1
uint8_t USB_HID_OUT_BUF[HID_OUT_BUFFER_SIZE]; /* PC->STM32 */
2
uint8_t USB_HID_IN_BUF[HID_IN_BUFFER_SIZE]; /* STM32->PC */

aber in main.c:
1
uint8_t buf[HID_OUT_BUFFER_SIZE-1], RepeatCounter = 0;

Hier ist der buffer 'buf' ein Byte kürzer, aber ausreichend, denn der 
memcpy kopiert nur 16 Bytes. Okay, ich sehe, Du brauchst später ein Byte 
mehr in USB_HID_SendData(), das habe ich verstanden. Scheint also auf 
den 2. Blick doch kein Problem zu sein.

Ich hatte nämlich erst befürchtet, dass durch einen Buffer-Overflow 
genau die dahinter definierte Variable RepeatCounter evtl. überschrieben 
wird. Aber das scheint doch wasserdicht zu sein.
#5319359
Lesenswert?

Gepackt sieht die Struktur physikalisch so aus:
1 Byte  protocol
2 Byte  address
2 Byte  command
1 Byte  flags
und das passt perfekt zum uint8_t-Array:
1 Byte
1 Byte
1 Byte
1 Byte
1 Byte
1 Byte
Endian habe ich auch berücksichtigt.

Ich mache dann mal eine neue Firmware mit korrektem 
IRMP_FLAG_REPETITION.
Moderator Persönliche Seite #5319365
Lesenswert?

Jörg R. schrieb:
> 0belix, bitte poste dasselbe mit RC5, nur um Frank zu überzeugen.

Erstmal würde ich gerne den das uint8_t-Array sehen mit einer 
funktionierenden NEC-Taste und mit einer nicht-funktionierenden 
NEC-Taste sehen, idealerweise genau mit den beiden Tasten oben, nämlich 
MODE2 und UP-Taste. Dann kann ich die von IRMP ermittelten Werte mit 
denen im Array befindlichen abgleichen.

Oder ist es so, dass jetzt bei allen NEC-Tasten flags != 0 ist??? Ich 
steige hier langsam nicht mehr durch ;-)

RC5 ist in dem Zusammenhang eher uninteressant.

Jörg R. schrieb:
> Das IRMP_FLAG_REPETITION werde ich einbauen, aber du meintest doch bei
> dem Problem hier spielt es keine Rolle?

Bei NEC spielt es keine Rolle, bei anderen Protokollen wie KASEIKYO 
schon. Daher war das eher eine allgemeine Anmerkung meinerseits.
Moderator Persönliche Seite #5319380
Lesenswert?

Jörg R. schrieb:
> Gepackt sieht die Struktur physikalisch so aus:
> 1 Byte  protocol
> 2 Byte  address
> 2 Byte  command
> 1 Byte  flags
> und das passt perfekt zum uint8_t-Array:
> 1 Byte
> 1 Byte
> 1 Byte
> 1 Byte
> 1 Byte
> 1 Byte
> Endian habe ich auch berücksichtigt.

Upps, das war mir doch glatt entfallen, dass ich vor 3 Jahren die 
Struktur ab Revision 151 (Jan 19 11:04:00 2015 UTC) gepackt hatte.

irmpsystem.h:
1
#if defined(PIC_C18)
2
#define IRMP_PACKED_STRUCT
3
#else
4
#define IRMP_PACKED_STRUCT              __attribute__ ((__packed__))
5
#endif
6

7
typedef struct IRMP_PACKED_STRUCT
8
{
9
    uint8_t                             protocol;                                   // protocol, e.g. NEC_PROTOCOL
10
    uint16_t                            address;                                    // address
11
    uint16_t                            command;                                    // command
12
    uint8_t                             flags;                                      // flags, e.g. repetition
13
} IRMP_DATA;

Okay, dann sollte es passen. Ich nehme nicht an, dass Obelix einen 
älteren IRMP-Source verwendet.
Moderator Persönliche Seite #5319443
Lesenswert?

Jörg R. schrieb:
> Ich habe es jetzt so verbessert:

Gut.

Noch zwei Empfehlungen:

1. Der Buffer 'uint8_t buf[HID_OUT_BUFFER_SIZE-1]' in main.c liegt auf 
dem Stack. Daher ist es nicht garantiert, dass alle 16 Bytes darin = 0 
sind. Da Du später die gepackte Struct (6 Bytes) per memcpy kopierst, 
bleiben die letzten 10 Stellen im Buffer undefiniert. In der späteren 
Funktion USB_HID_SendData() kopierst Du dann aber alle 16 Stellen und 
damit 10 Bytes Schrott. Wenn das nicht stört - auch gut.

Aber ich empfehle Dir, am Anfang von main() das Array einmal(!) zu 
nullen, z.B. per
1
memset (buf, 0, HID_OUT_BUFFER_SIZE-1);

2. Es kann sein, dass ich irgendwann in Zukunft das Packing der Struct 
wieder rauswerfe. Denn glücklich bin ich darüber eigentlich nicht, z.B. 
wegen Performance-Einbußen - gerade in einer ISR. Ich empfehle Dir 
daher, um kompatibel zu bleiben, den memcpy() zu ersetzen durch:
1
buf[0] = myIRData.protocol;
2
buf[1] = myIRData.address & 0xFF;
3
buf[2] = myIRData.address >> 8;
4
buf[3] = myIRData.command & 0xFF;
5
buf[4] = myIRData.command >> 8;
6
buf[5] = myIRData.flags;

Dann bist Du auf der sicheren Seite.
#5319646
Lesenswert?

Frank M. schrieb:
> In der späteren
> Funktion USB_HID_SendData() kopierst Du dann aber alle 16 Stellen und
> damit 10 Bytes Schrott. Wenn das nicht stört - auch gut.

Es gibt drei Stellen, an denen USB_HID_SendData() aufgerufen wird:
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L708
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L739
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L775
An jeder der drei wird nur soviel kopiert, wie benötigt.
Der Rest wird mit Nullen gefüllt:
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/usb_hid.c#L68

Frank M. schrieb:
> Es kann sein, dass ich irgendwann in Zukunft das Packing der Struct
> wieder rauswerfe.

Wenn du das Packing der Struct wieder raus wirfst, muss ich an vielen 
Stellen was anpassen, nicht nur an der einen memcpy() Stelle. Denn es 
wären ja alle Stellen, an denen ich IRMP_DATA Daten benutze, betroffen.
Ich hatte das früher mal, der Code war viel aufgeblähter.
Und wahrscheinlich bin ich nicht der Einzige, der dann viel anpassen 
müßte.

Aber mehr Performance ist immer gut, und wäre die Arbeit wert.
Moderator Persönliche Seite #5319650
Lesenswert?

Jörg R. schrieb:
> Hat aber bisher nie gestört.

Kann gut sein. Es ist auch unwahrscheinlich, dass eine Stack-Variable in 
main() irgendeinen Unsinn enthält. Das passiert eher in einer 
Unterfunktion. Aber darauf würde ich mich nicht verlassen.

Beispiel:
1
#include <stdio.h>
2

3
void a (void)
4
{
5
   int v1[3] = { 1, 2, 3 };
6

7
   printf ("v1 = %d %d %d\n", v1[0], v1[1], v1[2]);
8
}
9

10
void b (void)
11
{
12
   int v2[3];
13

14
   printf ("v2 = %d %d %d\n", v2[0], v2[1], v2[2]);
15
}
16

17
int main ()
18
{
19
    a ();
20
    b ();
21

22
    return 0;
23
}
1
$ cc stack.c -o stack && ./stack
2
v1 = 1 2 3
3
v2 = 1 2 3

memset() in b() würde das Problem lösen.
OP #5320160
Lesenswert?

Jörg R. schrieb:
> 0belix, dann also bitte die Ausgabe von stm32IRconfig im Monitor-Modus
> mit "guten" Tasten (Leiser / Lauter, Kanal + / Kanal - und vom
> Steuerkreutz die Pfeiltasten).
> Dann können wir das uint8_t-Array mit guten und schlechten Tasten
> vergleichen.

Guten Morgen, war gestern ab Nachmittag unterwegs.... Hier die Ausgabe 
in der genannten Reihenfolge:
1
read 17 bytes:
2
  01 02 14 eb 1e 00 01 00 00 00 00 00 00 00 00 00 00 
3
converted to protocoladdresscommandflag:
4
  02eb14001e01
5

6
read 17 bytes:
7
  01 02 14 eb 1e 00 01 00 00 00 00 00 00 00 00 00 00 
8
converted to protocoladdresscommandflag:
9
  02eb14001e01
10

11
read 17 bytes:
12
  01 02 14 eb 1e 00 01 00 00 00 00 00 00 00 00 00 00 
13
converted to protocoladdresscommandflag:
14
  02eb14001e01
15

16
read 17 bytes:
17
  01 02 14 eb 1e 00 01 00 00 00 00 00 00 00 00 00 00 
18
converted to protocoladdresscommandflag:
19
  02eb14001e01
20

21
read 17 bytes:
22
  01 02 14 eb 1e 00 01 00 00 00 00 00 00 00 00 00 00 
23
converted to protocoladdresscommandflag:
24
  02eb14001e01
25

26
read 17 bytes:
27
  01 02 14 eb 1e 00 01 00 00 00 00 00 00 00 00 00 00 
28
converted to protocoladdresscommandflag:
29
  02eb14001e01
30

31
read 17 bytes:
32
  01 02 14 eb 1e 00 01 00 00 00 00 00 00 00 00 00 00 
33
converted to protocoladdresscommandflag:
34
  02eb14001e01
35

36
read 17 bytes:
37
  01 02 14 eb 1e 00 01 00 00 00 00 00 00 00 00 00 00 
38
converted to protocoladdresscommandflag:
39
  02eb14001e01
40

41
read 17 bytes:
42
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
43
converted to protocoladdresscommandflag:
44
  02eb14001c01
45

46
read 17 bytes:
47
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
48
converted to protocoladdresscommandflag:
49
  02eb14001c01
50

51
read 17 bytes:
52
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
53
converted to protocoladdresscommandflag:
54
  02eb14001c01
55

56
read 17 bytes:
57
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
58
converted to protocoladdresscommandflag:
59
  02eb14001c01
60

61
read 17 bytes:
62
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
63
converted to protocoladdresscommandflag:
64
  02eb14001c01
65

66
read 17 bytes:
67
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
68
converted to protocoladdresscommandflag:
69
  02eb14001c01
70

71
read 17 bytes:
72
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
73
converted to protocoladdresscommandflag:
74
  02eb14001c01
75

76
read 17 bytes:
77
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
78
converted to protocoladdresscommandflag:
79
  02eb14001c01
80

81
read 17 bytes:
82
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
83
converted to protocoladdresscommandflag:
84
  02eb14001c01
85

86
read 17 bytes:
87
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
88
converted to protocoladdresscommandflag:
89
  02eb14001c01
90

91
read 17 bytes:
92
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
93
converted to protocoladdresscommandflag:
94
  02eb14001c01
95

96
read 17 bytes:
97
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
98
converted to protocoladdresscommandflag:
99
  02eb14001b01
100

101
read 17 bytes:
102
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
103
converted to protocoladdresscommandflag:
104
  02eb14001b01
105

106
read 17 bytes:
107
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
108
converted to protocoladdresscommandflag:
109
  02eb14001b01
110

111
read 17 bytes:
112
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
113
converted to protocoladdresscommandflag:
114
  02eb14001b01
115

116
read 17 bytes:
117
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
118
converted to protocoladdresscommandflag:
119
  02eb14001b01
120

121
read 17 bytes:
122
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
123
converted to protocoladdresscommandflag:
124
  02eb14001b01
125

126
read 17 bytes:
127
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
128
converted to protocoladdresscommandflag:
129
  02eb14001b01
130

131
read 17 bytes:
132
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
133
converted to protocoladdresscommandflag:
134
  02eb14001b01
135

136
read 17 bytes:
137
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
138
converted to protocoladdresscommandflag:
139
  02eb14001b01
140

141
read 17 bytes:
142
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
143
converted to protocoladdresscommandflag:
144
  02eb14001b01
145

146
read 17 bytes:
147
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
148
converted to protocoladdresscommandflag:
149
  02eb14001b01
150

151
read 17 bytes:
152
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
153
converted to protocoladdresscommandflag:
154
  02eb14001b01
155

156
read 17 bytes:
157
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
158
converted to protocoladdresscommandflag:
159
  02eb14001f01
160

161
read 17 bytes:
162
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
163
converted to protocoladdresscommandflag:
164
  02eb14001f01
165

166
read 17 bytes:
167
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
168
converted to protocoladdresscommandflag:
169
  02eb14001f01
170

171
read 17 bytes:
172
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
173
converted to protocoladdresscommandflag:
174
  02eb14001f01
175

176
read 17 bytes:
177
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
178
converted to protocoladdresscommandflag:
179
  02eb14001f01
180

181
read 17 bytes:
182
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
183
converted to protocoladdresscommandflag:
184
  02eb14001f01
185

186
read 17 bytes:
187
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
188
converted to protocoladdresscommandflag:
189
  02eb14001f01
190

191
read 17 bytes:
192
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
193
converted to protocoladdresscommandflag:
194
  02eb14001f01
195

196
read 17 bytes:
197
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
198
converted to protocoladdresscommandflag:
199
  02eb14001f01
200

201
read 17 bytes:
202
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
203
converted to protocoladdresscommandflag:
204
  02eb14001f01
205

206
read 17 bytes:
207
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
208
converted to protocoladdresscommandflag:
209
  02eb14001f01
210

211
read 17 bytes:
212
  01 02 14 eb 1f 00 01 00 00 00 00 00 00 00 00 00 00 
213
converted to protocoladdresscommandflag:
214
  02eb14001f01
215

216
read 17 bytes:
217
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
218
converted to protocoladdresscommandflag:
219
  02eb14001101
220

221
read 17 bytes:
222
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
223
converted to protocoladdresscommandflag:
224
  02eb14001101
225

226
read 17 bytes:
227
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
228
converted to protocoladdresscommandflag:
229
  02eb14001101
230

231
read 17 bytes:
232
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
233
converted to protocoladdresscommandflag:
234
  02eb14001101
235

236
read 17 bytes:
237
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
238
converted to protocoladdresscommandflag:
239
  02eb14001101
240

241
read 17 bytes:
242
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
243
converted to protocoladdresscommandflag:
244
  02eb14001101
245

246
read 17 bytes:
247
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
248
converted to protocoladdresscommandflag:
249
  02eb14001101
250

251
read 17 bytes:
252
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
253
converted to protocoladdresscommandflag:
254
  02eb14001101
255

256
read 17 bytes:
257
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
258
converted to protocoladdresscommandflag:
259
  02eb14001101
260

261
read 17 bytes:
262
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
263
converted to protocoladdresscommandflag:
264
  02eb14001101
265

266
read 17 bytes:
267
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
268
converted to protocoladdresscommandflag:
269
  02eb14001101
270

271
read 17 bytes:
272
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
273
converted to protocoladdresscommandflag:
274
  02eb14001101
275

276
read 17 bytes:
277
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
278
converted to protocoladdresscommandflag:
279
  02eb14001101
280

281
read 17 bytes:
282
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
283
converted to protocoladdresscommandflag:
284
  02eb14001101
285

286
read 17 bytes:
287
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
288
converted to protocoladdresscommandflag:
289
  02eb14001101
290

291
read 17 bytes:
292
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
293
converted to protocoladdresscommandflag:
294
  02eb14001101
295

296
read 17 bytes:
297
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
298
converted to protocoladdresscommandflag:
299
  02eb14001101
300

301
read 17 bytes:
302
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
303
converted to protocoladdresscommandflag:
304
  02eb14001101
305

306
read 17 bytes:
307
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
308
converted to protocoladdresscommandflag:
309
  02eb14001301
310

311
read 17 bytes:
312
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
313
converted to protocoladdresscommandflag:
314
  02eb14001301
315

316
read 17 bytes:
317
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
318
converted to protocoladdresscommandflag:
319
  02eb14001301
320

321
read 17 bytes:
322
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
323
converted to protocoladdresscommandflag:
324
  02eb14001301
325

326
read 17 bytes:
327
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
328
converted to protocoladdresscommandflag:
329
  02eb14001301
330

331
read 17 bytes:
332
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
333
converted to protocoladdresscommandflag:
334
  02eb14001301
335

336
read 17 bytes:
337
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
338
converted to protocoladdresscommandflag:
339
  02eb14001301
340

341
read 17 bytes:
342
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
343
converted to protocoladdresscommandflag:
344
  02eb14001301
345

346
read 17 bytes:
347
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
348
converted to protocoladdresscommandflag:
349
  02eb14001301
350

351
read 17 bytes:
352
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
353
converted to protocoladdresscommandflag:
354
  02eb14001301
355

356
read 17 bytes:
357
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
358
converted to protocoladdresscommandflag:
359
  02eb14001301
360

361
read 17 bytes:
362
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
363
converted to protocoladdresscommandflag:
364
  02eb14001301
365

366
read 17 bytes:
367
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
368
converted to protocoladdresscommandflag:
369
  02eb14001301
370

371
read 17 bytes:
372
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
373
converted to protocoladdresscommandflag:
374
  02eb14001301
375

376
read 17 bytes:
377
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
378
converted to protocoladdresscommandflag:
379
  02eb14001001
380

381
read 17 bytes:
382
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
383
converted to protocoladdresscommandflag:
384
  02eb14001001
385

386
read 17 bytes:
387
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
388
converted to protocoladdresscommandflag:
389
  02eb14001001
390

391
read 17 bytes:
392
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
393
converted to protocoladdresscommandflag:
394
  02eb14001001
395

396
read 17 bytes:
397
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
398
converted to protocoladdresscommandflag:
399
  02eb14001001
400

401
read 17 bytes:
402
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
403
converted to protocoladdresscommandflag:
404
  02eb14001001
405

406
read 17 bytes:
407
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
408
converted to protocoladdresscommandflag:
409
  02eb14001001
410

411
read 17 bytes:
412
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
413
converted to protocoladdresscommandflag:
414
  02eb14001001
415

416
read 17 bytes:
417
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
418
converted to protocoladdresscommandflag:
419
  02eb14001001
420

421
read 17 bytes:
422
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
423
converted to protocoladdresscommandflag:
424
  02eb14001001
425

426
read 17 bytes:
427
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
428
converted to protocoladdresscommandflag:
429
  02eb14001001
430

431
read 17 bytes:
432
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
433
converted to protocoladdresscommandflag:
434
  02eb14001001
435

436
read 17 bytes:
437
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
438
converted to protocoladdresscommandflag:
439
  02eb14001001
440

441
read 17 bytes:
442
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
443
converted to protocoladdresscommandflag:
444
  02eb14001001
445

446
read 17 bytes:
447
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
448
converted to protocoladdresscommandflag:
449
  02eb14001001
450

451
read 17 bytes:
452
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
453
converted to protocoladdresscommandflag:
454
  02eb14001001
455

456
read 17 bytes:
457
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
458
converted to protocoladdresscommandflag:
459
  02eb14001401
460

461
read 17 bytes:
462
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
463
converted to protocoladdresscommandflag:
464
  02eb14001401
465

466
read 17 bytes:
467
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
468
converted to protocoladdresscommandflag:
469
  02eb14001401
470

471
read 17 bytes:
472
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
473
converted to protocoladdresscommandflag:
474
  02eb14001401
475

476
read 17 bytes:
477
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
478
converted to protocoladdresscommandflag:
479
  02eb14001401
480

481
read 17 bytes:
482
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
483
converted to protocoladdresscommandflag:
484
  02eb14001401
485

486
read 17 bytes:
487
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
488
converted to protocoladdresscommandflag:
489
  02eb14001401
490

491
read 17 bytes:
492
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
493
converted to protocoladdresscommandflag:
494
  02eb14001401
495

496
read 17 bytes:
497
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
498
converted to protocoladdresscommandflag:
499
  02eb14001401
500

501
read 17 bytes:
502
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
503
converted to protocoladdresscommandflag:
504
  02eb14001401
505

506
read 17 bytes:
507
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
508
converted to protocoladdresscommandflag:
509
  02eb14001401
510

511
read 17 bytes:
512
  01 02 14 eb 14 00 01 00 00 00 00 00 00 00 00 00 00 
513
converted to protocoladdresscommandflag:
514
  02eb14001401
Moderator Persönliche Seite #5320408
Lesenswert?

Ist das normal, dass da ein- und derselbe Code ein paar dutzend Mal 
wiederholt wird?

Jörg R. schrieb:
> Rätselhaft, die "Guten" haben auch trotz neuem Key das
> Wiederholungsflag.
> Wie können die dann "gut" sein?!

Wann ist denn ein Code "gut"? Was ist denn das Kriterium?

Ich habe bereits im IRMP-Source gesucht, ob bei irgendwelchen 
Eventualitäten das Repetition-Flag in flags vom vorhergehenden Lauf 
versehentlich nicht gelöscht wird. Ich kann so einen Fall aber leider 
nicht konstruieren.

Man könnte natürlich mal vor Aufruf von irmp_get_data() das 
myIRData.flags versuchsweise explizit löschen.
#5320448
Lesenswert?

Frank M. schrieb:
> Ist das normal, dass da ein- und derselbe Code ein paar dutzend Mal
> wiederholt wird?

Wenn er etwas länger drückt, ja.

Frank M. schrieb:
> Wann ist denn ein Code "gut"?

Mit "gut" waren die Tasten gemeint, die seiner Beschreibung nach gehen.

Sind eigentlich die Protokolle 
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/patches/irmp.patch 
alle miteinander kompatibel?

0belix, bitte poste die Ausgabe von stm32IRconfig - g - c (get 
capabilities), und zur Sicherheit auch von ein paar RC5 Tasten 
(stm32IRconfig - m).
Moderator Persönliche Seite #5320505
Lesenswert?

Jörg R. schrieb:
> Wenn er etwas länger drückt, ja.

Da hat er aber verdammt lang gedrückt. Kann da was bei einer derartigen 
Befeuerung verloren gehen?

> Mit "gut" waren die Tasten gemeint, die seiner Beschreibung nach gehen.

Ich sehe nur, dass die Codes, die oben stehen, alle vom IRMP erkannt 
werden. Leider hat Obelix nicht näher beschrieben, was er da gemacht hat 
und ob da Ausgaben bei bestimmten Tastendrücken fehlen.

> Sind eigentlich die Protokolle
> https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/patches/irmp.patch
> alle miteinander kompatibel?

Ich habe eben mal alle Protokolle eingeschaltet, die Du auch 
eingeschaltet hast und dann nochmal den konvertierten Pulse/Pause-Log 
von oben in den IRMP geschoben: Beide Tasten (bezeichnet mit Mode2 und 
Up) wurden erkannt - mit flag = 0x00.

Das wäre noch interessant:

Frank M. schrieb:
> Man könnte natürlich mal vor Aufruf von irmp_get_data() das
> myIRData.flags versuchsweise explizit löschen.

Eine andere Idee habe ich im Moment auch nicht. Sehr merkwürdig, das 
Ganze.
OP #5320536
Lesenswert?

Jetzt weiß ich was du gemeint hast. Hier die Ausgabe:
1
written 17 bytes:
2
  03 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 
3

4
read 17 bytes:
5
  02 01 00 01 08 08 08 00 00 00 00 00 00 00 00 00 00 
6

7
macro_slots: 8
8
macro_depth: 8
9
wake_slots: 8
10

11

12
written 17 bytes:
13
  03 00 00 01 01 00 00 00 00 00 00 00 00 00 00 00 00 
14

15
read 17 bytes:
16
  02 01 00 01 01 02 03 05 14 1b 1c 04 08 07 09 15 18 
17

18
protocols: 1 2 3 5 20 27 28 4 8 7 9 21 24 
19

20
written 17 bytes:
21
  03 00 00 01 02 00 00 00 00 00 00 00 00 00 00 00 00 
22

23
read 17 bytes:
24
  02 01 00 01 0f 11 10 00 00 00 00 00 00 00 00 00 00 
25

26
protocols: 15 17 16
OP #5320545
Lesenswert?

Und hier die Ausgabe einer RC5 FB:
1
read 17 bytes:
2
  01 07 0b 00 48 00 00 00 00 00 00 00 00 00 00 00 00 
3
converted to protocoladdresscommandflag:
4
  07000b004800
5

6
read 17 bytes:
7
  01 07 0b 00 48 00 01 00 00 00 00 00 00 00 00 00 00 
8
converted to protocoladdresscommandflag:
9
  07000b004801
10

11
read 17 bytes:
12
  01 07 0b 00 44 00 00 00 00 00 00 00 00 00 00 00 00 
13
converted to protocoladdresscommandflag:
14
  07000b004400
15

16
read 17 bytes:
17
  01 07 0b 00 44 00 01 00 00 00 00 00 00 00 00 00 00 
18
converted to protocoladdresscommandflag:
19
  07000b004401
20

21
read 17 bytes:
22
  01 07 0b 00 47 00 00 00 00 00 00 00 00 00 00 00 00 
23
converted to protocoladdresscommandflag:
24
  07000b004700
25

26
read 17 bytes:
27
  01 07 0b 00 47 00 01 00 00 00 00 00 00 00 00 00 00 
28
converted to protocoladdresscommandflag:
29
  07000b004701
30

31
read 17 bytes:
32
  01 07 0b 00 47 00 01 00 00 00 00 00 00 00 00 00 00 
33
converted to protocoladdresscommandflag:
34
  07000b004701
35

36
read 17 bytes:
37
  01 07 0b 00 45 00 00 00 00 00 00 00 00 00 00 00 00 
38
converted to protocoladdresscommandflag:
39
  07000b004500
40

41
read 17 bytes:
42
  01 07 0b 00 45 00 01 00 00 00 00 00 00 00 00 00 00 
43
converted to protocoladdresscommandflag:
44
  07000b004501
45

46
read 17 bytes:
47
  01 07 0b 00 45 00 01 00 00 00 00 00 00 00 00 00 00 
48
converted to protocoladdresscommandflag:
49
  07000b004501
50

51
read 17 bytes:
52
  01 07 0b 00 45 00 01 00 00 00 00 00 00 00 00 00 00 
53
converted to protocoladdresscommandflag:
54
  07000b004501
55

56
read 17 bytes:
57
  01 07 0b 00 45 00 01 00 00 00 00 00 00 00 00 00 00 
58
converted to protocoladdresscommandflag:
59
  07000b004501
60

61
read 17 bytes:
62
  01 07 0b 00 46 00 00 00 00 00 00 00 00 00 00 00 00 
63
converted to protocoladdresscommandflag:
64
  07000b004600
65

66
read 17 bytes:
67
  01 07 0b 00 46 00 01 00 00 00 00 00 00 00 00 00 00 
68
converted to protocoladdresscommandflag:
69
  07000b004601
70

71
read 17 bytes:
72
  01 07 0b 00 46 00 01 00 00 00 00 00 00 00 00 00 00 
73
converted to protocoladdresscommandflag:
74
  07000b004601
75

76
read 17 bytes:
77
  01 07 0b 00 46 00 01 00 00 00 00 00 00 00 00 00 00 
78
converted to protocoladdresscommandflag:
79
  07000b004601
80

81
read 17 bytes:
82
  01 07 0b 00 46 00 01 00 00 00 00 00 00 00 00 00 00 
83
converted to protocoladdresscommandflag:
84
  07000b004601
85

86
read 17 bytes:
87
  01 07 0b 00 49 00 00 00 00 00 00 00 00 00 00 00 00 
88
converted to protocoladdresscommandflag:
89
  07000b004900
90

91
read 17 bytes:
92
  01 07 0b 00 49 00 01 00 00 00 00 00 00 00 00 00 00 
93
converted to protocoladdresscommandflag:
94
  07000b004901
95

96
read 17 bytes:
97
  01 07 0b 00 49 00 01 00 00 00 00 00 00 00 00 00 00 
98
converted to protocoladdresscommandflag:
99
  07000b004901
100

101
read 17 bytes:
102
  01 07 0b 00 49 00 01 00 00 00 00 00 00 00 00 00 00 
103
converted to protocoladdresscommandflag:
104
  07000b004901
105

106
read 17 bytes:
107
  01 07 0b 00 49 00 01 00 00 00 00 00 00 00 00 00 00 
108
converted to protocoladdresscommandflag:
109
  07000b004901
110

111
read 17 bytes:
112
  01 07 0b 00 4a 00 00 00 00 00 00 00 00 00 00 00 00 
113
converted to protocoladdresscommandflag:
114
  07000b004a00
115

116
read 17 bytes:
117
  01 07 0b 00 4a 00 01 00 00 00 00 00 00 00 00 00 00 
118
converted to protocoladdresscommandflag:
119
  07000b004a01
120

121
read 17 bytes:
122
  01 07 0b 00 4a 00 01 00 00 00 00 00 00 00 00 00 00 
123
converted to protocoladdresscommandflag:
124
  07000b004a01
125

126
read 17 bytes:
127
  01 07 0b 00 4a 00 01 00 00 00 00 00 00 00 00 00 00 
128
converted to protocoladdresscommandflag:
129
  07000b004a01
130

131
read 17 bytes:
132
  01 07 0b 00 4a 00 01 00 00 00 00 00 00 00 00 00 00 
133
converted to protocoladdresscommandflag:
134
  07000b004a01
135

136
read 17 bytes:
137
  01 07 0b 00 4a 00 01 00 00 00 00 00 00 00 00 00 00 
138
converted to protocoladdresscommandflag:
139
  07000b004a01
140

141
read 17 bytes:
142
  01 07 0b 00 4c 00 00 00 00 00 00 00 00 00 00 00 00 
143
converted to protocoladdresscommandflag:
144
  07000b004c00
145

146
read 17 bytes:
147
  01 07 0b 00 4c 00 01 00 00 00 00 00 00 00 00 00 00 
148
converted to protocoladdresscommandflag:
149
  07000b004c01
150

151
read 17 bytes:
152
  01 07 0b 00 4c 00 01 00 00 00 00 00 00 00 00 00 00 
153
converted to protocoladdresscommandflag:
154
  07000b004c01
155

156
read 17 bytes:
157
  01 07 0b 00 4c 00 01 00 00 00 00 00 00 00 00 00 00 
158
converted to protocoladdresscommandflag:
159
  07000b004c01
160

161
read 17 bytes:
162
  01 07 0b 00 4c 00 01 00 00 00 00 00 00 00 00 00 00 
163
converted to protocoladdresscommandflag:
164
  07000b004c01
165

166
read 17 bytes:
167
  01 07 0b 00 4b 00 00 00 00 00 00 00 00 00 00 00 00 
168
converted to protocoladdresscommandflag:
169
  07000b004b00
170

171
read 17 bytes:
172
  01 07 0b 00 4b 00 01 00 00 00 00 00 00 00 00 00 00 
173
converted to protocoladdresscommandflag:
174
  07000b004b01
175

176
read 17 bytes:
177
  01 07 0b 00 4b 00 01 00 00 00 00 00 00 00 00 00 00 
178
converted to protocoladdresscommandflag:
179
  07000b004b01
180

181
read 17 bytes:
182
  01 07 0b 00 4b 00 01 00 00 00 00 00 00 00 00 00 00 
183
converted to protocoladdresscommandflag:
184
  07000b004b01
185

186
read 17 bytes:
187
  01 07 0b 00 4b 00 01 00 00 00 00 00 00 00 00 00 00 
188
converted to protocoladdresscommandflag:
189
  07000b004b01
Moderator Persönliche Seite #5320578
Lesenswert?

"T." ". schrieb:
> Jetzt weiß ich was du gemeint hast. Hier die Ausgabe:

Die Ausgabe wovon? Was hast Du da gedrückt?

> written 17
> bytes:
>   03 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00

An Jörg: Was ist das? Wahrscheinlich darf ich alles, was nicht mit 01 
beginnt, ignorieren, weil es nichts mit IRMP zu tun hat?

> [...]

Auch mit dem Rest kann ich persönlich nichts anfangen. Da muss Jörg was 
zu sagen.

"T." ". schrieb:
> Und hier die Ausgabe einer RC5 FB:read 17 bytes:
>   01 07 0b 00 48 00 00 00 00 00 00 00 00 00 00 00 00
> converted to protocoladdresscommandflag:
>   07000b004800
>
> read 17 bytes:
>   01 07 0b 00 48 00 01 00 00 00 00 00 00 00 00 00 00
> converted to protocoladdresscommandflag:
>   07000b004801

Damit kann ich was anfangen: Protokoll RC5, beim ersten mal mit flags = 
0x00, also keine Wiederholung, beim zweiten Mal dieselbe Taste mit flags 
= 0x01, also Wiederholung.

@Obelix: Bitte zukünftig die Tasten nicht soooo lange drücken, dann wird 
die Liste nicht so lang und damit übersichtlicher.
#5320582
Lesenswert?

Frank M. schrieb:
> Da hat er aber verdammt lang gedrückt. Kann da was bei einer derartigen
> Befeuerung verloren gehen?

Nein, erst ab 255 mal.

"T." ". schrieb:
> protocols: 1 2 3 5 20 27 28 4 8 7 9 21 24
> protocols: 15 17 16

Das sind die Nummern der eingebauten Protokolle.

"T." ". schrieb:
> converted to protocoladdresscommandflag:
>   07000b004800

RC5 geht tadellos.

Frank M. schrieb:
> Man könnte natürlich mal vor Aufruf von irmp_get_data() das
> myIRData.flags versuchsweise explizit löschen.

0belix, drücke bitte ganz kurz eine RC5 Taste und dann eine NEC Taste 
und poste stm32IRconfig - m. Wichtig ist dabei die RC5 Taste so kurz zu 
drücken, dass nur eine Ausgabe kommt. Also mit spitzem Finger ganz 
kurz hacken. Es darf nur die Ausgabe mit 00 am Ende sein.
Mal sehen ob das dem NEC hilft.
OP #5320629
Lesenswert?

Jörg R. schrieb:
> 0belix, drücke bitte ganz kurz eine RC5 Taste und dann eine NEC Taste
> und poste stm32IRconfig - m. Wichtig ist dabei die RC5 Taste so kurz zu
> drücken, dass nur eine Ausgabe kommt. Also mit spitzem Finger ganz
> kurz hacken. Es darf nur die Ausgabe mit 00 am Ende sein.
> Mal sehen ob das dem NEC hilft.

Taste 5 von NEC:
1
read 17 bytes:
2
  01 02 14 eb 06 00 00 00 00 00 00 00 00 00 00 00 00 
3
converted to protocoladdresscommandflag:
4
  02eb14000600

Taste 5 von RC5:
1
read 17 bytes:
2
  01 07 0b 00 05 00 00 00 00 00 00 00 00 00 00 00 00 
3
converted to protocoladdresscommandflag:
4
  07000b000500
OP #5320635
Lesenswert?

Jörg R. schrieb:
> Welche hast du zuerst gedrückt?

Erst NEC dann RC5. Hier die Ausgabe von erst von RC5 und dann NEC:

Taste 5 RC5:
1
read 17 bytes:
2
  01 07 0b 00 05 00 00 00 00 00 00 00 00 00 00 00 00 
3
converted to protocoladdresscommandflag:
4
  07000b000500

Taste 5 NEC:
1
read 17 bytes:
2
  01 02 14 eb 06 00 00 00 00 00 00 00 00 00 00 00 00 
3
converted to protocoladdresscommandflag:
4
  02eb14000600
OP #5320651
Lesenswert?

Jörg R. schrieb:
> Krass. Jetzt hat das NEC plötzlich flags 0. Auch vor dem RC5.
>
> Spiel mal ein bischen rum und erkunde, wovon es abhängt, ob du bei neuer
> Taste NEC flags 0 oder 1 bekommst.

Bitte:
1
read 17 bytes:
2
  01 02 14 eb 02 00 01 00 00 00 00 00 00 00 00 00 00 
3
converted to protocoladdresscommandflag:
4
  02eb14000201
5

6
read 17 bytes:
7
  01 02 14 eb 03 00 00 00 00 00 00 00 00 00 00 00 00 
8
converted to protocoladdresscommandflag:
9
  02eb14000300
10

11
read 17 bytes:
12
  01 02 14 eb 04 00 01 00 00 00 00 00 00 00 00 00 00 
13
converted to protocoladdresscommandflag:
14
  02eb14000401
15

16
read 17 bytes:
17
  01 02 14 eb 05 00 00 00 00 00 00 00 00 00 00 00 00 
18
converted to protocoladdresscommandflag:
19
  02eb14000500
20

21
read 17 bytes:
22
  01 02 14 eb 06 00 00 00 00 00 00 00 00 00 00 00 00 
23
converted to protocoladdresscommandflag:
24
  02eb14000600
25

26
read 17 bytes:
27
  01 02 14 eb 07 00 00 00 00 00 00 00 00 00 00 00 00 
28
converted to protocoladdresscommandflag:
29
  02eb14000700
30

31
read 17 bytes:
32
  01 02 14 eb 08 00 01 00 00 00 00 00 00 00 00 00 00 
33
converted to protocoladdresscommandflag:
34
  02eb14000801
35

36
read 17 bytes:
37
  01 02 14 eb 09 00 01 00 00 00 00 00 00 00 00 00 00 
38
converted to protocoladdresscommandflag:
39
  02eb14000901
40

41
read 17 bytes:
42
  01 02 14 eb 0a 00 00 00 00 00 00 00 00 00 00 00 00 
43
converted to protocoladdresscommandflag:
44
  02eb14000a00
45

46
read 17 bytes:
47
  01 02 14 eb 10 00 01 00 00 00 00 00 00 00 00 00 00 
48
converted to protocoladdresscommandflag:
49
  02eb14001001
50

51
read 17 bytes:
52
  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00 
53
converted to protocoladdresscommandflag:
54
  02eb14001101
55

56
read 17 bytes:
57
  01 02 14 eb 14 00 00 00 00 00 00 00 00 00 00 00 00 
58
converted to protocoladdresscommandflag:
59
  02eb14001400
60

61
read 17 bytes:
62
  01 02 14 eb 13 00 01 00 00 00 00 00 00 00 00 00 00 
63
converted to protocoladdresscommandflag:
64
  02eb14001301
65

66
read 17 bytes:
67
  01 02 14 eb 12 00 01 00 00 00 00 00 00 00 00 00 00 
68
converted to protocoladdresscommandflag:
69
  02eb14001201
70

71
read 17 bytes:
72
  01 02 14 eb 1c 00 01 00 00 00 00 00 00 00 00 00 00 
73
converted to protocoladdresscommandflag:
74
  02eb14001c01
75

76
read 17 bytes:
77
  01 02 14 eb 1e 00 00 00 00 00 00 00 00 00 00 00 00 
78
converted to protocoladdresscommandflag:
79
  02eb14001e00
80

81
read 17 bytes:
82
  01 02 14 eb 1b 00 01 00 00 00 00 00 00 00 00 00 00 
83
converted to protocoladdresscommandflag:
84
  02eb14001b01
85

86
read 17 bytes:
87
  01 02 14 eb 1f 00 00 00 00 00 00 00 00 00 00 00 00 
88
converted to protocoladdresscommandflag:
89
  02eb14001f00

Ich habe unterschiedliche Tasten nur einmal gedrückt.
OP #5320664
Lesenswert?

Ist das eigentlich normal, dass stm32IRconfig und irw unterschiedliche 
Ausgaben haben?

Taste 5 stm32IRconfig (monitor):
1
read 17 bytes:
2
  01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00 
3
converted to protocoladdresscommandflag:
4
  02eb14000601

Taste 5 irw (nicht gepatcht):
1
02eb14000600 3 KEY_5 IRMP

Oder ist das das was du mit den Flags gemeint hast?
Moderator Persönliche Seite #5320688
Lesenswert?

"T." ". schrieb:
> read 17 bytes:
>   01 02 14 eb 02 00 01 00 00 00 00 00 00 00 00 00 00
> converted to protocoladdresscommandflag:
>   02eb14000201

protocol = NEC, address = EB14, command = 0002, flags = 0x01

> read 17 bytes:
>   01 02 14 eb 03 00 00 00 00 00 00 00 00 00 00 00 00
> converted to protocoladdresscommandflag:
>   02eb14000300

protocol = NEC, address = EB14, command = 0003, flags = 0x00

> read 17 bytes:
>   01 02 14 eb 04 00 01 00 00 00 00 00 00 00 00 00 00
> converted to protocoladdresscommandflag:
>   02eb14000401

protocol = NEC, address = EB14, command = 0004, flags = 0x01

> read 17 bytes:
>   01 02 14 eb 05 00 00 00 00 00 00 00 00 00 00 00 00
> converted to protocoladdresscommandflag:
>   02eb14000500

protocol = NEC, address = EB14, command = 0005, flags = 0x00

Für mich sieht bisher das so aus:

Immer, wenn command einen geraden Wert hat, ist flags gesetzt.

Stimmt aber nicht immer:

> read 17 bytes:
>  01 02 14 eb 11 00 01 00 00 00 00 00 00 00 00 00 00
> converted to protocoladdresscommandflag:
>  02eb14001101

protocol = NEC, address = EB14, command = 0011, flags = 0x01

@Obelix: Du hast aus dieser Liste nichts rausgelöscht, oder?
Moderator Persönliche Seite #5320766
Lesenswert?

"T." ". schrieb:
> Frank M. schrieb:
> @Obelix: Du hast aus dieser Liste nichts rausgelöscht, oder?
>
> Nein.

Da bin ich jetzt ratlos. Aber eine Idee habe ich noch:

@Jörg:

Ich habe mir mal Deine Funktionen check_macros() usw. angeschaut. Ist 
das richtig, dass Du die IRMP-Daten inkl. flags mit EEPROM-Inhalten 
abgleichst?

Ich vermute mal, dass im EEPROM angelernte IRMP-Daten stecken. Aber 
warum inkl. flags? Dann matchen sie ja nur, wenn auch das flag identisch 
ist!

Angenommen, es werden IRMP-Daten mit flags = 1 im EEPROM gespeichert. 
Dann muss ich danach die Taste immer lange drücken, damit sie überhaupt 
eine Funktion erfüllt?

Andersherum: es werden IRMP-Daten mit flags = 0 im EEPROM gespeichert. 
Dann wirken Wiederholungen (zum Beispiel Lautstärke-Taste) gar nicht und 
ich muss die Lautstärke-Taste 30x hintereinander drücken (statt 1x 
lange), um 30 Stufen runterzudrehen?

Frage: Wann erscheinen die Daten im obigen Log vom Obelix? Wenn sie 
matchen? Oder immer? Wenn sie nur geloggt werden, wenn sie matchen, dann 
erkläre ich das Verhalten so: Im EEPROM sind Daten mit flags = 0x01 
gespeichert und der vorher empfangene Frame mit 0x00 wird im Log 
unterdrückt.

Das Speichern/Vergleichen der Daten inkl. Flags halte ich erstmal für 
unsinnig. Aber vielleicht hast Du da noch eine andere Erklärung, die 
mich umstimmt ;-)
#5320997
Lesenswert?

"T." ". schrieb:
> Ist das eigentlich normal, dass stm32IRconfig und irw unterschiedliche
> Ausgaben haben?
>
> Taste 5 stm32IRconfig (monitor):
> read 17 bytes:
>   01 02 14 eb 06 00 01 00 00 00 00 00 00 00 00 00 00
> converted to protocoladdresscommandflag:
>   02eb14000601
> Taste 5 irw (nicht gepatcht):
> 02eb14000600 3 KEY_5 IRMP

irw zeigt an, was irmplircd ausgibt. irmplircd läßt die flags weg, und 
benutzt statt dessen einen Zähler. Der ist 0 beim ersten Tastendruck, 
und zählt mit jeder Wiederholung +1 hoch.
flags sieht man also hier: 02eb140006*01* oder indirekt am Hochzählen in 
irw: 02eb14000600 3 KEY_5 IRMP

Frank M. schrieb:
> Ist
> das richtig, dass Du die IRMP-Daten inkl. flags mit EEPROM-Inhalten
> abgleichst?

Für das PC aufwecken z.B. 
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L437 
wird flags genullt. Das sollte überall so sein, müßte ich mal prüfen 
bzw. ins README schreiben (wenn man von Hand eingibt).

Frank M. schrieb:
> Dann wirken Wiederholungen (zum Beispiel Lautstärke-Taste) gar nicht und
> ich muss die Lautstärke-Taste 30x hintereinander drücken (statt 1x
> lange), um 30 Stufen runterzudrehen?

Nein, denn dafür wird ja nichts mit dem Eeprom verglichen, sondern 
erster Tastendruck plus 29 Repeats werden an die Anwendung weiter 
gegeben.

Frank M. schrieb:
> Frage: Wann erscheinen die Daten im obigen Log vom Obelix?

https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L749
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L775
werden ja in jeder Schleife abgearbeitet, also erscheinen sie praktisch 
sofort (außer wenn IR gesendet wird, denn dann ist ja der Empfang lahm 
gelegt).

Frank M. schrieb:
> Das Speichern/Vergleichen der Daten inkl. Flags halte ich erstmal für
> unsinnig. Aber vielleicht hast Du da noch eine andere Erklärung, die
> mich umstimmt ;-)

Weil jede Eeprom Einheit 2 Bytes aufnimmt, paßte ein IRMP_DATA in 3 
Eeprom Einheiten: 
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L326 
. Ob mit oder ohne flags. Beim Vergleichen ist der Code 
eleganter/einfacher, wenn die flags mit verglichen werden, aber 
aufbauend auf der Voraussetzung das sie vorher genullt wurden. Das 
könnte ich aber tatsächlich mal überarbeiten.

Unterm Strich haben wir immer noch keine Erklärung dafür, warum bei 
0belix's NEC Fernbedienung die flags beim ersten Tastendruck ohne 
erkennbares System mal richtig und mal falsch kommen.

Was mir noch auffällt ist, dass bei allen NEC Tests vor dem RC5 Test 
immer flags 1 war, und dass es seitdem mal 0 und mal 1 ist.

Ich weiß aber nicht, was ich da noch machen könnte.
Wenn ich die Fernbedienung hätte, könnte ich theoretisch mal einen 
Debugger anschmeissen, oder printf's einbauen oder IRMP loggen lassen.
So fällt mit erst mal nichts mehr ein.

Eine Idee doch noch: 0belix, was passiert, wenn du deine Harmony 
Universal-FB mal auf NEC stellst? Geht es dann?
OP #5321288
Lesenswert?

Jörg R. schrieb:
> "Online bietet Logitech eine Datenbank mit den Steuercodes für über
> 225.000 Geräte von mehr als 5.000 Herstellern."
> 
http://www.chip.de/news/Logitech-Harmony-300-Volksfernbedienung-im-Test-42778181.html
> Und da ist kein NEC dabei?!

Sorry, über diesen Weg natürlich. Dafür muss ich aber wissen, welcher 
Hersteller NEC benutzt.... Ich versuche mal mein Glück...
OP #5321289
Lesenswert?

Jörg R. schrieb:
> Jörg R. schrieb:
>> Was mir noch auffällt ist, dass bei allen NEC Tests vor dem RC5 Test
>> immer flags 1 war, und dass es seitdem mal 0 und mal 1 ist.
>
> Das könnte daran liegen, dass er zwischendurch die Firmware upgedatet
> hat, was wiederum bedeutet, dass
> https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L756
> ein bißchen geholfen hat.

Nein, ich habe noch kein Update installiert. Es ist weiterhin Version 
2018-01-05_14-37_Red_BL_SC_jrie.bin installiert.
Moderator Persönliche Seite #5321441
Lesenswert?

Jörg R. schrieb:
> Für das PC aufwecken z.B.
> https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L437
> wird flags genullt. Das sollte überall so sein, müßte ich mal prüfen
> bzw. ins README schreiben (wenn man von Hand eingibt).

Ich habe mir mal store_new_wakeup() angeschaut:
1
void store_new_wakeup(void)
2
{
3
  uint8_t idx;
4
  IRMP_DATA wakeup_IRData;
5
  toggle_LED();
6
  /* 5 seconds to press button on remote */
7
  delay_ms(5000);
8
  if (irmp_get_data(&wakeup_IRData)) {
9
    wakeup_IRData.flags = 0;
10
    idx = (MACRO_DEPTH + 1) * SIZEOF_IR/2 * MACRO_SLOTS;
11
    /* store received wakeup IRData in first wakeup slot */
12
    eeprom_store(idx, (uint8_t *) &wakeup_IRData);
13
    toggle_LED();
14
  }
15
}

Es kann unter Umständen passieren, dass im IRMP-Buffer immer noch Daten 
vom zuletzt empfangenen Frame "lauern", weil sie noch nicht per 
irmp_get_data() abgeholt wurden. Dein Aufruf von irmp_get_data() liest 
dann eventuell einen alten Frame aus.

Genau das Problem hatte ich mal beim Anlernen in 
DIY Lernfähige Fernbedienung mit IRMP.

Die Lösung ist simpel:

Vor dem Aufruf von delay_ms(5000) einbauen:
1
     irmp_get_data(&wakeup_IRData); // flush input of irmp data

Dabei den Rückgabewert ignorieren. Danach hat der User 5 Sekunden Zeit, 
seine Taste zu drücken.

> Was mir noch auffällt ist, dass bei allen NEC Tests vor dem RC5 Test
> immer flags 1 war, und dass es seitdem mal 0 und mal 1 ist.

Ich habe nochmal im irmp-Source gesucht, ob es da eine Lücke bzgl. flags 
gibt.

Und ich bin fündig geworden. Es gibt nur eine Stelle im IRMP-Source, wo 
irmp_flags genullt wird:
1
        case IRMP_NEC_PROTOCOL:
2
             if ((irmp_command >> 8) == (~irmp_command & 0x00FF))
3
             {
4
                 irmp_command &= 0xff;
5
                 rtc = TRUE;
6
             }
7
        ....
8
        if (rtc)
9
        {
10
            irmp_data_p->protocol = irmp_protocol;
11
            irmp_data_p->address = irmp_address;
12
            irmp_data_p->command = irmp_command;
13
            irmp_data_p->flags   = irmp_flags;
14
            irmp_command = 0;
15
            irmp_address = 0;
16
            irmp_flags   = 0;
17
        }

Das heisst:

Falls ein NEC-Frame empfangen wurde, wo das Upper-Byte vom command NICHT 
dem invertierten Lower-Byte entspricht, wird rtc nicht gesetzt, d.h. der 
Frame wird verworfen. Aber die evtl. gesetzte interne Variable 
irmp_flags wird dann leider NICHT auf 0 zurückgesetzt.

Es kommt offenbar bei der FB von Obelix bei bestimmten Tasten zu 
Übertragungsfehlern und dabei kann ein evtl. vormals gesetztes 
Repetition-Bit stehenbleiben.

@Obelix: Kannst Du den obigen if-Block mal testweise ändern?

Alt:
1
        if (rtc)
2
        {
3
            irmp_data_p->protocol = irmp_protocol;
4
            irmp_data_p->address = irmp_address;
5
            irmp_data_p->command = irmp_command;
6
            irmp_data_p->flags   = irmp_flags;
7
            irmp_command = 0;
8
            irmp_address = 0;
9
            irmp_flags   = 0;
10
        }

Neu:
1
        if (rtc)
2
        {
3
            irmp_data_p->protocol = irmp_protocol;
4
            irmp_data_p->address = irmp_address;
5
            irmp_data_p->command = irmp_command;
6
            irmp_data_p->flags   = irmp_flags;
7
        }
8

9
        irmp_command = 0;
10
        irmp_address = 0;
11
        irmp_flags   = 0;

Das if-Statement solltest Du in Zeile 2461 finden.

EDIT:
Es kann aber auch sein, dass diese FB bei bestimmten Tasten die Regel 
generell nicht einhält, dass das Kommando aus nicht-invertierten und 
invertierten Kommando-Bits besteht. Dann verhält sie sich nicht 
NEC-standardkonform. Die obige Korrektur ist aber auf jeden Fall 
sinnvoll. Kommt ins nächste Release.
OP #5322126
Lesenswert?

Hier die stm32config Monitor Ausgabe der anderen NEC FB:
1
read 17 bytes:
2
  01 02 00 bf 45 00 01 00 00 00 00 00 00 00 00 00 00 
3
converted to protocoladdresscommandflag:
4
  02bf00004501
5

6
read 17 bytes:
7
  01 02 00 bf 05 00 01 00 00 00 00 00 00 00 00 00 00 
8
converted to protocoladdresscommandflag:
9
  02bf00000501
10

11
read 17 bytes:
12
  01 02 00 bf 06 00 01 00 00 00 00 00 00 00 00 00 00 
13
converted to protocoladdresscommandflag:
14
  02bf00000601
15

16
read 17 bytes:
17
  01 02 00 bf 16 00 00 00 00 00 00 00 00 00 00 00 00 
18
converted to protocoladdresscommandflag:
19
  02bf00001600
20

21
read 17 bytes:
22
  01 02 00 bf 5a 00 00 00 00 00 00 00 00 00 00 00 00 
23
converted to protocoladdresscommandflag:
24
  02bf00005a00
25

26
read 17 bytes:
27
  01 02 00 bf 1b 00 01 00 00 00 00 00 00 00 00 00 00 
28
converted to protocoladdresscommandflag:
29
  02bf00001b01
30

31
read 17 bytes:
32
  01 02 00 bf 1a 00 01 00 00 00 00 00 00 00 00 00 00 
33
converted to protocoladdresscommandflag:
34
  02bf00001a01
35

36
read 17 bytes:
37
  01 02 00 bf 52 00 01 00 00 00 00 00 00 00 00 00 00 
38
converted to protocoladdresscommandflag:
39
  02bf00005201
40

41
read 17 bytes:
42
  01 02 00 bf 50 00 01 00 00 00 00 00 00 00 00 00 00 
43
converted to protocoladdresscommandflag:
44
  02bf00005001
45

46
read 17 bytes:
47
  01 02 00 bf 10 00 01 00 00 00 00 00 00 00 00 00 00 
48
converted to protocoladdresscommandflag:
49
  02bf00001001
50

51
read 17 bytes:
52
  01 02 00 bf 56 00 01 00 00 00 00 00 00 00 00 00 00 
53
converted to protocoladdresscommandflag:
54
  02bf00005601
55

56
read 17 bytes:
57
  01 02 00 bf 54 00 01 00 00 00 00 00 00 00 00 00 00 
58
converted to protocoladdresscommandflag:
59
  02bf00005401
60

61
read 17 bytes:
62
  01 02 00 bf 14 00 01 00 00 00 00 00 00 00 00 00 00 
63
converted to protocoladdresscommandflag:
64
  02bf00001401
65

66
read 17 bytes:
67
  01 02 00 bf 4e 00 01 00 00 00 00 00 00 00 00 00 00 
68
converted to protocoladdresscommandflag:
69
  02bf00004e01
70

71
read 17 bytes:
72
  01 02 00 bf 4c 00 01 00 00 00 00 00 00 00 00 00 00 
73
converted to protocoladdresscommandflag:
74
  02bf00004c01
75

76
read 17 bytes:
77
  01 02 00 bf 0f 00 01 00 00 00 00 00 00 00 00 00 00 
78
converted to protocoladdresscommandflag:
79
  02bf00000f01

Gedrückt habe ich die Tasten: Menü, Exit, hoch, runter, links, rechts, 
ok, 1 - 0 und die FB reagiert genauso bescheiden wie die Terratec.

Gruß
#5322194
Lesenswert?

Frank M. schrieb:
> Und ich bin fündig geworden.

Danke Frank, ich bin froh, dass du was gefunden hast.
Heute spät oder morgen gibt es dann eine neue Firmware zum Testen.

Ich werde mal meine eigene Universal-FB auf NEC stellen, und damit 
testen.

Frank M. schrieb:
> Es kann unter Umständen passieren, dass im IRMP-Buffer immer noch Daten
> vom zuletzt empfangenen Frame "lauern", weil sie noch nicht per
> irmp_get_data() abgeholt wurden. Dein Aufruf von irmp_get_data() liest
> dann eventuell einen alten Frame aus.

Ein alter Frame kann aber nur ausgelesen werden, wenn keine Taste in den 
5 Sekunden gedrückt wurde. Wenn eine Taste gedrückt wird, wird der alte 
Frame ja komplett überschrieben.
Oder?

Ich werde das so einbauen, um zu vermeiden, dass das 
Bestätigungs-Blinken der LED kommen könnte, obwohl der Tastendruck gar 
nicht in den 5 Sekunden statt fand.


Das Initialisieren des Buffers werde ich aber wieder raus nehmen, weil 
nach nochmaligem Überdenken ich sicher bin, dass da nichts schief gehen 
kann.
Da werden sowieso ständig verschieden lange Sachen rein geschrieben, und 
hinterher wird nie aufgeräumt, was aber auch gar nicht nötig ist, da 
beim Senden immer nur genau das Benötigte raus geht, und der Rest 
genullt wird.


Noch eine kurze offtopic Frage:
Frank M. schrieb:
> Danke. Mittlerweile bin ich mit der imon.txt durch. Es handelt sich um
> kein Fernbedienungsprotokoll im klassischen Sinne. Es ist weder
> Manchester-codiert noch ist ein Pulse-Distance Protokoll. Es ist viel
> einfacher, nämlich einfach bitseriell mit 38 Bits, wenn ich mich nicht
> verzählt habe.
>
> Das kann IRMP nicht. Einfacher wäre es, einen Software-Uart (i.d.R. 8
> Bit) auf 38 Bit umzuschreiben. ;-)
>
> Naja, ich schaue mir nochmal imon2.txt an. Dann entscheide ich, ob ich
> das in IRMP einbaue oder nicht.

Da wurde nie geschrieben, was dabei heraus gekommen ist. Ist das immer 
noch gültig, dass IRMP kein IMON kann? Neulich kam diese Frage mal im 
VDR-Portal auf.
OP #5322253
Lesenswert?

Jörg R. schrieb:
> "T." ". schrieb:
>> Hier die stm32config Monitor Ausgabe der anderen NEC FB:
>
> Im Prinzip dasselbe, mal flags 0, mal 1.
>
> Ich sage Bescheid, wenn es die neue Firmware gibt.

OK, danke. Bevor ich nun meine Harmony umprogrammiere, habe ich mal 
geschaut, was die anderen Fernbedienungen die ich hier noch habe für 
Protokolle sprechen. Ich habe noch zwei Stück mit NEC gefunden.
Moderator Persönliche Seite #5322297
Lesenswert?

Jörg R. schrieb:
> Ein alter Frame kann aber nur ausgelesen werden, wenn keine Taste in den
> 5 Sekunden gedrückt wurde. Wenn eine Taste gedrückt wird, wird der alte
> Frame ja komplett überschrieben.

Nein, der wird nicht überschrieben. Solange Du ihn nicht per 
irmp_get_data() abholst, nimmt IRMP keine weiteren Frames mehr an. Du 
bekommst dann den alten ausgeliefert.

> Ich werde das so einbauen, um zu vermeiden, dass das
> Bestätigungs-Blinken der LED kommen könnte, obwohl der Tastendruck gar
> nicht in den 5 Sekunden statt fand.

Gut.

> Das Initialisieren des Buffers werde ich aber wieder raus nehmen, weil
> nach nochmaligem Überdenken ich sicher bin, dass da nichts schief gehen
> kann.
> Da werden sowieso ständig verschieden lange Sachen rein geschrieben, und
> hinterher wird nie aufgeräumt, was aber auch gar nicht nötig ist, da
> beim Senden immer nur genau das Benötigte raus geht, und der Rest
> genullt wird.

Okay, deshalb schrieb ich ja gestern: Wenn es nicht stört, auch gut.

> Da wurde nie geschrieben, was dabei heraus gekommen ist. Ist das immer
> noch gültig, dass IRMP kein IMON kann? Neulich kam diese Frage mal im
> VDR-Portal auf.

Hm, das muss schon was länger her sein. Upps, 2011... Weiß ich jetzt aus 
dem Stehgreif gar nicht mehr. Schaue ich mir nochmal an.
#5322985
Lesenswert?

Ich weiß jetzt ungefähr, woran es liegt. Nur das tiefere Verständnis 
fehlt mir noch. Aber der Reihe nach.

Schlußendlich habe ich es geschafft, meine  OFA URC 7541 per SAT-0137 
auf NEC einzustellen.
Auch mit IRMP 3.0.9 kamen dann wie bei 0belix alle flags 1, bei anderen 
Versuchen mal 0 , mal 1. Bei einem Versuch sogar alles richtig.

Also habe ich bei meinem Code alles verzichtbare abgestellt, und langsam 
wieder dazu genommen, und dabei getestet, ab wann der Fehler wieder 
auftaucht. Es lag am toggle_LED(); in main():
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L766
Durch das kürzlich hinzu gekommene "SHORTFLASH" gibt es da eine 
Verzögerung. Abstellen von SHORTFLASH oder Herabsetzen des delay von 
50ms auf 30ms hilft.
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L317
Nur verstehe ich nicht, wie diese Verzögerung die Fehler in IRMP hervor 
ruft.

Noch eine interessante Beobachtung: Wenn ich die Tasten ganz kurz 
drücke, geht es bei 35ms delay immer, es kommt eine Ausgabe mit flags 0, 
drücke ich die Taste etwas länger, kommt wieder flags 1 für beide 
frames. Was passiert da??

Ist das nun ein Fehler in meinem Code, oder exponiert die Verzögerung 
ein Problem in IRMP?

irmp_get_data(&wakeup_IRData); // flush input of irmp data
ist jetzt übrigens auch drin: 
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L433

Jörg R. schrieb:
> Für das PC aufwecken z.B.
> https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L437
> wird flags genullt. Das sollte überall so sein, müßte ich mal prüfen
> bzw. ins README schreiben (wenn man von Hand eingibt).

Getan: 
https://github.com/j1rie/IRMP_STM32/blob/master/STM32F103/src/main.c#L753
Bei den Konfigurationsprogrammen muß ich noch gucken.

Es gibt neue Firmware im git.
Moderator Persönliche Seite #5323012
Lesenswert?

Jörg R. schrieb:
> Es lag am toggle_LED(); in main():

Es liegt definitiv am delay().

Ich kann das vielleicht auch - zumindest teilweise - erklären:

1. User drückt Taste (hält den Finger drauf)
2. Anwendung holt Frame ab.
3. Anwendung macht Delay
4. Da der Finger noch drauf ist, kommt während des Delays ein weiterer
   Frame mit flags = 1 rein
5. IRMP sperrt den Empfang, da Anwendung den letzten Frame noch nicht
   abgeholt hat.
6. Anwendung holt Frame mit flags = 1 ab.
7. IRMP gibt den Empfang wieder frei.

Solange Dein Delay länger ist als die Zeit, in welcher ein weiterer 
Frame reinkommen kann, hinkst Du in der Anwendung immer 1 Frame 
hinterher.

Ist eigentlich dasselbe Problem wie das (vor)gestern erläuterte mit dem 
delay von 5 Sekunden.

Entweder machst Du das delay kürzer (sehe gerade: hast Du schon auf 
25msec runtergestellt)

oder

Du baust den Flush auch hinter(!) dem Delay in main() ein

oder

Du lässt Deine LED im Hintergrund über eine Timer-Routine aufblitzen und 
lässt die main-Routine ungehindert, d.h. ohne Verzögerung, durchlaufen.

Die dritte Variante ist zweifellos die eleganteste.

P.S.
Du könntest die LED auch über die IRMP-Callback-Funktion aufleuchten 
lassen. Dann flimmert die immer dann, solange IRMP einen Frame empfängt. 
Genau für so etwas hatte ich damals die Callback-Funktion in IRMP 
implementiert:

IRMP: IRMP USE CALLBACK
Moderator Persönliche Seite #5323041
Lesenswert?

Jörg R. schrieb:
> Ja, das im Hintergrund zu machen erscheint mir auch das Beste.

Oder über IRMP: IRMP USE CALLBACK, siehe P.S., was ich oben eben noch 
nachträglich angehangen habe.

> Deine Erklärung erklärt aber nicht, wieso schon der erste frame
> flags 1 hat. Oder?

Nein, ganz habe ich es noch nicht verstanden. Aber ich weiß, dass bei 
delays der IRMP dicht macht, sobald er einen weiteren Frame im 
Hintergrund empfängt und der nicht (rechtzeitig) abgeholt wird.

Lösung wäre ein FiFo (Queue), hatte ich aber damals, als es nur die 
AVR-Variante gab, wegen höherem Speicherbedarf verworfen.
#5323080
Lesenswert?

Frank M. schrieb:
> 1. User drückt Taste (hält den Finger drauf)
> 2. Anwendung holt Frame ab.
> 3. Anwendung macht Delay
> 4. Da der Finger noch drauf ist, kommt während des Delays ein weiterer
>    Frame mit flags = 1 rein
> 5. IRMP sperrt den Empfang, da Anwendung den letzten Frame noch nicht
>    abgeholt hat.
> 6. Anwendung holt Frame mit flags = 1 ab.
> 7. IRMP gibt den Empfang wieder frei.

Der Frame von 2. wird vor dem Delay abgeholt, hat aber bereits flags 1.
Da muss noch etwas Anderes dazwischen funken.
Moderator Persönliche Seite #5323102
Lesenswert?

Frage:

Der WAKEUP_RESET_PIN ist in der Regel high, korrekt? Nicht, dass der in 
jedem Schleifendurchgang in store_new_wakeup() reinspringt...

Du könntest natürlich auch mal einen Breakpoint auf delay_ms() setzen. 
Vielleicht gibts da noch weitere Delays. Ein Breakpoint auf 
irmp_get_data() wäre auch nicht so verkehrt.
Moderator Persönliche Seite #5323182
Lesenswert?

Jörg R. schrieb:
> Einen Breakpoint setzen kriege ich hin. Aber auf was soll ich dann
> achten?

Wo der Sprung in die Funktion herkam. Am besten zu Anfang der jeweiligen 
Funktion einen Breakpoint und dann nochmal am Ende, also entweder beim 
return oder beim letzten Statement der Funktion.

Wenn die Funktion dann aufgerufen wird (z.B. Delay), mit "Continue" zum 
Breakpoint am Ende der Funktion springen, und dann mit "Step over" 
weitersteppen. Dann sieht man direkt, wo der Call herkam. Anschließend 
kann man dann mit "Continue" das Programm weiterlaufen lassen.

Ich würde erstmal auf delay_ms() einen Breakpoint setzen und dann mal 
schauen, wann und woher Calls auf delay_ms() gemacht werden. Wenn das 
alles logisch erscheint, dann Breakpoint auf get_irmp_data(). Das dürfte 
ja im Normalfall lediglich direkt aus main() aufgerufen werden, richtig? 
Nicht, dass da noch ein irmp_get_data() dazwischenkommt, der 
ausggerechnet den Frame mit flags = 0x00 wegfrisst - was übrigens 
passieren kann, wenn WAKEUP_RESET_PIN low gemessen wird.
#5323228
Lesenswert?

Frank M. schrieb:
> Der WAKEUP_RESET_PIN ist in der Regel high, korrekt?

Ja, da muss man schon das Gehäuse öffnen und eine Drahtbrücke ansetzen 
...

Bei den ganzen Tests wurde ja nur IR empfangen und über USB ausgegeben, 
von den ganzen anderen Sachen wird dabei nichts benutzt, außer dem 
offensichtlichem.

Wir sind nur in diesem Block
1
    /* poll IR-data */
2
    if (irmp_get_data(&myIRData)) {
3
      if (learn_wakeup) {
4
        /* store received wakeup IRData in first wakeup slot */
5
        myIRData.flags = 0;
6
        eeprom_store((MACRO_DEPTH + 1) * SIZEOF_IR/2 * MACRO_SLOTS, (uint8_t *) &myIRData);
7
        learn_wakeup = 0;
8
      }
9

10
      myIRData.flags = myIRData.flags & IRMP_FLAG_REPETITION;
11
      if (!(myIRData.flags)) {
12
        RepeatCounter = 0;
13
      } else {
14
        RepeatCounter++;
15
      }
16

17
      if (RepeatCounter == 0 || RepeatCounter >= MIN_REPEATS) {
18
        toggle_LED();
19
        /* if macros are sent already, while the trigger IR data are still repeated,
20
         * the receiving device may crash */
21
        check_macros(&myIRData);
22
        check_wakeups(&myIRData);
23
        check_resets(&myIRData);
24
        check_reboot(&myIRData);
25
      }
26

27
      /* send IR-data */
28
      memcpy(buf, &myIRData, sizeof(myIRData));
29
      USB_HID_SendData(REPORT_ID_IR, buf, sizeof(myIRData));
30
    }
Dabei ist learn_wakeup irrelevant, da schon vorhanden, macros sind nicht 
vorhanden, resets auch nicht, wakeups nur einer, reboot auch nur einer. 
Da gibt es keine Verzögerung.

Außer dem toggle_LED(), dem man nicht gleich die Verzögerung ansieht, 
ist da nichts.

Ich werde aber sowieso auf die IRMP-Callback-Funktion umsatteln, optisch 
sehe ich da keinen großen Unterschied zu wie es vorher war, und ich 
finde es eleganter. Und weiter Energie in Debuggen stecken, habe ich 
eher nicht vor, da ich mir nichts davon verspreche. Wenn ich es doch 
tue, würde ich timestamps über printf's ausgeben, um mal zu sehen, wo 
wie viel Zeit verbraten wird. Das könnte interessant sein.
Moderator Persönliche Seite #5323584
Lesenswert?

Ja, habe ich. Es ist ein 38-Bit bitserielles Protokoll. IRMP kann zwar 
seit ein paar Jährchen auch dieses Protokoll (das ist nichts anderes als 
das, was ein UART ausspuckt, nur halt ein paar Bits mehr), nur weiß ich 
im Moment noch nicht, wie ich die 38 Bit in die IRMP-Struct quetschen 
soll.

Da sich sämtliche 38 Bit je nach Taste ändern, gibt es auch keine 
Geräteadresse. Damit bleiben in der IRMP-Struct nur noch 16 Bit übrig, 
die ich verwenden kann. Es könnte durchaus sein, dass der IMON-Frame 
noch Redundanzen enthält, die man dann beim Decodieren noch eindampfen 
könnte (mache ich bei fast allen Protokollen so, z.B. NEC oder auch beim 
42-Bit-Kaseikyo-Protokoll), aber bisher konnte ich keine entdecken.

Alles in allem gestaltet sich die Dekodierung allein mit der bisherigen 
IRMP-Struct als schwierig bis unmöglich. Ich müsste sie daher aufbohren 
und damit eine Inkompatibilität in Kauf nehmen.

Ich habe aber noch nicht aufgegeben. Vielleicht fällt mir ja noch was 
auf.
#5323700
Lesenswert?

Und noch was (da muss mal der pointer type angepaßt werden):
1
src/main.c: In function 'main':
2
src/main.c:651:25: warning: passing argument 1 of 'irmp_set_callback_ptr' from incompatible pointer type [-Wincompatible-pointer-types]
3
  irmp_set_callback_ptr (led_callback);
4
                         ^~~~~~~~~~~~
5
In file included from src/irmpmain.h:4:0,
6
                 from src/main.c:15:
7
irmp/irmp.h:254:41: note: expected 'void (*)(uint_fast8_t) {aka void (*)(unsigned int)}' but argument is of type 'void (*)(uint8_t) {aka void (*)(unsigned char)}'
8
 extern void                             irmp_set_callback_ptr (void (*cb)(uint_fast8_t));
Moderator Persönliche Seite #5323919
Lesenswert?

Jörg R. schrieb:
> Und noch was (da muss mal der pointer type angepaßt werden):

Nein, das Argument von Deiner Funktion led_callback().

Alt:
1
void led_callback (uint8_t on)
Neu:
1
void led_callback (uint_fast8_t on)

Dann passt das und die Warnung verschwindet.

Ich hatte das Argument im Zuge der Portierung auf 32-Bit-µCs auf 
uint_fast8_t geändert und vergessen, das Beispiel im IRMP-Artikel unter 
IRMP: IRMP USE CALLBACK anzupassen. Habe ich jetzt nachgeholt. Danke 
für den Hinweis.

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren