🚛 CarMotion: Steuerung via IR Fernbedienungsbefehle durch Arduino generiert

#1 von fbstr , 09.04.2024 19:29

Schon von Anfang an interessiert mich das Rückwärtsfahren der CarMotion-LKW's. Diese Funktion kann man mit der IR-Fernbedienung auslösen.
Ich hätte gerne das "Rückwärtsfahren" in der DCC-IR-Steuerung integriert, aber der Viessmann-Support ziert sich noch.

Beim Bahnpark Augsburg würde ich nämlich gerne unter den Kran fahren und stoppen. Auf meinem Testmodel kann ich dann vorwärts weiterfahren.

In Augsburg geht das aber nicht. Also wäre der Wunsch:
- Ich drücke einen Taster und halte diesen fest
- Der LKW setzt den Warnblinker
- per Servo werden "Bordsteine" hochgefahren damit der LKW beim Rückwärtsfahren geführt wird (ich denke da an die MobaLedLib)
- das nervige Piepsen wird per Sound aktiviert (ich denke immer noch an die MobaLedLib)
- der LKW fährt so lange zurück wie ich den Taster gedrückt halte
- ich lasse den Taster los
- der Bordstein fährt wieder herunter
- der LKW kann vorwärts nach rechts abbiegen und weiterfahren

Letzte Woche konnte jemand die IR-Befehle mittels Arduino und IR-Sendediode generieren und hat diese Info in der Facebookgruppe gepostet. Ich war begeistert!

Mittels dem "Multi-function Tester-T7" kann man die IR-Signale auslesen, aber diese dann richtig in den Sketch zu bringen - daran war ich gescheitert. Z.B.:

Mit Hilfe des Facebook-Hinweis konnte ich heute zum ersten Mal per Tastendruck den LKW rückwärts fahren lassen.

Ich habe folgenden Testaufbau:
- Taster gelb: Ein-/Ausschalten der Warnblinker (war eher als Kontrolle gedacht)
- Taster grau: Aktivieren der Rückwärtsfahrt. Bei der Fernbedienung muß man die Taste gedrückt halten.
- grüne LED: Die soll leuchten, wenn die IR-Diode das "Rückwärtsfahren" sendet. So als Kontrolle

So ganz funktioniert mein Sketch noch nicht
- die grüne LED macht fast nichts
- das Rückwärtsfahren reagiert nur auf die abfallende Flanke des Tasters und dann fährt der LKW eine bestimmte Zeit rückwärts

Aber hey, das ist doch schon mal was!

Vielleicht können die Arduino-Profis mir ein paar Tipps geben was ich verbessern kann:

Zitat

#include <IRremote.hpp>

const int SenderPin = 5; //Pin für IR-Diode
const byte buttonDriveBackwards = 8 ; //Taster "Anhalten und Rückwärts"
const byte buttonWarnblinker = 9 ; //Taster "Warnblinker"
const byte ledDriveBackwardsPin = A4; //LED Feedback "Anhalten und Rückwärts"
byte buttonStatusDriveBackwards = 0 ;
byte buttonStatusWarnblinker = 0 ;
uint8_t Repeats = 0;

uint32_t rawData01 = 0xBA45FF00; //Fahrzeug aus
uint32_t rawData02 = 0xBF40FF00; //Beschleunigen
uint32_t rawData03 = 0xBC43FF00; //Anhalten und Rückwärts
uint32_t rawData04 = 0xF807FF00; //Blinken links
uint32_t rawData05 = 0xEA15FF00; //losfahren
uint32_t rawData06 = 0xF609FF00; //Blinken rechts
uint32_t rawData07 = 0xE916FF00; //Hauptlichter schalten
uint32_t rawData08 = 0xE619FF00; //Abbremsen
uint32_t rawData09 = 0xF20DFF00; //Akkuanzeige
uint32_t rawData10 = 0xF30CFF00; //Fernlicht
uint32_t rawData11 = 0xE718FF00; //Rundumlicht
uint32_t rawData12 = 0xA15EFF00; //Warnblinker
uint32_t rawData13 = 0xF708FF00; //Taste 4
uint32_t rawData14 = 0xE31CFF00; //Taste 5
uint32_t rawData15 = 0xA55AFF00; //Taste 6
uint32_t rawData16 = 0xBD42FF00; //Taste 7
uint32_t rawData17 = 0xAD52FF00; //Taste 8
uint32_t rawData18 = 0xB54AFF00; //Taste 9
uint32_t rawData19 = 0xBB44FF00; //Taste Test
uint32_t rawData20 = 0xB847FF00; //Taste MENU

