Voir les contributions

Cette section vous permet de consulter les contributions (messages, sujets et fichiers joints) d'un utilisateur. Vous ne pourrez voir que les contributions des zones auxquelles vous avez accès.


Messages - bobyAndCo

Pages: 1 ... 18 19 [20] 21
286
Le logiciel DCC++ / Re : DCC++ BaseStation
« le: septembre 04, 2016, 05:39:35 pm »
Bonjour à tous,

Il n’aura certainement pas échappé à ceux qui se sont intéressés à DCC++ que ce dernier permettait de communiquer par Ethernet en plus de la traditionnelle liaison série. L’un des nombreux points forts de DCC++ est qu’il fonctionne avec l’envoi de simples messages textuels structurés et ça fonctionne !

Dans ce post, je vais décrire comment paramétrer les réglages Ethernet et vous trouverez également en fin en téléchargement un petit "controller" pour piloter DCC++ avec un navigateur web ou pourquoi pas votre tablette ou votre smartphone en wifi  :)




DCC++ Base Station utilise les mêmes messages en communication série ou Ethernet. Ces messages qui sont en fait des commandes, sont envoyés au programme et doivent être placés entre ‘<’ et ‘>’. Ce que vous mettrez avant ‘<’ ou après ‘>’ sera ignoré par DCC++. Pour plus de détails sur les commandes : https://github.com/DccPlusPlus/BaseStation/wiki/Commands-for-DCCpp-BaseStation

Cette précision est importante car en communication Ethernet avec le protocole HTTP on envoie plus que cela et ce sont les ‘<’ et ‘>’  qui vont permettre d’identifier la commande à l’intérieur de tout le texte des requêtes.

Pour utiliser Ethernet vous devrez bien sûr disposer d’un Arduino MEGA (les autres ne sont pas supportés) d’un shield Ethernet. Pour le reste vous n’avez pratiquement besoin que de votre ordinateur et d’un réseau Ethernet « domestique » qui est fourni par votre box.

Dans DCC++, c’est dans le fichier Config.h que l’on sélectionne la communication par Ethernet. Ligne 34 : #define COMM_INTERFACE   à 1,2 ou 3 selon votre shield.

// DEFINE COMMUNICATIONS INTERFACE
//
//  0 = Built-in Serial Port
//  1 = Arduino.cc Ethernet/SD-Card Shield
//  2 = Arduino.org Ethernet/SD-Card Shield
//  3 = Seeed Studio Ethernet/SD-Card Shield W5200

#define COMM_INTERFACE   1

Il faudra également décommenter la ligne 41 : #define IP_ADDRESS { 192, 168, 1, 200 }

// DEFINE STATIC IP ADDRESS *OR* COMMENT OUT TO USE DHCP
//

#define IP_ADDRESS { 192, 168, 1, 200 }

Mais auparavant on va tout de même s’assurer que cette adresse IP 192.168.1.200 peut « s’insérer » dans votre réseau domestique. Sur Mac, ces informations sont disponibles dans « Préférences Système » -> Réseau.

Sur mon ordinateur, l’adresse IP est 192.168.1.31 ce qui veut dire que toutes les adresse IP de mon réseau domestique vont de 192.168.1.1 à 192.168.1.254, et que mon Arduino + Ethernet devrait pouvoir trouver sa place à l’intérieur avec l'adresse IP 192.168.1.200.

Pour ceux qui maîtrisent un peu plus ces questions, faites un PING en Mac avec « Utilitaire de réseau »



Sur PC, c'est  -> démarrer / exécuter / cmd/k ipconfig /all (je crois).

Dans le fichier confi.h, laissez le port HTTP tel qu’il est configuré à 2560. Voilà donc à quoi devrait ressembler notre code dans Config.h

Config.h
COPYRIGHT (c) 2013-2016 Gregg E. Berman

Part of DCC++ BASE STATION for the Arduino

**********************************************************************/

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE MOTOR_SHIELD_TYPE ACCORDING TO THE FOLLOWING TABLE:
//
//  0 = ARDUINO MOTOR SHIELD          (MAX 18V/2A PER CHANNEL)
//  1 = POLOLU MC33926 MOTOR SHIELD   (MAX 28V/3A PER CHANNEL)

#define MOTOR_SHIELD_TYPE   0

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE NUMBER OF MAIN TRACK REGISTER

