Table des matières:
- Étape 1: Code Arduino - Station de commande avec clavier
- Étape 2: Code Arduino - Affichage TFT
- Étape 3: Contrôleur d'aiguillage
Vidéo: Chemin de fer modèle - Station de commande DCC utilisant Arduino :: 3 étapes
2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08
Mis à jour en août 2018 - voir le nouveau Instructable:
Mise à jour du 28 avril 2016: Désormais, la capacité de contrôle de 16 aiguillages/points vers la station de commande. Les aiguillages T1 - T8 sont accessibles via la touche 'B'Les aiguillages T9 - T16 sont accessibles via la touche 'C'
Mise à jour du 10 mars 2016:
Ajout d'une capacité de contrôle de 8 aiguillages / points à la station de commande. Le code Arduino a été mis à jour en conséquence en utilisant le paquet standard NMRA pour les aiguillages (également basé sur une étude des paquets de données Lenz / Atlas Compact pour le contrôle des aiguillages).
Les aiguillages T1 - T8 sont disponibles via la touche 'B'
Voir instructable sur le circuit récepteur de paquets de données utilisé et le code Arduino requis.
Mise à jour du 18 janvier 2016:
J'ai ajouté une résistance de détection de courant (1k5 ohm) et un condensateur (10 uf) au circuit et modifié le code Arduino pour couper l'alimentation lorsqu'un courant de crête de > 3200 mA est détecté. La spécification du pont en H indique un courant de détection de sortie de 377 uA pour 1 A dans la charge.
La résistance de 1,5 k ohm fournira 0,565 volts par ampère sur la broche analogique 6. Avec 1023 pas sur l'entrée analogique, cela donne 0,565 * 1023 / 5 = 116 par ampère de charge.
A = 100 * (analogRead(AN_CURRENT)) / 116;A = A * 10; (pour donner le résultat en milliampères)
Le courant de charge en milliampères est affiché sur le TFT
Le clavier 4x4 complet comprend les fonctions F1 à F8 et 10 autres locomotives (1-19) via la touche '#' (pour ajouter 10 aux touches numériques à partir de la loco 10).
Le code arduino inclut la norme NMRA pour les octets d'instruction.
Voir le lien
www.nmra.org/sites/default/files/s-9.2.1_20…
(la page 6 est particulièrement pertinente)
Les paquets sont organisés en fonction du nombre d'étapes de vitesse, de l'adresse longue/courte et des instructions du groupe de fonctions.
Tous les octets d'instruction sont précédés d'un préambule de bits « 1 » 11111111 (ou paquet inactif) suivi de;
par exemple. Une adresse de 4 octets 0 00000011 0 00111111 0 10000011 0 10111111
équivaut à la locomotive 3, 128 pas de vitesse, direction avant et pas de vitesse 3 (l'octet de fin est le contrôle d'erreur XOR)
par exemple une adresse de 3 octets 0 00000011 0 10010000 0 10110011
équivaut à la locomotive 3, groupe de fonctions 1, FL s'allume plus octet XOR (un bit '0' sépare chaque octet)
Voir la vidéo de démonstration ci-jointe pour la locomotive 12.
Les fonctions F1 - F8 sont disponibles via la touche 'A', DIR (touche '*' = direction) FL (touche '0' = lumières) et la touche '#' donne les locomotives 10 à 19 sur le pavé numérique. La touche « D » est maintenant utilisée pour un « ARRÊT d'urgence ».
Merci à divers fournisseurs sur le Web pour les sources d'informations DCC et le code Arduino.
En particulier, ce projet a été inspiré par Michael Blank et son 'Simple DCC - a command station'
www.oscale.net/en/simpledcc
4x4 Matrix Array 16 touches clavier à membrane (ebay) 1,75 €
Module d'affichage LCD TFT SPI série 2,2 pouces 240x320 (ebay) 7,19 €
ADAPTATEUR AC UNIVERSEL 12V 5A 60W (ebay) 6,49 €
Nano V3.0 pour Arduino avec CH340G 5V 16M compatible ATmega328P (ebay) 2 x 3,30 £ = 6,60 £
Module de pilote de moteur LMD18200T pour Arduino R3 (ebay) 6,99 €
Connecteurs, fil, carte vero, potentiomètre environ 3,50 £
Total £32,52
La station de commande de base sans écran tft et 1 x nano serait de 22,03 £
[Remarque: Il est possible d'ajouter une carte mémoire à l'écran TFT et de modifier le code pour afficher les images des moteurs sélectionnés, bien que les codes de la bibliothèque doivent être modifiés pour créer plus de mémoire pour le croquis. La taille actuelle de l'esquisse est au maximum pour le TFT Arduino Nano]
Le code Arduino original de Michael Blank était pour un moteur, avant/arrière uniquement sans contrôle de fonction, sans clavier et sans affichage.
J'ai modifié le code pour inclure 1 à 19 moteurs, un écran d'affichage, une direction, des lumières, 8 fonctions, un arrêt d'urgence et une limite de courant automatique.
Le pont LMD18200T peut transporter jusqu'à 3 ampères, ce qui le rend adapté à toutes les échelles, y compris l'échelle G (trains de jardin). L'alimentation secteur et l'électronique ne conviennent qu'à une utilisation en intérieur, à moins que vous ne puissiez le rendre à l'épreuve des intempéries. J'ai le poste de commande dans la maison d'été avec des fils de connexion ferroviaires qui traversent le mur jusqu'à la voie.
Étape 1: Code Arduino - Station de commande avec clavier
Mes remerciements à tvantenna2759 pour avoir signalé 2 erreurs dans le schéma de circuit où le code Arduino ne correspondait pas au câblage, maintenant mis à jour (21 octobre 2017).
Maintenant ajouté 16 aiguillages à la station de commande. Voir instructable sur le schéma de circuit d'aiguillage / points à l'aide du module Arduino Mini Pro.
Le code modifié, y compris le contrôle des aiguillages, est joint ci-dessous.
Le paquet de décodeur d'accessoire de base est: 0 10AAAAAA 0 1AAACDDD 0 EEEEEEEE 1 À partir de l'analyse du paquet utilisé par Lenz (Compact / Atlas) pour le contrôle des points, j'ai utilisé le format de paquet binaire suivant pour les octets 1 et 2: tunAddr = 1 Aiguillage 1a: 1000 0001 1111 1000 / Aiguillage 1b: 1000 0001 1111 1001 Aiguillage 2a: 1000 0001 1111 1010 / Aiguillage 2b: 1000 0001 1111 1011 Aiguillage 3a: 1000 0001 1111 1100 / Aiguillage 3b: 1000 0001 1111 1101 Aiguillage 4a: 1000 0001 1111 1110 / Aiguillage 4b: 1000 0001 1111 1111 tunAddr = 2 ----------------------------------------- -------------------------------------------------- ----------------- Aiguillage 5a: 1000 0010 1111 1000 / Aiguillage 5b: 1000 0010 1111 1001 Aiguillage 6a: 1000 0010 1111 1010 / Aiguillage 6b: 1000 0010 1111 1011 Aiguillage 7a: 1000 0010 1111 1100 / Aiguillage 7b: 1000 0010 1111 1101 Aiguillage 8a: 1000 0010 1111 1110 / Aiguillage 8b: 1000 0010 1111 1111 ----------------------- -------------------------------------------------- ---------------------------------- Aiguillage 9a: 1000 0011 1111 1000 / Aiguillage 9b: 1000 0011 1111 1001 etc ………
Extrait du code modifié: ajoutez 2 autres mises à jour de message 'struct'void amend_tun1 (struct Message & x) { x.data[0] = 0x81; // décodeur accessoire 0x80 & adresse 1 x.data[1] = 0; }
void amend_tun2 (struct Message & x) { x.data[0] = 0x82; // décodeur accessoire 0x80 & adresse 2 x.data[1] = 0; }
Ajouter un nouveau vide pour les aiguillages: boolean read_turnout() { delay(20);
booléen changes_t = false; Obtenir la clé();
if (key_val >= 101 && key_val <= 404 && turn == 1){
données = 0xf8; // = binaire 1111 1000
amend_tun1(msg[1]);
}
if (key_val >= 505 && key_val <= 808 && turn == 1){
données = 0xf8; // = binaire 1111 1000
amend_tun2(msg[1]);
}
if (key_val == 101 && turn == 1){
si (tun1 == 1){
données |= 0; // t1a
modifié_t = vrai;}
si (tun1 == 0){
données |= 0x01; // t1b
modifié_t = vrai;}
}
if (key_val == 202 && turn == 1){
si (tun2 == 1){
données |= 0x02; // t2a
t_changé = vrai;
}
si (tun2 == 0){
données |= 0x03; // t2b
t_changé = vrai; }
}
if (key_val == 303 && turn == 1){
si (tun3 == 1){
données |= 0x04; // t3a
t_changé = vrai;
}
si (tun3 == 0){
données |= 0x05; // t3b
modifié_t = vrai;}
}
if (key_val == 404 && turn == 1){
si (tun4 == 1){
données |= 0x06; // t4a
t_changé = vrai;
}
si (tun4 == 0){
données |= 0x07; // f4b
modifié_t = vrai;}
}
if (key_val == 505 && turn == 1){
si (tun5 == 1){
données |= 0; // t5a
t_changé = vrai;
}
si (tun5 == 0){
données |= 0x01; // t5b
modifié_t = vrai;}
}
etc ………………….
Étape 2: Code Arduino - Affichage TFT
Le circuit d'affichage reste le même avec un code modifié pour montrer l'état des 16 aiguillages. Remarque: le code de la bibliothèque occupe la quasi-totalité de la mémoire du code d'esquisse, laissant peu de place aux nouvelles fonctionnalités. Si quelqu'un a un fichier de bibliothèque plus efficace pour le TFT utilisé ici, merci de me le faire savoir.
Étape 3: Contrôleur d'aiguillage
Voir instructable sur la façon de faire le contrôleur Aiguillage / Points.
Le circuit complet contrôle 16 points et 15 accessoires tels que lumières, sons, platine, etc.
Conseillé:
Agencement de chemin de fer miniature automatisé exécutant deux trains (V2.0) - Basé sur Arduino : 15 étapes (avec photos)
Agencement de chemin de fer miniature automatisé exécutant deux trains (V2.0) | Basé sur Arduino : L'automatisation des configurations de chemin de fer miniature à l'aide de microcontrôleurs Arduino est un excellent moyen de fusionner les microcontrôleurs, la programmation et le modélisme ferroviaire en un seul passe-temps. Il y a un tas de projets disponibles sur la conduite d'un train de manière autonome sur un modélisme ferroviaire
Disposition de chemin de fer modèle automatisé simple - Contrôlé par Arduino : 11 étapes (avec photos)
Disposition de chemin de fer modèle automatisé simple | Contrôlé par Arduino : les microcontrôleurs Arduino sont un excellent ajout au modélisme ferroviaire, en particulier lorsqu'il s'agit d'automatisation. Voici un moyen simple et facile de démarrer avec l'automatisation des chemins de fer miniatures avec Arduino. Alors, sans plus tarder, commençons
Chemin de fer miniature contrôlé par pavé tactile pour ordinateur portable - Interface PS/2 Arduino : 14 étapes
Chemin de fer miniature contrôlé par pavé tactile pour ordinateur portable | Interface PS/2 Arduino : le pavé tactile d'un ordinateur portable est l'un des excellents appareils à utiliser comme entrée pour les projets de microcontrôleur. Alors aujourd'hui, implémentons cet appareil avec un microcontrôleur Arduino pour contrôler un modélisme ferroviaire. A l'aide d'un touchpad PS/2, nous pourrons contrôler 3 t
Agencement de chemin de fer modèle automatisé faisant fonctionner deux trains : 9 étapes
Schéma de modèle de chemin de fer automatisé exécutant deux trains: J'ai fait un schéma de train de modèle automatisé avec Passing Siding il y a quelque temps. À la demande d'un collègue, j'ai fait ce Instructable. Cela ressemble un peu au projet mentionné plus haut. Le réseau accueille deux trains et les fait alterner
Modèle de chemin de fer automatisé point à point avec voie de garage : 10 étapes (avec photos)
Chemin de fer modélisé point à point automatisé avec voie de garage : les microcontrôleurs Arduino ouvrent de grandes possibilités dans le modélisme ferroviaire, en particulier en ce qui concerne l'automatisation. Ce projet est un exemple d'une telle application. C'est la continuation d'un des projets précédents. Ce projet comprend un point