void setup() {
Serial.begin(115200);
pinMode(SenderPin, OUTPUT);
pinMode(ledDriveBackwardsPin, OUTPUT);
IrSender.begin(SenderPin,DISABLE_LED_FEEDBACK,0);

pinMode(buttonDriveBackwards, INPUT_PULLUP);
pinMode(buttonWarnblinker, INPUT_PULLUP);
}

void loop() {

// Status der Taster einlesen
buttonStatusDriveBackwards = digitalRead(buttonDriveBackwards);
buttonStatusWarnblinker = digitalRead(buttonWarnblinker);

if (buttonStatusDriveBackwards == LOW) // Wenn Taster gedrueckt...
{
IrSender.sendNECRaw(rawData03, 5500); //Anhalten und Rückwärts, 6000=17cm, 5500=19,5cm
digitalWrite(ledDriveBackwardsPin, HIGH);
}
else
{
digitalWrite(ledDriveBackwardsPin, LOW);
}

if (buttonStatusWarnblinker == LOW) // Wenn Taster gedrueckt...
{
IrSender.sendNECRaw(rawData12, Repeats); //Warnblinker
// digitalWrite(ledDriveBackwardsPin, HIGH);
}
else
{
// digitalWrite(ledDriveBackwardsPin, LOW);
}

}

#2 von fbstr , 11.04.2024 19:22

Ich habe noch 2 zusätzliche Taster eingebaut und die internen Pullups verwendet. Hat aber nichts daran geändert, dass die abfallende Flanke verwendet wird.

Hier im Spoiler der aktuelle Sketch:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 

 
#include <IRremote.hpp>
 
const int SenderPin = 5;               //Pin für IR-Diode
const byte buttonDriveBackwards = 8 ;  //Taster "Anhalten und Rückwärts"
const byte buttonWarnblinker = 9 ;  //Taster "Warnblinker"
const byte buttonLosfahren = 4 ;  //Taster "+"
const byte buttonAbbremsen = 3 ;  //Taster "-"
const byte ledDriveBackwardsPin = A4;  //LED Feedback "Anhalten und Rückwärts"
byte buttonStatusDriveBackwards = 0 ;
byte buttonStatusWarnblinker = 0 ;
byte buttonStatusLosfahren = 0 ;
byte buttonStatusAbbremsen = 0 ;
uint8_t Repeats = 0;
 
uint32_t rawData01 = 0xBA45FF00;  //Fahrzeug aus
uint32_t rawData02 = 0xBF40FF00;  //Beschleunigen, (+)
uint32_t rawData03 = 0xBC43FF00;  //Anhalten und Rückwärts
uint32_t rawData04 = 0xF807FF00;  //Blinken links
uint32_t rawData05 = 0xEA15FF00;  //losfahren, (Fahren)
uint32_t rawData06 = 0xF609FF00;  //Blinken rechts
uint32_t rawData07 = 0xE916FF00;  //Hauptlichter schalten
uint32_t rawData08 = 0xE619FF00;  //Abbremsen, (-)
uint32_t rawData09 = 0xF20DFF00;  //Akkuanzeige
uint32_t rawData10 = 0xF30CFF00;  //Fernlicht
uint32_t rawData11 = 0xE718FF00;  //Rundumlicht
uint32_t rawData12 = 0xA15EFF00;  //Warnblinker
uint32_t rawData13 = 0xF708FF00;  //Taste 4
uint32_t rawData14 = 0xE31CFF00;  //Taste 5
uint32_t rawData15 = 0xA55AFF00;  //Taste 6
uint32_t rawData16 = 0xBD42FF00;  //Taste 7
uint32_t rawData17 = 0xAD52FF00;  //Taste 8
uint32_t rawData18 = 0xB54AFF00;  //Taste 9
uint32_t rawData19 = 0xBB44FF00;  //Taste Test
uint32_t rawData20 = 0xB847FF00;  //Taste MENU
 