#define MAX_MAIN_REGISTERS 12

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE COMMUNICATIONS INTERFACE
//
//  0 = Built-in Serial Port
//  1 = Arduino.cc Ethernet/SD-Card Shield
//  2 = Arduino.org Ethernet/SD-Card Shield
//  3 = Seeed Studio Ethernet/SD-Card Shield W5200

#define COMM_INTERFACE   1

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE STATIC IP ADDRESS *OR* COMMENT OUT TO USE DHCP
//

#define IP_ADDRESS { 192, 168, 1, 200 }

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE PORT TO USE FOR ETHERNET COMMUNICATIONS INTERFACE
//

#define ETHERNET_PORT 2560

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE MAC ADDRESS ARRAY FOR ETHERNET COMMUNICATIONS INTERFACE
//

#define MAC_ADDRESS {  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEF }

/////////////////////////////////////////////////////////////////////////////////////

ATTENTION : Il manque quelques lignes de code dans DCC++ Base Station qui utilise la bibliothèque Ethernet de l’Arduino. Dans le fichier SerialCommand.cpp il faudra ajouter à la ligne 66 :

INTERFACE.println("HTTP/1.1 200 OK");
      INTERFACE.println("Content-Type: text/html");
      INTERFACE.println("Access-Control-Allow-Origin: *");
      INTERFACE.println("Connection: close");
      INTERFACE.println();

et entre les lignes 73 et 74 (qui seront devenues 80 et 81)

client.stop();

Code complet :

#elif COMM_TYPE == 1

    EthernetClient client=INTERFACE.available();

    if(client){

      INTERFACE.println("HTTP/1.1 200 OK");
      INTERFACE.println("Content-Type: text/html");
      INTERFACE.println("Access-Control-Allow-Origin: *");
      INTERFACE.println("Connection: close");
      INTERFACE.println();
     
      while(client.connected() && client.available()){        // while there is data on the network
      c=client.read();
      if(c=='<')                    // start of new command
        sprintf(commandString,"");
      else if(c=='>')               // end of new command
        parse(commandString);                   
      else if(strlen(commandString)<MAX_COMMAND_LENGTH)    // if comandString still has space, append character just read from network
        sprintf(commandString,"%s%c",commandString,c);     // otherwise, character is ignored (but continue to look for '<' or '>')
      } // while
     
      client.stop();
     
    }

  #endif

Le code étant le même pour COMM_TYPE == 0 (communication série) assurez vous que vous l’avez bien recopié dans #elif COMM_TYPE == 1

Voilà pour la programmation de la carte. Si vous uploadez, vous devez avoir un message de ce type dans le moniteur série de l’IDE avec l’adresse IP en fin :
<iDCC++ BASE STATION FOR ARDUINO MEGA / ARDUINO MOTOR SHIELD: V-1.2.1+ / Aug 22 2016 15:52:06><N1: 192.168.1.200>

Une précision toute bête mais assurez-vous que votre shield Ethernet est bien relié à votre box par un câble RJ 45 ! Vous pourrez faire un nouveau ping toujours sur cette adresse 192.168.1.200 qui doit maintenant s’afficher.

Voilà pour la carte. Votre Arduino c’est transformé en petit serveur web qui va répondre aux requêtes HTTP sur son adresse IP.

La partie "client", c'est le Mini Controller DCC++ que vous allez trouver en fin de ce post. Mais pour que cette application fonctionne, il nous faut disposer d'un serveur web qui soit interne à notre réseau domestique et qui va héberger nos pages HTML, pages de programmation, feuilles de style et images.

Vous pouvez tout a fait utiliser votre box par exemple si elle fait serveur web ou si vous avez déjà un serveur web interne à votre domicile. Mais nous allons ici choisir d’installer ce serveur web sur notre propre ordinateur et pour cela, nous allons télécharger puis installer un logiciel gratuit mais très puissant qui est à la fois un serveur web, un serveur SQL et capable d’exécuter des scripts PHP (nous en aurons besoin assez rapidement quand notre application prendra de l’importance).

Ce logiciel s’appelle MAMP dans sa version Mac, WAMP dans sa version PC et XAMPP sous Linux. Choisissez la version gratuite largement suffisante. Voici les liens de téléchargement :

Mac : https://www.mamp.info/en/
PC : http://www.wampserver.com/
Linux : https://www.apachefriends.org/fr/download.html