void setup() {
  Serial.begin(115200);
  pinMode(SenderPin, OUTPUT);
  pinMode(ledDriveBackwardsPin, OUTPUT);
  IrSender.begin(SenderPin,DISABLE_LED_FEEDBACK,0);
 
  pinMode(buttonDriveBackwards, INPUT_PULLUP);
  pinMode(buttonWarnblinker, INPUT_PULLUP);
  pinMode(buttonAbbremsen, INPUT_PULLUP);
  pinMode(buttonLosfahren, INPUT_PULLUP);
}
 
void loop() {
 
  // Status der Taster einlesen
  buttonStatusDriveBackwards = digitalRead(buttonDriveBackwards);
  buttonStatusWarnblinker = digitalRead(buttonWarnblinker);
  buttonStatusAbbremsen = digitalRead(buttonAbbremsen);
  buttonStatusLosfahren = digitalRead(buttonLosfahren);
  
  if (buttonStatusDriveBackwards == LOW)         // Wenn Taster gedrueckt...
    {
        IrSender.sendNECRaw(rawData03, 5500);      //Anhalten und Rückwärts, 6000=17cm, 5500=19,5cm
//        digitalWrite(ledDriveBackwardsPin, HIGH);
    }
  else
    {
        digitalWrite(ledDriveBackwardsPin, LOW);
    }
 
  if (buttonStatusWarnblinker == LOW)         // Wenn Taster gedrueckt...
    {
        IrSender.sendNECRaw(rawData12, 2);      //Warnblinker Repeats
        delay(100); // mindestens 5 ms Pause nach dem Senden
        digitalWrite(ledDriveBackwardsPin, HIGH);
    }
  else
    {
//        digitalWrite(ledDriveBackwardsPin, LOW);
    }
 
  if (buttonStatusAbbremsen == LOW)         // Wenn Taster gedrueckt...
    {
        IrSender.sendNECRaw(rawData08, 0);      //Abbremsen
//        digitalWrite(ledDriveBackwardsPin, HIGH);
    }
  else
    {
//        digitalWrite(ledDriveBackwardsPin, LOW);
    }
 
  if (buttonStatusLosfahren == LOW)         // Wenn Taster gedrueckt...
    {
        IrSender.sendNECRaw(rawData05, 0);      //Losfahren
//        digitalWrite(ledDriveBackwardsPin, HIGH);
    }
  else
    {
//        digitalWrite(ledDriveBackwardsPin, LOW);
    }    
 
 
}
 
 

Am Ende noch ein Stopp-Magnet. Damit kann ich ohne die IR-Fernbedienung hin- und herfahren.

Aber im Prinzip bin ich noch nicht weiter gekommen. Ich kann auch nur 1 Stufe beschleunigen, bzw. Abbremsen.

#3 von fpps , 19.04.2024 11:43

Hallo Frank,

Schon Gemacht!
Ich habe eine Frage über deine Lösung: Benutzt Du die IR-Drahtloss Protocol (Ahnlich wie TV) oder Viessmann's eigene IR Abstands- und Steuerungs Protocol.

MfG,
Frank (fpps).

#4 von fbstr , 20.04.2024 15:15

Zitat von fpps im Beitrag #3
Benutzt Du die IR-Drahtloss Protocol (Ahnlich wie TV) oder Viessmann's eigene IR Abstands- und Steuerungs Protocol.

MfG,
Frank (fpps).

Hallo Frank,

hier wird das IRremote.hpp verwendet, also wie bei Fernbedienungen. Ich habe inzwischen das "IR Mini" bekommen und angefangen damit herumzuprobieren, aber das muß irgendwie anders funktionieren. Hier geht es aber um die Funktionalität der IR Fernbedienung und den Versuch diese in meinem "Bahnpark Augsburg" Szenario anzuwenden.

Zur Erinnerung:
Ich möchte gerne einen Taster drücken und der LKW soll so lange rückwärts fahren wie ich den Taster gedrückt halte.

Das hat bisher nicht funktioniert.

Und heute morgen hat sich @Hardi Zeit genommen mit mir das Problem anzusehen.

Mittels dem Beispiel-Sketch "SimpleReceiver" der IRremote-Bibliothek konnten wir sehen was passiert, wenn die Taste auf der Fernbedienung lange gedrückt wird:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 

14:40:58.323 -> START C:\Users\xxx\Documents\Arduino\libraries\IRremote\examples\SimpleReceiver\SimpleReceiver.ino from Apr 20 2024
14:40:58.323 -> Using library version 4.3.1
14:40:58.323 -> Ready to receive IR signals of protocols: NEC/NEC2/Onkyo/Apple, at pin 2
14:41:08.908 -> Protocol=NEC Address=0x0 Command=0x43 Raw-Data=0xBC43FF00 32 bits LSB first
14:41:08.908 -> Send with: IrSender.sendNEC(0x0, 0x43, <numberOfRepeats>);
14:41:08.908 -> 
14:41:08.978 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=38050us
14:41:08.978 -> 
14:41:09.082 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92700us
14:41:09.082 -> 
14:41:09.177 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92700us
14:41:09.177 -> 
14:41:09.309 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92700us
14:41:09.309 -> 
14:41:09.391 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92750us
14:41:09.391 -> 
14:41:09.482 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92750us
14:41:09.482 -> 
14:41:09.625 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92750us
14:41:09.625 -> 
14:41:09.694 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92750us
14:41:09.694 -> 
14:41:09.791 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92750us
14:41:09.838 -> 
14:41:09.931 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92700us
14:41:09.931 -> 
14:41:10.027 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92700us
14:41:10.027 -> 
14:41:10.126 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92750us
14:41:10.126 -> 
14:41:10.216 -> Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92750us
14:41:10.261 -> 
 

 

D.h. nur einmal wird gesendet: Protocol=NEC Address=0x0 Command=0x43 Raw-Data=0xBC43FF00 32 bits LSB first
Danach kommt "nur" noch: Protocol=NEC Address=0x0 Command=0x43 Repeat gap=92700us

Dies zeigte Hardi, dass es noch einen Folgebefehl geben müßte, der nach "IrSender.sendNECRaw" verwendet werden muß.
Und das ist "IrSender.sendNECRepeat"

Dann noch den Taster für das Rückwärtsfahren genauer auswerten:

1
2
3
4
5
6
7
8
9
 

  // Verhalten des Tasters:
  //
  // ---------------,            ,---------------
  //                |            |
  //                '------------'
  // Nicht gedrückt    Gehalten    Losgelassen
  //                ^            ^
 
 

Herausgekommen ist der angehängte Sketch:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 

/*  
    Am 20.04.24 mit Hardi angepasst. Rückwärtsfahren solange wie Taster gedrückt.
    
    
    Von Odracir Repahcs am 01.04.2024 auf Facebook gepostet
    https://www.facebook.com/groups/800631387836720/permalink/1070476617518861/
    Ich habe die Signale der Fernbedienung ausgelesen 
    Das "Rückwärtsfahrsignal" in der Wiederholrate enorm erhöht (900). 
  
    Bibliothek "IRremote" installieren
    Pin 5 am Mega verwendet 
  
    Wunschliste:
    - Feedback LED fürs Rückwärtsfahren
    - Taster der das Rückwärtsfahren auslöst
    - Sound "Sicherheitspiepsen" beim Rückwärtsfahren: https://www.videvo.net/de/lizenzfreie-soundeffekte/lkw-ruckwarts-piepton/705171/
 

*/ 
 
#include <IRremote.hpp>
 