Normalement, l’installation ne doit vous poser aucun problème car elle est vraiment très simple. Au besoin, consultez le tuto sur  OpenClassrooms

Sur votre ordinateur, vous devez déterminer un répertoire bien précis qui va être l’espace disque réservé pour votre serveur web. Choisissez par exemple de le « ranger » dans « Mes documents/mon_petit_train/dossier_web ».

Lancez maintenant l’application MAMP (ou WAMP, ou XAMPP) qui ouvre normalement automatiquement le serveur web et le serveur mySql, (cases en haut à droite de couleur verte).



Clickez sur le bouton « Préférences » à gauche au milieu

Sur la première fenêtre, sélectionnez tout de suite le répertoire que vous avez créé précédemment et qui va devenir la racine de votre serveur web. Pour cela cliquez sur l’icone à droite de « Document Root » et naviguez jusqu’à trouver votre dossier :




Dossier racine qui pour l’instant ne contient rien. Concernant les autres onglets en haut de la fenêtre MAMP, ne changez rien.



L’onglet Ports vous renseigne sur les paramétrages de ports que MAMP a programmés automatiquement. Ne changez rien. Par contre, notez que MAMP a attribué au Port Apache (c’est à dire au serveur web) le port 8888. Nous en aurons besoin par la suite.

Cliquez sur "annuler" pour sortir et vous vous retrouvez sur la fenêtre principale de MAMP que vous allez maintenant laisser travailler bien tranquillement en tâche de fond. Ne quittez pas MAMP car vous désactiveriez alors le serveur web.

Téléchargez le fichier joint : maPageTest.html.zip que vous allez dézipper et placer dans votre répertoire web, normalement « Mes documents/mon_petit_train/dossier_web ».

Dans votre navigateur, entrez l’url : http://localhost:8888/maPageTest.html et vous devriez voir apparaître dans la page : « Hello Locoduino ! »

Si oui, bravo, vous avez fini les paramétrages, sinon, retournez en arrière pour trouver où vous vous êtes probablement trompé.

Ca y est vous allez pouvoir maintenant piloter votre locomotive sur votre circuit. Téléchargez le fichier joint controller_mini_dccpp.zip et placez le contenu du dossier dans votre répertoire « Mes documents/mon_petit_train/dossier_web » puis clickez sur le lien http://localhost:8888/controller_mini_dccpp/controller.html ou tout simplement http://localhost:8888/

Attention : Si vous avez donné à votre Arduino MEGA une autre adresse IP que 192.168.1.200:2560 vous devrez modifier la ligne 14 du fichier « controller.js » qui se trouve dans le dossier « scripts » avec un éditeur de texte et entrer votre propre adresse IP.

Voilà un controller assez complet que vous allez personnaliser. En cliquant sur la petite flèche à droite de la fenêtre « paramétrages », vous allez entrer l’adresse de votre locomotive et valider. Profitez pour entrer son nom ainsi que les noms des fonctions pour votre loco. L’image de la loco est dans le dossier « image », vous pouvez placer votre propre image et entrer l’url « img/ma_belle_loco.jpg ». Vous pouvez même si vous le souhaitez trouver une image sur internet et entrer son url entière : http://www.leffondre.fr/_media/img/large/dsc-3385-rec.jpg.

Tous les CV’s peuvent être modifiés dans autres réglages. Attention cependant à ne pas entrer n’importe quoi. Au besoin, le CV 8 auquel on affecte la valeur 8 permet de retrouver les réglages usine. N’oubliez pas modifier ensuite l’adresse sur votre controller puisque la valeur usine est 3 par défaut.

Avec ce Mini Controller, vous allez pouvoir tester DCC++ Base Station avec une locomotive. Par la suite, je développerai comment réaliser un controller pour tout un parc de locomotive en HTML 5 en utilisant le framework AngularJS. Vous verrez ainsi comment vous pourrez "jouer" à plusieurs en WIFI avec des tablettes ou des smartphones.

N’hésitez pas à me faire part de vos remarques et questions ou si vous avez besoin d'aide.

J'espère qu'avec DCC++ et votre controller web, vous connaitrez des expériences intéressantes.

Christophe.

287
Le logiciel DCC++ / Re : DCC++ BaseStation
« le: août 31, 2016, 02:26:46 pm »
J'attends avant de modifier le seuil de détection car je trouve les résultats tellement éloignés de ce qu'il devraient être que je cherche d'abord ailleurs.