const int SenderPin = 5;                //Pin für IR-Diode
const byte buttonDriveBackwards = 8 ;   //Taster "Anhalten und Rückwärts"
const byte buttonWarnblinker = 9 ;      //Taster "Warnblinker"
const byte buttonLosfahren = 4 ;        //Taster "+"
const byte buttonAbbremsen = 3 ;        //Taster "-"
const byte ledDriveBackwardsPin = A4;   //LED Feedback "Anhalten und Rückwärts"
byte buttonStatusDriveBackwards = 0 ;
byte buttonStatusWarnblinker = 0 ;
byte buttonStatusLosfahren = 0 ;
byte buttonStatusAbbremsen = 0 ;
uint8_t Repeats = 0;
bool Old_DriveBackwards = true;         // Vorheriger Status des Tasters (nicht gedrückt = HIGH, gedrückt = LOW)
uint32_t StartTimer;
 
uint32_t rawData01 = 0xBA45FF00;  //Fahrzeug aus
uint32_t rawData02 = 0xBF40FF00;  //Beschleunigen, (+)
uint32_t rawData03 = 0xBC43FF00;  //Anhalten und Rückwärts
uint32_t rawData04 = 0xF807FF00;  //Blinken links
uint32_t rawData05 = 0xEA15FF00;  //losfahren, (Fahren)
uint32_t rawData06 = 0xF609FF00;  //Blinken rechts
uint32_t rawData07 = 0xE916FF00;  //Hauptlichter schalten
uint32_t rawData08 = 0xE619FF00;  //Abbremsen, (-)
uint32_t rawData09 = 0xF20DFF00;  //Akkuanzeige
uint32_t rawData10 = 0xF30CFF00;  //Fernlicht
uint32_t rawData11 = 0xE718FF00;  //Rundumlicht
uint32_t rawData12 = 0xA15EFF00;  //Warnblinker
uint32_t rawData13 = 0xF708FF00;  //Taste 4
uint32_t rawData14 = 0xE31CFF00;  //Taste 5
uint32_t rawData15 = 0xA55AFF00;  //Taste 6
uint32_t rawData16 = 0xBD42FF00;  //Taste 7
uint32_t rawData17 = 0xAD52FF00;  //Taste 8
uint32_t rawData18 = 0xB54AFF00;  //Taste 9
uint32_t rawData19 = 0xBB44FF00;  //Taste Test
uint32_t rawData20 = 0xB847FF00;  //Taste MENU
 

void setup() {
  Serial.begin(115200);
  pinMode(SenderPin, OUTPUT);
  pinMode(ledDriveBackwardsPin, OUTPUT);
  IrSender.begin(SenderPin,DISABLE_LED_FEEDBACK,0);
 
  pinMode(buttonDriveBackwards, INPUT_PULLUP);
  pinMode(buttonWarnblinker, INPUT_PULLUP);
  pinMode(buttonAbbremsen, INPUT_PULLUP);
  pinMode(buttonLosfahren, INPUT_PULLUP);
}
 
void loop() {
 
  // Status der Taster einlesen
  buttonStatusDriveBackwards = digitalRead(buttonDriveBackwards);
  buttonStatusWarnblinker = digitalRead(buttonWarnblinker);
  buttonStatusAbbremsen = digitalRead(buttonAbbremsen);
  buttonStatusLosfahren = digitalRead(buttonLosfahren);
  
  // Verhalten des Tasters:
  //
  // ---------------,            ,---------------
  //                |            |
  //                '------------'
  // Nicht gedrückt    Gehalten    Losgelassen
  //                ^            ^
  //
 
  if (Old_DriveBackwards == HIGH && buttonStatusDriveBackwards == LOW)  // Taster wird gedrückt
     {
//     Serial.println("Taster gedrückt"); 
     IrSender.sendNECRaw(rawData03, 0);      //Anhalten und Rückwärts
     StartTimer = millis();
     }
  else if (Old_DriveBackwards == LOW && buttonStatusDriveBackwards == HIGH)   // Taster wird losgelassen
     {
     digitalWrite(ledDriveBackwardsPin, LOW); 
//     Serial.println("Taster losgelassen");     
     }
  else if (buttonStatusDriveBackwards == LOW)   // Wenn Taster gehalten wird
     {
     if (millis() - StartTimer > 92)
        { 
//        Serial.println("Taster gehalten");
        digitalWrite(ledDriveBackwardsPin, HIGH); // Kontroll-LED: Taster Rückwärtsfahren gehalten
        IrSender.sendNECRepeat();
        StartTimer = millis();
        }
     }
 
  if (buttonStatusWarnblinker == LOW)           // Wenn Taster gedrueckt...
    {
        IrSender.sendNECRaw(rawData12, 0);      //Warnblinker
    }
  else
    {
 
    }
 
  if (buttonStatusAbbremsen == LOW)             // Wenn Taster gedrueckt...
    {
        IrSender.sendNECRaw(rawData08, 0);      //Abbremsen
    }
  else
    {
 
    }
 
  if (buttonStatusLosfahren == LOW)             // Wenn Taster gedrueckt...
    {
        IrSender.sendNECRaw(rawData05, 0);      //Losfahren
    }
  else
    {
 
    }    
  Old_DriveBackwards = buttonStatusDriveBackwards;
 
}
 
 

Inzwischen zeigt die grüne LED auch an, wenn ich den grauen Taster gedrückt halte.

Ich bin voll happy!

Vielen Dank Hardi!

#5 von kormorix , 17.02.2025 18:54

Hallo Frank,
erstmal vielen Dank, daß Du uns an Deinen Erkenntnissen hier teilhaben läßt!
Ich hoffe, ich habe es nicht übersehen, aber kannst Du mir mitteilen, welche IR-Sendediode Du benutzt, bzw. welche Wellenlänge sie hat?
VG von Burkhard

#6 von fbstr , 17.02.2025 20:42

Zitat von kormorix im Beitrag #5
... aber kannst Du mir mitteilen, welche IR-Sendediode Du benutzt, bzw. welche Wellenlänge sie hat?

Hallo Burkhard,

hier findest Du mehr Infos:
🚛 CarMotion: Steuerung via DCC

Alle meine IR-Dioden haben 850nm, erst nachdem ich diese hatte entdeckte ich dass Viessmann 940nm empfiehlt.

#7 von kormorix , 17.02.2025 22:55

Vielen Dank für die Info!

#8 von bomber1970 , 11.03.2025 16:27

Hallo,
die Car Motion Fahrzeuge kann ich ja mit der FB durch drücken des roten Knopfes ausschalten.
Einschalten geht ja aber nur, indem man die FB auf das Dach hält.
Wenn ich es richtig verstanden habe, ist ein Ein und Ausschalten auch über den Induktiv Charger möglich.
Jetzt meine Frage: Ist es möglich das Ein und Ausschalten über IR Diode und DCC zu senden?

Gruß
Renato

#9 von fbstr , 11.03.2025 16:35

Zitat von bomber1970 im Beitrag #8
Hallo,
die Car Motion Fahrzeuge kann ich ja mit der FB durch drücken des roten Knopfes ausschalten.
Einschalten geht ja aber nur, indem man die FB auf das Dach hält.
Wenn ich es richtig verstanden habe, ist ein Ein und Ausschalten auch über den Induktiv Charger möglich.
Jetzt meine Frage: Ist es möglich das Ein und Ausschalten über IR Diode und DCC zu senden?

Gruß
Renato

Hallo Renato,

das ist eine interessante Frage. Soll ich die mal an die Facebookgruppe weiterleiten?

Viessmann betont, das ausgeschaltete Fahrzeuge wirklich stromlos sind. D.h. der LiPo ist auch nach Wochen im ausgeschalteten Zustand noch so wie zum Zeitpunkt des Ausschaltens.

Das erklärt für mich warum man per IR nur Ausschalten kann. Könnte es sein dass der Charger so ein starkes Magnetfeld zum Einschalten schickt?

#10 von bomber1970 , 11.03.2025 16:58

Hallo Frank.
Das kannst du gerne machen.
Aber wie bekomme ich den Befehl des ausschalten über DCC geschickt? Kann man das im Carmanager als Makro hinterlegen?
Gruß Renato

#11 von VSz , 12.03.2025 08:05

Hallo zusammen,
ja, der Charger kann auch stromlose Fahrzeuge einschalten, und ist auch DCC-kompatibel.

#12 von H073Hürth , 12.03.2025 09:38

Hallo Zusammen,