J'ai pourtant tout re-re-re vérifié, les câbles les paramètres de DCC++ Base !!! C'est sans doute un truc tout bête mais bon...

Mais je suis preneur de toute proposition...

288
Le logiciel DCC++ / Re : DCC++ BaseStation
« le: août 31, 2016, 01:34:03 pm »
Bonjour Tanguy,

Merci pour votre aide.

En fait, j'utilise un MAX471 pour la lecture de courant. Il ne me semble pas qu'il soit nécessaire d'ajouter une résistance. Cependant, j'ai tout de même essayé puisque je me souviens que vous parliez d'une résistance dans un de vos post et j'ai donc mis 2,2 K. Mais la lecture est la même.

Comme je le disais, je fais des tests en "mélangeant" UNO et MEGA, LMD18200 et POLOLU.

Avec le LMD les résultats sont très incohérents. Avec le POLOLU plus réalistes

<r123|1|123 255>
<r123|1|123 255>
<r123|1|123 100>

Mais il n'empêche que pour la première lecture, la loco a le cv 9, pour la seconde 8 et pour la troisième 8 ???

Je n'arrive même plus à retrouver les "quelques" bons résultats que j'ai obtenus hier avec certaines configs et certaines locos.

Il y a sans doute un problème dans mon alimentation (trop fort en V ?, trop faible ?) Je suis en train d'analyser les bits pour la lecture des mesures de courant !

Amicalement

PS : Peut être pouvons nous nous tutoyer ?

289
Le logiciel DCC++ / Re : DCC++ BaseStation
« le: août 30, 2016, 06:06:27 pm »
Bonjour à tous,

Je vous disais hier que j'avais des problèmes de lectures de CV's avec la fonction < R CV CALLBACKNUM CALLBACKSUB > (lecture des CV's d'une loco sur la voie de programmation). J'ai fait depuis toute une série de tests en utilisant, d'une part un UNO puis un MEGA et le LMD18200 et la carte POLOLU. Détail des mesures en PJ.

MEGA + LMD18200 : Aucune mesure possible, retourne -1 pour tous les CV's
MEGA + POLOLU : Mesures exactes sur 2 machines avec des décodeurs peu sophistiqués (MFX et l'autre n'a que la lumière et même pas le son). Toutes les autres machines avec des décodeurs sophistiqués (ZIMO XB 401, ESU V4.0) retournent -1, lecture impossible.

A préciser que la POLOLU se met en sécurité (sur la voie de prog) dès que l'on pose une loco gourmande en énergie !

UNO+POLOLU : Mêmes résultats qu'avec le MEGA, OK pour 2 machines avec des décodeurs peu sophistiqués, toutes les autres lecture impossible et les machines "énergivores" font disjoncter la carte.

Enfin, UNO+LMD18200, je n'ai aucune mesure cohérente, les valeurs retournées sont erronées !!!