zunächst einmal vielen Dank für die tollen Beiträge, die gerade für die Wiedereinsteiger eine super Hilfe und tolle Dankanstöße sind. Danke.

Zur Zeit bin ich in Tests meine Modellbahn mit einer Carmotion-Anlage zu ergänzen. Mit der IR-Steuerung über die CS3 funktioniert das schon sehr gut. Letztlich bin ich aber an derselben Frage wir Renato steckengeblieben. Mein Ziel ist es, mit dem Herunterfahren der Modellbahn auch die Carmotion-Anlage stromlos zu machen. Leider habe ich mit IR-Steuerung und Makro für die Fahrzeuge bisher keinen Erfolg.

Eine Lösung mit Charger ist interessant, aber bei 10 Fahrzeugen könnte es doch bedeuten, dass ich an den „Heimatadressen“ der Fahrzeuge jeweils einen Charger bräuchte. Das wären neben den Fahrzeugen schon erhebliche Zusatz-Kosten. Oder habe ich es nicht richtig verstanden?

Das Ausschalten mit IR-Befehlen wäre ja schon eine tolle Lösung fürs Herunterfahren. Leider bin ich mit dem Adruino nicht so fit und bin da auf die Spezialisten angewiesen.

Grüße Jürgen

#13 von UweS , 14.03.2025 13:33

Zitat von H073Hürth im Beitrag #12
Eine Lösung mit Charger ist interessant, aber bei 10 Fahrzeugen könnte es doch bedeuten, dass ich an den „Heimatadressen“ der Fahrzeuge jeweils einen Charger bräuchte

Hallo Jürgen,

hab grad Deine Frage gelesen, noch ohne Antwort.

Mit der Ladespule kann man ein Fahrzeug ausschalten wenn es drauf steht und alle anderen Fahrzeuge die dahinter stehen werden mit ausgeschalten, muss man in CarManager so einstellen.
Einschalten kann man nur das auf der Ladespule stehende Fahrzeug.
Es wird ein Impuls von der Ladespule über die Empfängerspule am Fahrzeug, an den Prozessor gesendet.

Also Du brauchst an jeder Heimatadresse eine Ladespule.
(In anderen Sprachen auch "Charger" genannt)

#14 von bomber1970 , 14.03.2025 13:56

Hallo Uwe,
Die ursprüngliche Frage war aber, kann man die Fahrzeuge auch über DCC ausschalten, über einen Befehl von der Zentrale?

Gruß Renato

#15 von H073Hürth , 15.03.2025 09:03

Hallo Uwe, hallo Renato,
danke für Eure Rückmeldungen. Leider bestätigt das meine Vermutung zur Ladespule.

Renatos Frage trifft dabei genau meinen Punkt: Ich bin mit DCC auch in der Frage zur Abschaltung nicht weitergekommen. Hier fehlt mir im Mapping die Funktion "Abschalten", die ja per IR-Signal möglich ist.

Wie sind Eure Erfahrungen: Macht es Sinn direkt mit Viessmann Kontakt aufzunehmen, um ggf. bei einem Update eine Erweiterung in vorgenanntem Sinne anzuregen?

Grüße Jürgen

#16 von fbstr , 15.03.2025 09:47

Zitat von H073Hürth im Beitrag #15
Wie sind Eure Erfahrungen: Macht es Sinn direkt mit Viessmann Kontakt aufzunehmen, um ggf. bei einem Update eine Erweiterung in vorgenanntem Sinne anzuregen?

Du kannst auch im Viessmann-Forum die Frage stellen:
https://viessmann-modell.com/forum/board/26-carmotion/

Ich werde nächsten Samstag beim IR-Mini-Seminar sein. Da kann ich auch mal nachfragen.

Mein Bauchgefühl sagt mir dass es momentan nicht möglich ist per DCC den LKW abzuschalten, genauso wie es nicht möglich ist per DCC Rückwärts zu fahren. Ist vermutlich leicht für Viessmann aktivierbar, aber die zieren sich noch:
https://viessmann-modell.com/forum/threa...ren-via-dcc-ir/
In Mannheim habe ich den Wunsch auch nochmal wiederholt.