Je ne dis pas que le problème soit universel (Dominique lit ses CV's, sur la voie principale certes, mais de façon correcte) avec un LMD18200.

J'ai aussi fait des tests en variant de 16 à 20 V (en HO) mais ça n'a rien donné.

Alors si quelqu'un à des idées  :) Merci d'avance.

Christophe

290
Le logiciel DCC++ / Re : DCC++ BaseStation
« le: août 30, 2016, 08:59:06 am »
Bonjour Denis,

Non pas en roulant, c'est ce que disait Dominique.

Par contre, il s'est "fabriqué" une méthode :

void SerialCommand::discover() {
  commandString[0] = '1';
  parse(commandString);
  commandString[0] = 'r';
  commandString[1] = ' ';
  commandString[2] = '1';
  commandString[3] = ' ';
  commandString[4] = '1';
  commandString[5] = '2';
  commandString[6] = '3';
  commandString[7] = ' ';
  commandString[8] = '1';
  commandString[9] = '2';
  commandString[10] = '3';
  parse(commandString);
  commandString[0] = '0';
  parse(commandString);
}

"r" dans commandString[0] = 'r'; est créé ad hoc (n'existe pas à l'origine) qu'il "parse" avec une méthode pour la voie principale (qui est similaire à la méthode pour la voie de programmation)

case 'r':     // <r CV CALLBACKNUM CALLBACKSUB>
/*   
 *    reads a Configuration Variable from the decoder of an engine on the main track
 *   
 *    CV: the number of the Configuration Variable memory location in the decoder to read from (1-1024)
 *    CALLBACKNUM: an arbitrary integer (0-32767) that is ignored by the Base Station and is simply echoed back in the output - useful for external programs that call this function
 *    CALLBACKSUB: a second arbitrary integer (0-32767) that is ignored by the Base Station and is simply echoed back in the output - useful for external programs (e.g. DCC++ Interface) that call this function
 *   
 *    returns: <r CALLBACKNUM|CALLBACKSUB|CV VALUE)
 *    where VALUE is a number from 0-255 as read from the requested CV, or -1 if read could not be verified
*/   
      mRegs->readCV_Main(com+1);
      break;

On voit case 'r' au début et  mRegs-> en fin (pour la voie principale)

Le tout appelé dans le setup pour faire apparître l'adresse dans le moniteur série :

mainRegs.addressDccToDiscover = 3;
  SerialCommand::discover(); // dcc adress found is stored in readCV_Main()
  Serial.println();
  Serial.print("adresse DCC : ");Serial.println(mainRegs.addressDccToDiscover);

Voilà.

Christophe


291
Le logiciel DCC++ / Re : DCC++ BaseStation
« le: août 30, 2016, 07:30:10 am »
Bonjour Dominique,

Oui j'ai regardé ton code. Les seules différences sont que tu es sur la voie principale et moi sur la voie de programmation et que tu utilises un LMD18200 et moi un Pololu !

Je vais commencer par changer le booster pour tester. J'ai 16 V (en HO) à l'entrée du booster, cela est correct, non ?

Je fais de nouveaux tests ce matin et fais le retour.

Merci

Christophe

292
Le logiciel DCC++ / Re : DCC++ BaseStation
« le: août 29, 2016, 07:24:50 pm »
Dominique,

C'est quoi "rm" au début du return ? Et tu as envoyé quoi comme texte ?

Merci

293
Le logiciel DCC++ / Re : DCC++ BaseStation
« le: août 29, 2016, 05:51:58 pm »
Bonsoir à tous,

Je suis en train de tester la lecture des valeurs de CV's < R CV CALLBACKNUM CALLBACKSUB > mais impossible d'obtenir d'autre réponse que :  -1 étant "vérification impossible". Exemple : <r12|13|1 -1>.

Returns: **< r CALLBACKNUM|CALLBACKSUB|CV VALUE>
CV VALUE is a number from 0-255 as read from the requested CV, or -1 if read could not be verified.

Je suis sur Mega avec carte Pololu, j'ai fait le test en port série et en Ethernet. La voie de programmation est bien alimentée, diodes de la carte allumée et la loco a bien le comportement typique de la programmation (léger mouvement + phares allumés). J'ai ainsi testé dans une boucle les 200 premier CV's de deux locos avec des valeurs (non prises en compte par DCC++ de 12 et 13, puis 100 et 200). Exemple : <R 1 12 13> et c'est à chaque fois la même réponse.

Merci de votre aide, et bien cordialement

Christophe

294
Présentez vous ! / Re : Présentation
« le: août 27, 2016, 05:10:40 pm »
Bonjour drahcoc,

Bienvenue au club ! Tu as du voir qu'il y avait moyen de s'amuser follement avec des "petites cartes", du code... et beaucoup de persévérance parce que ça marche rarement du premier coup.

Christophe

295
Bonjour Denis,

Je profite de ta question pour essayer de bien définir les choses car c’est à mon avis fondamental pour une bonne compréhension.

Il y a tout d’abord l’utilisation du HTML avec son langage de programmation, le Java Script (qui permet quand on appuie sur un bouton par exemple de déclencher une action).

Le HTML est à mon sens intéressant car il permet de réaliser des interfaces graphiques très esthétiques et facilement car il existe pléthore de bibliothèques de style, de boutons, d’images voir même de comportements.

Si on prend l’exemple d’un gestionnaire de réseau tel que nous le décrit Pierre dans son article très intéressant : « Un gestionnaire en C++ pour votre réseau », on peut imaginer que la « couche » HTML ne serve qu’à l’interface graphique. Quelques scripts de comportement derrière les boutons ou les images (qui peuvent être de zones interactives) et quelques méthodes pour échanger avec l’Arduino, et le tour est joué.

L’essentiel du programme est sur l’Arduino tel que par exemple nous le présente Pierre.  Il y a juste à programmer les échanges d’information entre l’interface graphique et l’Arduino selon le protocole choisi.

C’est le second point qui nécessite selon moi d’être bien compris. Aussi étonnant que cela puisse paraître, il est tout à fait possible d’avoir l’interface graphique en HTML, utilisée au travers de son navigateur web préféré sans pour autant utiliser le moindre shield Ethenet sur l’Arduino. Application graphique en HTML + Javascript sont totalement dissociables d’un protocole de communication particulier.

Nul besoin de réécrire l’application qui tourne (parfaitement) sur Arduino, simplement la communication.

D’un autre côté, on peut considérer l’Ethernet (je parle donc bien là de cartes Arduino avec leur shield) comme un bus de communication comme un autre, série, CAN, ou autres. On peut choisir ce canal d’échange pour moult raisons mais sans écrire une seule ligne en HTML ou Java Script. Les cartes échangent entre elles ou avec la centrale avec ce protocole comme elles auraient pu le faire avec un autre.

Donc, la réponse à ta question (qui n’en était pas une d’ailleurs :)) : Oui on peut lui ajouter un gestionnaire de réseau. Ma version personnelle en contient d’ailleurs un pour mes seuls aiguillages pour l’instant.

J’en ai profité pour préciser ces points car certains sont un peu effrayés d’avoir à tout « reconstruire » s’ils se lancent dans l’aventure HTML ou Ethernet. J’espère ainsi les rassurer et les inciter à explorer de nouvelles voies qui ne peuvent qu’enrichir leurs expériences.

Et pour être tout à fait complet, il est aussi possible d'écrire totalement des applications très puissantes en HTML + Java Script car le Java Script est un langage très performant orienté objet (hummm, c'est un délice). Il est donc capable de se substituer pour une bonne part au programme chargé habituellement sur l'Arduino et la réduire presque un un rôle de simple exécutant (envoyer un signal électrique pour activer un aiguillage, changer l'état d'un signalisation).

Bien à vous tous et bon WE,

Christophe

 

296
Bonjour à tous,

J’ai terminé l’adaptation de mon controller (HTML + Angular JS) dont je vous ai parlé il y a quelques jours et qui utilise maintenant la bibliothèque DCC++.

Toutes les commandes de tractions fonctionnent très bien. Toutes les fonctions aussi de F0 à F28. Ca a été pour moi l’occasion d’entendre des sons et des bruitages pour la première fois car j’utilisais jusque là CmdrArduino limitée à 12 + FL.

Toutes les modifications de valeurs pour les cv’s sont aussi possibles. Toutes mes locos sont maintenant pilotables et paramétrables via DCC++. Au passage, ça fonctionne parfaitement avec un LMD18200 comme cela a déjà été confirmé plusieurs fois.

Je vais maintenant m’intéresser à l’exploitation des données de consommation de courant et à la lecture et programmation sur la voie de programmation.

S’agissant d’une application basée sur le HTM, elle doit être hébergée sur un serveur web qui peut être  installé sur votre propre ordinateur. Il existe de très bons freewares.

Il paraît logique, quand on a développé un controller avec des technologies essentiellement issues du monde du web d’utiliser DCC++ en communication Ethernet avec le shield « ad hoc ». C’est là encore particulièrement simple à faire en modifiant quelques paramètres dans le code DCC++. Mais attention toute fois, si vous vous aventurez à utiliser cette bibliothèque en Ethernet, il manque du code !!! Gregg Berman n’a pas fini le travail. Au besoin, je les communiquerai à ceux qui en auraient besoin.

Et là en Ethernet, vous accédez à une autre dimension puisqu’il vous est possible de « jouer » avec un grand nombre de périphériques dont certains en wifi comme les smartphones ou les tablettes. Des terminaux pour piloter vos locos en famille ou entre amis, votre tableau d’aiguillage sur des écrans différents pour augmenter le confort d’utilisation.

Logique disais-je d’utiliser un shield Ethernet mais pas obligé puisque l’on peut aussi demander à un script en PHP sur le serveur web… de communiquer avec l’Arduino par le port série !

A votre disposition pour vous apporter toutes infos supplémentaires sur ce sujet.

A suivre...

297
Le logiciel DCC++ / Re : DCC++ BaseStation
« le: août 23, 2016, 06:39:17 pm »
Alors là je dis chapeau parce que ça veut dire (si je ne trompe pas) que l'on doit pouvoir récupérer l'ensemble des cv's et leur valeur dès que l'on pose la loco sur la voie de programmation. On peut donc renseigner la base de données du controller automatiquement.