#17 von MaWe , 12.08.2025 17:28

Hallo,
hat jemand schon mal versucht DCC Befehle über eine IR Diode mit dem Arduino zu erzeugen? Also eigentlich wie die Signale der Fernbediehnung nur als DCC Signal.
Hintergrund:
Ich möchte völlig unabhängig von allen Eisenbahnsteuerungen über einen Arduino die CarMotion Fahrzeuge steuern.
Das Starten eines Macros würde mir zB sehr helfen einzelne Fahrsituationen individuell zu gestalten.
Leider kann man scheinbar keine Macros über die Fernbedienung starten, sonst hätte ich die Lösung schon in diesem Beitrag gefunden.
Mit Hilfe von KI hab ich schon Code und theoretische Hardware erzeugt, leider kann ich zur Zeit nichts praktisch ausprobieren. Ich liefer das aber bestimmt nach, wenn ich Ergebnisse bekomme.
Vielleicht hat jemand von Euch ja schon mal etwas ähnliches gemacht?

#18 von fbstr , 12.08.2025 17:49

Zitat von MaWe im Beitrag #17
...hat jemand schon mal versucht DCC Befehle über eine IR Diode mit dem Arduino zu erzeugen? Also eigentlich wie die Signale der Fernbediehnung nur als DCC Signal.

Hallo MaWe,

im Prinzip haben dies schon Tausende gemacht indem sie eine DCC-EX Zentrale gebastelt haben.
Und statt am Gleis wird eben eine IR-Diode (plus Diode und Widerstand) angestöpselt.

Henner hat einen schönen Fred dazu erstellt: 10€ Analog/DCC Regler/Zentrale ohne PC mit Funk

#19 von MaWe , 13.08.2025 11:41

Hallo Frank,
Danke für den link zu Henner.
Sehr interessant, aber ich würde es gerne rudimentärer machen mit weniger fertigem code.
Eigentlich ist IR-Fernbedienung kein Problem (Dank diesem Beitrag), und DCC über fertige Module auch nicht.
Eine saubere Kombination ist gedanklich mein Problem. IR funktioniert eigentlich über eine 38kHz Trägerfrequenz (wie in diesem IR Fernbedienungsbeispiel).
Wenn ich das Signal über eine DCC Zentrale erzeuge, dann fehlt genau diese Trägerfrequenz.
Das "saubere" Ziel wäre es das DCC Signal mit Hilfe der Trägerfrequenz zu übertragen. Die Praxis zeigt, dass es scheinbar auch ohne geht (oder CarMotion hat sehr unempfindliche IR Filter).
Um so etwas zu testen ist ein einfacher code am besten. Solange ich praktisch nichts tun kann, kann ich nur theoretisieren.
Wenn ich zum Testen komme werde ich Euch meine Ergebnisse mitteilen.
Schöne Grüße Markus

Beiträge:	3.220
Registriert am:	28.08.2016
Ort:	Stuttgart
Gleise	Peco Code 75, Trix C
Spurweite	H0, H0e
Steuerung	YD7001, MobaLedLib, MirZ21, Lenz LZV100
Stromart	DC, Digital

Beiträge:	3.220
Registriert am:	28.08.2016
Ort:	Stuttgart
Gleise	Peco Code 75, Trix C
Spurweite	H0, H0e
Steuerung	YD7001, MobaLedLib, MirZ21, Lenz LZV100
Stromart	DC, Digital

Beiträge:	7
Registriert am:	06.09.2018
Ort:	Cuijk
Spurweite	H0
Steuerung	CS3
Stromart	Digital

Beiträge:	3.220
Registriert am:	28.08.2016
Ort:	Stuttgart
Gleise	Peco Code 75, Trix C
Spurweite	H0, H0e
Steuerung	YD7001, MobaLedLib, MirZ21, Lenz LZV100
Stromart	DC, Digital

Beiträge:	9
Registriert am:	14.10.2019
Ort:	Kreis Ludwigsburg
Gleise	Tillig Elite, Roco Geoline im Schattenbahnhof
Spurweite	H0
Steuerung	BiDiB
Stromart	Digital