Ca devrait donc aussi vouloir dire que si la loco possède une adresse déjà attribuée (et stockée dans la base de données controller), il est possible de lui en affecter automatiquement une autre qui est libre.

Je suis certain que ce que tu nous soumets ouvre sur bien d'autres potentialités.

298
Le logiciel DCC++ / Re : DCC++ BaseStation
« le: août 22, 2016, 01:34:23 pm »
Bonjour à tous,

Je me suis moi même intéressé au DCC++ que j’ai testé avec succès. Ce programme est d’une simplicité d’utilisation déconcertante. J’ai bien dit d’utilisation car quand on regarde le code, c’est "chiadé", propre. Nul doute que Gregg Berman possède un don pour la programmation.

Mais je crois qu’il est moins doué pour le graphisme et l’esthétisme si j’en juge par son controller (DCCpp_Controller) ! Cela a déjà été précisé ailleurs mais il est important de rappeler que DCC++ peut fonctionner indépendamment de DCC++ Controller. Il y a là un côté génial car vous pouvez utiliser pratiquement tout sortes de moyens pour envoyer des ordres à votre Arduino sur laquelle vous avez recopié tel quel le code de DCC++ BasrStation et ça marche !

Vous pouvez utiliser JMRI ou RocRail par exemple, mais vous pouvez aussi (facilement) créer votre propre "controller".

A la base, c’est assez déconcertant, après avoir relié tout le hardware et alimenté l’ensemble, puis entré dans le moniteur série de l’IDE d’Arduino : <1> puis <t 1 3 10 1> de voir que la locomotive adresse 3 démarre bien à la vitesse 10 en avant. Entrez maintenant <t 1 3 10 0> et elle va partir en arrière toujours à la vitesse 10. Plus vite maintenant toujours en arrière <t 1 3 80 0>  à la vitesse 80. Voir aussi le premier post de Tanguy : http://forum.locoduino.org/index.php?topic=203.0

Tout a été fait pour que l’utilisation soit la plus simple possible. Certes, taper des <t 1 3 10 1> <t 1 3 10 0> ou autres <t 1 3 10 0> dans la fenêtre série pour piloter son réseau est un peu fastidieux mais beaucoup plus réaliste avec un petit programme simple qui saurait envoyer ces séquences d’ordres au port série ou à un shield Ethernet que vous auriez implanté sur votre Arduino Mega ! Eh oui, DCC++ ne peut communiquer par Ethernet qu’avec un Mega, avec son code actuel, il faut le préciser.

J’utilise l’Ethernet sur tout mon réseau et on m'a déjà demandé plusieurs fois d'expliciter la chose. Se servir de l’Ethernet n’est pas aussi compliqué qu’on le pense sans doute. Tout d’abord, on utilise son « bon vieux » réseau domestique, Free, Bouygues ou Orange et on peut concevoir de piloter son réseau avec son navigateur web ou son smartphone. A voir les vidéo sur le net, ça semble être le grand phantasme des amateurs de N ou de HO. Et pourquoi pas tous les smarthones de la famille car Ethernet permet le raccordement de terminaux multiples contrairement au port série. Mais cela peut être aussi un pilotage principal sur l’ordinateur, les commandes d'accessoires dont les aiguilles sur tablettes et pour le fun, une loco sur smarphone.

Voici un lien sur mon controller actuel : http://89.225.199.180/train_HO/locomotives/controller_demo.html

Cette version n’utilise pas encore DCC++ mais je suis en train de m’y consacrer.

Alors, je vous propose de rédiger un sujet sur la mise en œuvre de cette technologie et sur la réalisation des applications web à développer. Pour ce faire, j’aimerai que vous puissiez me remonter vos différentes attentes et questions sur le sujet afin que je puisse y répondre au mieux. A cet effet, j’ai ouvert un nouveau sujet dans la rubrique Modélisation, Architecture logicielles et matérielles : http://forum.locoduino.org/index.php?board=13.0

Je vous propose de nous retrouver sur ce tropic et merci par avances de vos contributions.

Bien à vous.

Christophe


299
Bonjour à tous,

J’ai ouvert ce nouveau sujet car il y a semble t’il un certain intérêt dans la communauté Locoduino pour la communication par Ethernet sur nos réseaux et somme toute peu (peut être rien) sur le site.

Ethernet n’est qu’une technologie. TCP/IP, c’est déjà un peu plus précis, c’est un protocole de communication entre différents appareils. Des ordinateurs, des tablettes et des smartphones et bien sûr nos petites cartes chéries pour peu qu’on y mette « à cheval » les shields appropriés : https://www.arduino.cc/en/Main/ArduinoEthernetShield

Et encore à l’intérieur de TCP/IP, HTTP. Là ça vous parle mieux, c’est quand votre navigateur consulte des pages HTML sur des serveur ou que parfois vous envoyez des informations quand vous remplissez des formulaires et appuyez sur le bouton « envoyer » Submit !

Nos Uno’s, Mega’s et autres peuvent se transformer en serveurs Web ; eh oui ! Modestes certes, mais très efficaces pour nos besoins en modélisme ferroviaire.

Ce fil est ouvert pour essayer de répondre si possible à toutes vos questions, mais il a aussi pour ambition de présenter des applications concrètes qui utilisent ce protocole.

Pour ma part, j’ai développé un controller de locomotives pour mon réseau et qui permet aussi de piloter les aiguillages. Visible en version démo

Si vous avez suivi les différents fils récents sur le forum, vous avez sans doute vu que ça s'agitait beaucoup autour de DCC++. C’est que c’est bigrement intéressant et prometteur. Dominique en particulier s’est « emparé » du sujet avec frénésie et il a raison je crois.

Pour ma part, mon ambition est d’adapter mon controller ci-dessus à DCC++ et vous faire un retour. Ce sera un exemple concret de mise en œuvre de Ethernet sur Arduino. Et vous verrez qu’au final, c’est beaucoup moins compliqué qu’il n’y parait.

Dans l’attente de vos retours et au plaisir de vous lire.

Christophe

300
Bus DCC / Re : DCC & CVs
« le: août 20, 2016, 09:12:09 am »
Bonjour Dominique,

Tout d’abord, je te remercie pour ton inlassable contribution à faire évoluer « la chose ». Je n’avais pas vu dans DCC++ qu’il y avait possibilité de lire les CV’s et pour cause, puisque tu dis que c’est une fonction que tu as développé toi même ;-). Je suis très intéressé que tu nous mettes à disposition le code.

Je tiens à préciser que je ne suis pas particulièrement défenseur de Railcom plus que de tout autres technologies. Bien au contraire, je crois qu’il faut chercher à s’approprier le meilleur de tout ce qui est à notre disposition et  marier tout cela. Et donc pourquoi pas Railcom et DCC++. Mais Railcom est commercial et il difficile de se procurer les sources.

A suivre je pense ! Et que certains d’entre nous travaillent dans différentes directions pour ensuite croiser les résultats et le rendre disponible aux autres me paraît une bonne chose. Au final, le sujet principal qui nous préoccupe est bien celui de la détection et de la rétro signalisation des locos.

Au passage, je voudrais signaler que j’ai fait le choix sur mon réseau de communiquer entièrement en TCP/IP. Il y a à cela plusieurs raisons dont celle qui était de pouvoir développer un controller en HTML 5 pour disposer d’une gigantesque bibliothèque graphique de potentiomètres, boutons etc…. Associé à un langage de programmation objet puissant, AngularJS (Framework javascript), ça marche vraiment bien et c’est quand même beaucoup plus ouvert (possibilité de plusieurs controllers pour un même réseau dont smartphones et tablettes, WIFI inclus, possibilité de communiquer en PHP avec des bases de données type SQL…)

Voici le lien sur mon controller en version démo : http://89.225.199.180/train_HO/locomotives/controller_demo.html

(J’ai testé avec Chrome, rien n’est garanti pour les autres navigateurs)

C’était juste un clin d’œil par rapport au controller proposer avec DCC++. Avouez que ça a un peu plus de « tête » non ? Mais je ne voudrais pas créer une confusion et préciser que DCC++ et son controller sont indépendants ce qui n’interdit pas d’utiliser le premier avec autre chose que le second. C’est d’ailleurs ce que tu fais avec tes manettes.

Je ne manquerai pas de tester DCC++ avec ton code de lecture de CV et je vous ferai un retour. Et pour ceux que ça intéresse, je veux bien développer sur la communication par Ethernet en TCP/IP.

Bien amicalement

Christophe

Pages: 1 ... 18 19 [20] 21