LOCODUINO
Parlons Arduino => Vos projets => Discussion démarrée par: frederic le février 10, 2024, 06:00:21 pm
-
bonjour,
Je suis en train de construire un TCO physique (écran, bouton poussoir, horloge)qui viendra en complément de la gestion complète par ordinateur et Arduino
actuellement le programme joint fonctionne, mais quand j' active la communication (en gris ou /**/), entre ordi et Arduino (USB) plus aucun bouton fonctionne mais les ordres donné depuis l' ordi fonctionne, je voudrais les 2 lol
pouvez vous m' aider SVP.
#include <PCA9685.h> //platine servomoteur
PCA9685 pwmController;
PCA9685_ServoEval pwmAngleValue;
#include <LiquidCrystal_I2C.h> // ecran LCD 20x4
LiquidCrystal_I2C lcd(0x27, 20, 4);
#include <virtuabotixRTC.h> //module horloge
virtuabotixRTC myRTC(6, 7, 8);
// vitesse servomoteur
int Attente = 25; // vitesse servomoteur
// position aiguillage
int AIG1 = 0; // position aiguillage
int AIG2M1 = 0;
int AIG2M2 = 0;
int AIG3 = 0;
int AIG4 = 0;
int AIG5 = 0;
int AIG6 = 0;
int AIG7 = 0;
// variable anti retour
int etat0 = 0; // variable anti retour
int etat1 = 0;
int etat2 = 0;
int etat3 = 0;
int etat4 = 0;
int etat5 = 0;
int etat6 = 0;
int etat7 = 0;
// Déclaration des entrées pour les boutons poussoir
const int BvoieA = 27;
const int BvoieB = 26;
const int BvoieC = 25;
const int BvoieD = 24;
const int BvoieE = 28;
const int Bentrernord = 22;
const int Bsortienord = 23;
const int Bentrersud = 30;
const int Bsortiesud = 29;
// Variable de stockage de l'instruction reçu
String reception = "";
void setup() {
Serial.begin(9600);
lcd.init();
lcd.backlight();
// Etat des entrées pour les boutons poussoir
pinMode(BvoieA, INPUT);
pinMode(BvoieB, INPUT);
pinMode(BvoieC, INPUT);
pinMode(BvoieD, INPUT);
pinMode(BvoieE, INPUT);
pinMode(Bentrernord, INPUT);
pinMode(Bsortienord, INPUT);
pinMode(Bentrersud, INPUT);
pinMode(Bsortiesud,INPUT);
//myRTC.setDS1302Time(18, 39, 15, 7, 25, 12, 2023);// activé pour régler l' horloge
Wire.begin(); // Initialisation de l'interface I2C
// Ré-initialisation des PCA9685 sur la ligne I2C
pwmController.resetDevices();
pwmController.init(); // Initilisation du module
// Définit une fréquence f=5OHz soit T=20ms
// pour les Servomoteurs standard
pwmController.setPWMFreqServo();
}
void loop() {
// identificatition des éléments
myRTC.updateTime();
Serial.print("Current Date / Time: ");
Serial.print(myRTC.dayofmonth);
Serial.print("/");
Serial.print(myRTC.month);
Serial.print("/");
Serial.print(myRTC.year);
Serial.print(" ");
Serial.print(myRTC.hours);
Serial.print(":");
Serial.print(myRTC.minutes);
Serial.print(":");
Serial.println(myRTC.seconds);
// organisation écran LCD
lcd.setCursor(0, 0);
lcd.print("**BLAUSEE--MITHOLZ**");
lcd.setCursor(0, 1);
lcd.print(myRTC.hours);
lcd.print(":");
lcd.print(myRTC.minutes);
lcd.print(" ");
lcd.print(myRTC.dayofmonth);
lcd.print("/");
lcd.print(myRTC.month);
lcd.print("/");
lcd.print(myRTC.year);
// Attente des instructions du uno
/*while(true){
if (Serial.available()){
//reception = Serial.readStringUntil('\n');
//break;// Sortie de la boucle
}
}
*/
// "1" aiguillage en position droite
// "2" aiguillage en position dévier
//ordre donnée par bouton poussoir
if(digitalRead(Bentrernord) == HIGH) {if(digitalRead(BvoieB) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Nord sur voie B");
AIG2M1 = 1;
AIG2M2 = 2;
}
}
if(digitalRead(Bentrernord) == HIGH) {if(digitalRead(BvoieC) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Nord sur voie C");
AIG2M1 = 1;
AIG2M2 = 1;
AIG3 = 1;
}
}
if(digitalRead(Bentrernord) == HIGH) {if(digitalRead(BvoieD) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Nord sur voie D");
AIG2M1 = 1;
AIG2M2 = 1;
AIG3 = 2;
}
}
if(digitalRead(Bsortienord) == HIGH) {if(digitalRead(BvoieB) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Voie B sur Nord");
AIG2M1 = 1;
AIG2M2 = 2;
AIG1 = 2;
}
}
if(digitalRead(Bsortienord) == HIGH) {if(digitalRead(BvoieC) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Voie C sur Nord");
AIG2M1 = 1;
AIG2M2 = 2;
AIG1 = 2;
}
}
if(digitalRead(Bsortienord) == HIGH) {if(digitalRead(BvoieD) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Voie D sur Nord");
AIG2M1 = 1;
AIG2M2 = 2;
AIG1 = 2;
}
}
if(digitalRead(Bsortienord) == HIGH) {if(digitalRead(BvoieA) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Voie A sur Nord");
AIG1 = 1;
}
}
if(digitalRead(BvoieD) == HIGH) {if(digitalRead(BvoieE) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Voie D sur Voie E");
AIG4 = 2;
AIG5 = 2;
}
}
if(digitalRead(BvoieC) == HIGH) {if(digitalRead(BvoieE) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Voie C sur Voie E");
AIG4 = 1;
AIG5 = 2;
}
}
if(digitalRead(BvoieB) == HIGH) {if(digitalRead(BvoieE) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Voie B sur Voie E");
AIG5 = 1;
}
}
if(digitalRead(BvoieE) == HIGH) {if(digitalRead(Bentrersud) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("sud sur Voie E ");
AIG6 = 2;
AIG7 = 2;
}
}
if(digitalRead(BvoieE) == HIGH) {if(digitalRead(Bsortiesud) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Voie E sortie Sud");
AIG6 = 1;
}
}
if(digitalRead(BvoieA) == HIGH) {if(digitalRead(Bentrersud) == HIGH)
{
lcd.setCursor(0, 2);
lcd.print("Voie A sortie Sud");
AIG7 = 1;
}
}
// ordre donné de l' ordi
/*if (Serial.available()){
AIG1-1 = Serial.read();
AIG1 = 1;
lcd.setCursor(0, 2);
lcd.print("!!PILOTE PAR ORDI!!");
lcd.setCursor(0, 3);
lcd.print("!!PILOTE PAR ORDI!!");
}
if (reception == "AIG1-2"){
AIG1 = 2;
lcd.setCursor(0, 2);
lcd.print("!!PILOTE PAR ORDI!!");
lcd.setCursor(0, 3);
lcd.print("!!PILOTE PAR ORDI!!");
}
if (reception == "AIG2M1-1"){
AIG2M1 = 1;
}
if (reception == "AIG2M1-2"){
AIG2M1 = 2;
}
if (reception == "AIG2M2-1"){
AIG2M2 = 1;
}
if (reception == "AIG2M2-2"){
AIG2M2 = 2;
}
if (reception == "AIG3-1"){
AIG3 = 1;
}
if (reception == "AIG3-2"){
AIG3 = 2;
}
if (reception == "AIG4-1"){
AIG4 = 1;
}
if (reception == "AIG4-2"){
AIG4 = 2;
}
if (reception == "AIG5-1"){
AIG5 = 1;
}
if (reception == "AIG5-2"){
AIG5 = 2;
}
if (reception == "AIG6-1"){
AIG6 = 1;
}
if (reception == "AIG6-2"){
AIG6 = 2;
}
if (reception == "AIG7-1"){
AIG7 = 1;
}
if (reception == "AIG7-2"){
AIG7 = 2;
}
*/
//commande des moteur d' aiguillage
if (AIG1 == 1){ if (etat0 == 0){
for (int angle1 = +20; angle1 >= -20 ; --angle1){
pwmController.setChannelPWM(0, pwmAngleValue.pwmForAngle(angle1));// aig 1 Droite
delay(Attente);
}
}
etat0 = 1;
}
if (AIG1 == 2){ if (etat0 == 1){
for (int angle1 = -20; angle1 <= +20 ; ++angle1){
pwmController.setChannelPWM(0, pwmAngleValue.pwmForAngle(angle1));// aig 1 Dévier
delay(Attente);
}
}
etat0 = 0;
}
if (AIG2M1 == 1){if (etat1 == 0){
for (int angle1 = +20; angle1 >= -20 ; --angle1){
pwmController.setChannelPWM(1, pwmAngleValue.pwmForAngle(angle1));// aig 2 moteur 1 Droite
delay(Attente);
}
}
etat1 = 1;
}
if (AIG2M1 == 2){if (etat1 == 1){
for (int angle1 = -20; angle1 <= +20 ; ++angle1){
pwmController.setChannelPWM(1, pwmAngleValue.pwmForAngle(angle1));// aig 2 moteur 1 Dévier
delay(Attente);
}
}
etat1 = 0;
}
if (AIG2M2 == 1){ if(etat2 == 0){
for (int angle1 = +20; angle1 >= -20 ; --angle1){
pwmController.setChannelPWM(2, pwmAngleValue.pwmForAngle(angle1));// aig 2 moteur 2 Droite
delay(Attente);
}
}
etat2 = 1;
}
if (AIG2M2 == 2){if(etat2 == 1){
for (int angle1 = -20; angle1 <= +20 ; ++angle1){
pwmController.setChannelPWM(2, pwmAngleValue.pwmForAngle(angle1));// aig 2 moteur 2 Dévier
delay(Attente);
}
}
etat2 = 0;
}
if (AIG3 == 1){if (etat3 == 0){
for (int angle1 = +20; angle1 >= -20 ; --angle1){
pwmController.setChannelPWM(3, pwmAngleValue.pwmForAngle(angle1));// aig 1 Droite
delay(Attente);
}
}
etat3 = 1;
}
if (AIG3 == 2){if (etat3 == 1){
for (int angle1 = -20; angle1 <= +20 ; ++angle1){
pwmController.setChannelPWM(3, pwmAngleValue.pwmForAngle(angle1));// aig 1 Dévier
delay(Attente);
}
}
etat3 = 0;
}
if (AIG4 == 1){if (etat4 == 0){
for (int angle1 = +20; angle1 >= -20 ; --angle1){
pwmController.setChannelPWM(4, pwmAngleValue.pwmForAngle(angle1));// aig 1 Droite
delay(Attente);
}
}
etat4 = 1;
}
if (AIG4 == 2){if(etat4 == 1){
for (int angle1 = -20; angle1 <= +20 ; ++angle1){
pwmController.setChannelPWM(4, pwmAngleValue.pwmForAngle(angle1));// aig 1 Dévier
delay(Attente);
}
}
etat4 = 0;
}
if (AIG5 == 1){if(etat5 == 0){
for (int angle1 = +20; angle1 >= -20 ; --angle1){
pwmController.setChannelPWM(5, pwmAngleValue.pwmForAngle(angle1));// aig 1 Droite
delay(Attente);
}
}etat5 = 1;
}
if (AIG5 == 2){if(etat5 == 1){
for (int angle1 = -20; angle1 <= +20 ; ++angle1){
pwmController.setChannelPWM(5, pwmAngleValue.pwmForAngle(angle1));// aig 1 Dévier
delay(Attente);
}
etat5 = 0;
}
}
if (AIG6 == 1){ if(etat6 == 1){
for (int angle1 = +20; angle1 >= -20 ; --angle1){
pwmController.setChannelPWM(6, pwmAngleValue.pwmForAngle(angle1));// aig 1 Droite
delay(Attente);
}
etat6 = 0;
}
}
if (AIG6 == 2){ if(etat6 == 0){
for (int angle1 = -20; angle1 <= +20 ; ++angle1){
pwmController.setChannelPWM(6, pwmAngleValue.pwmForAngle(angle1));// aig 1 Dévier
delay(Attente);
}
}
etat6 = 1;
}
if (AIG7 == 1){if (etat7 == 0){
for (int angle1 = +20; angle1 >= -20 ; --angle1){
pwmController.setChannelPWM(7, pwmAngleValue.pwmForAngle(angle1));// aig 1 Droite
delay(Attente);
}
}
etat7 = 1;
}
if (AIG7 == 2){if (etat7 == 1){
for (int angle1 = -20; angle1 <= +20 ; ++angle1){
pwmController.setChannelPWM(7, pwmAngleValue.pwmForAngle(angle1));// aig 1 Dévier
delay(Attente);
}
}
etat7 = 0;
}
}
-
Hello,
/*while(true){
if (Serial.available()){
//reception = Serial.readStringUntil('\n');
//break;// Sortie de la boucle
}
}
*/
While(true) est une boucle sans fin !!!
Quoiqu'il arrive, ton programme tourne en boucle ici.
Il te faut quelque chose du genre :
while(Serial.available())
{
reception = Serial.readStringUntil('\n');
// pas besoin de break
}
Christophe
-
Salut Christophe,
merci pour ton aide,
j' ai corrigé, et effectivement sa débloque le programme, mais l' ordre donné reste effectif faut-il donné une fin à l' ordre reçu ?ou un vide mémoire ?une fois que l'ordre a terminé de s' exécuter?
-
bonjour,
après mes recherches infructueuse (j' ai pas du chercher au bon endroits ou avec les bon termes)lol
Je vais revoir tout mon programme.
Au lieu de recevoir des "ordres" des boutons poussoir et du bus série,
je vais créer une interface avec un Arduino uno qui lui recevra les "ordres" du TCO physique (bouton poussoir) et du TCO virtuel (processing/USB).
merci à tous
-
Frederic,
Si je peux me permettre un conseil, tu cherches à aller trop vite sans maîtriser les fondamentaux. On ne le répétera jamais assez, il faut commencer par la commencement et sur Locoduino, il est ici : https://www.locoduino.org/spip.php?id_mot=26&page=theme
Compte tenu de l'erreur que je t'ai corrigée, on voit bien il s'agissait d'un bout de code que tu as copié sur internet avec d'autres bouts de code. Résultat, ça ne fonctionne pas mais tu ne sais pas pourquoi.
Le programme que tu as présenté est tout bringbalant mais pourrait fonctionner sans trop de difficultés après quelques corrections.
Mais tu parles maintenant de te lancer avec Processing qui est beaucoup plus difficile à appréhender encore que la programmation Arduino où tout a été fait pour que ce soit très simple à utiliser. Libre à toi mais tu ne trouveras pas grand monde alors pour t'aider.
Bien cordialement.
Christophe
-
Mais tu parles maintenant de te lancer avec Processing qui est beaucoup plus difficile à appréhender encore que la programmation Arduino où tout a été fait pour que ce soit très simple à utiliser. Libre à toi mais tu ne trouveras pas grand monde alors pour t'aider.
Processing c'est comme Arduino, tout a été fait pour que ce soit simple à utiliser, mais pour un autre domaine, celui du dessin et de l'animation 2D et 3D.
Pierre
-
Mais tu parles maintenant de te lancer avec Processing qui est beaucoup plus difficile à appréhender encore que la programmation Arduino où tout a été fait pour que ce soit très simple à utiliser. Libre à toi mais tu ne trouveras pas grand monde alors pour t'aider.
Processing c'est comme Arduino, tout a été fait pour que ce soit simple à utiliser, mais pour un autre domaine, celui du dessin et de l'animation 2D et 3D.
Pierre
A la bonne heure Frédérique, puisque Processing est si simple tu as eu bien raison d'y penser... et j'ai bien eu tort de t'en dissuader.
Christophe
-
re a tous
oui se son des bouts de codes pris un peu partout, j' essaye de faire quelque chose et de comprendre avec se que je trouve sur internet le TCO fonctionne sans la communication, certainement qu' il y a mieux (plus pro) j' essaie aussi de pas harceler avec trop de question lol,
j' ai lu de super Articles ici sur TCO avec processing, ménage a trois, mais sa sera dans l' avenir .
Dans un premier temps je voulait avoir un TCO qui commande mes aiguillages par les boutons . (ça fonctionne avec des roues carré )lol
deuxième étape que je puisse avoir la possibilité par la suite de les piloter par l' ordi.
oui j' ai lu les articles pour débuter, je vais les relire sa fais pas de mal.
Mes connaissances son très limité.
Autour de moi, je connais personne pour m' aider.
en tout cas, je vous remercie pour toute l' aide que vous apporté.
si quelqu'un se trouve vers Castres et qui veut m' aider.
-
Je pense que actionner les aiguilles avec des boutons poussoirs est une première étape. En programmation, si le code est bien écrit au départ, il n'est en générale pas trop compliqué d'ajouter des fonctionnalités.
Combien y a t'il d'aiguilles ? Ce sont des servomoteurs de mémoire ?
Sur quelle carte ? Uno, Mega, Nano ?
Il y a déjà eu plein de choses sur le même sujet dans le forum et en article, fais des recherches !
Je ne suis pas certain que le PCA9685 se justifie, j'avais fait un programme pour 16 aiguilles avec mouvement lent des aiguilles sur un autre forum et ça marchait nickel. Je vais rechercher dans l'après-midi.
Mais fais vraiment des recherche sur le site éditorial et sur le forum avec "aiguillage" "servomoteurs" etc... Tu ne vas pas perdre ton temps de toutes façons
Christophe
-
Bon je n'ai pas eu à chercher longtemps. Le programme joint n'est pas encore celui auquel je pensais mais il va sans doute t'intéresser encore plus (pour le moment). Je reconnais que le programme est un peu compliqué mais il fonctionne. Tu pourras faire ce que tu voulais et puis, on pourra en discuter.
Ce programme répondait à la même demande que toi de piloter et régler les servos à partir de l'interface série de l'IDE Arduino
Ce programme permet de piloter 6 servos (mais 16 serait possible sur un Mega).
Pour le faire fonctionner, il faut dézipper et placer le dossier (avec les 3 fichiers) dans ton dossier Arduino.
Dans le fichier Servo_Aiguilles.ino, il faut tout d'abord choisir combien d'aiguilles on veut piloter. Ici on a mis 6 : #define NB_SERVO 6
Ensuite il faut indiquer sur quelles pins sont reliés les servos :
// Setup de chaque instance
// id, servoPin, togPinAig, ledPinAig, minPosition, maxPosition, (dirAig)
aiguille[0].setup(0, 2, 31, 40, position[0], position[1], 0);
aiguille[1].setup(1, 3, 33, 42, position[2], position[3], 0);
aiguille[2].setup(2, 4, 35, 44, position[4], position[5], 0);
aiguille[3].setup(3, 5, 37, 46, position[6], position[7], 0);
aiguille[4].setup(4, 6, 39, 48, position[8], position[9], 1);
aiguille[5].setup(5, 11, 41, 50, position[10], position[11], 0);
Par exemple :
aiguille[0].setup(0, 2
2 est le numéro de broche
aiguille[1].setup(1, 3
3 est le n° de broche
Si tu peux, garde le même brochage comme cela il n'y aura rien à modifier
Et il n'y a rien d'autre à modifier.
Maintenant comment ça marche ?
Quand le programme est lancé, il faut saisir des codes dans la barre du moniteur série de l'IDE Arduino :
- On commence par entrer le n° du servo que l'on veut régler (0, 1, 2...)
- va faire reculer le servo (très peu !), il faut donc appuyer plusieurs fois pour vraiment le voir bouger
+ va faire avancer le servo (très peu !)
s enregistre en EEPROM
w affiche à l'écran les réglages de tous les servos
Bon je n'ai pas beaucoup le temps là mais ensuite je te montrerai comment on fera pour actionner les différents servos à partir des réglages appliqués.
Et bien sûr ensuite avec des Boutons Poussoirs.
Christophe
-
super merci,
je l' ai téléchargé et ouvert
je regarde et essaie de comprendre le code
effectivement c'est à un autre niveau
-
salut Christophe,
D' abord merci pour ton aide c'est sympa,
quelque explication:
J' ai un ami avec très peu de moyen, je lui ai proposé de lui faire un TCO avec des servomoteurs pour sa petite gare, dans un premier temps la gare sera inclue dans un ovale double voie, le tout pour un budget de 50euro moi je prends rien (bénévolement),
pour la réalisation de ce TCO voici le matériels utilisé:
Un Arduino Mēga.
Un module RTC.
Un écran 4 lignes I2C.
Fils de câblages.
hors TCO,
Servomoteur MG90S 180° métal.
Rallonges 3 fils servomoteurs.
Une alimentation ATX d' ordinateur modifier 5V et 12 V (occasion),
pour limité le câblage, j' avais prévus une platine PCA9685 sur la quelle brancher les servomoteurs, se qui me permettais d' avoir comme câble entre le TCO et son réseau: 2 fils pour alim 5V,2 fils pour le BUS de la PCA9685, 2 fils pour le BUS entre Arduino, en tout 8 fils (câble informatique 1 paire doublé pour le 5V).
Par la suite (dans une galaxie lointaine), cet ovale recevra une gare caché et une gare principale ,le tout gérer par ordinateur.
Je me suis lancé dans se projet pour lui, parce que de mon coté j' ai le même projet, mais d' une voie unique beaucoup plus complexe tout se que je vais apprendre pour son projet servira au mien voilà le passé, présent et futur de se/ses projet.
-
@frederic,
je me suis amusé à dessiner mon réseau sur un écran 7" tactile résistif, avec des ordres graphiques simples de la bibliothèque UTFT. J'ai ajouté la commande des aiguilles en touchant simplement les aiguilles.
Le projet est connecté sur bus CAN et j'ai fait un simulateur simple qui montre la formation des itinéraires devant le train, avec position des aiguilles, puis les occupations des aiguilles et l'affichage du numéro de train dans la zone occupée.
C'est visible ici dans cette video.
https://vimeo.com/manage/videos/909176742 (https://vimeo.com/manage/videos/909176742)
C'est assez laborieux à écrire et à chercher les coordonnées de chaque objet graphique, mais une fois que c'est fait, c'est facile à mettre au point.
Si vous voulez en savoir plus, il suffit de me le demander.
-
Salut,
Quand je voie tout les super projets ici, je suis épatée j,e prends pleinement conscience de mon manque de connaissance,,
Et quand je pense au écran tactile grand format je pleure.
-
Au contraire il faut se réjouir d’avoir Locoduino ;D
Tout s’apprend à petit pas, au fur et à mesure des désirs que l’on a et en progressant étape par étape, en commençant par des exemples (ceux fournis avec les bibliothèques pour apprendre leurs instructions, puis les projets dans Locoduino qu’on déforme pour obtenir le résultat visé).
Il ne faut pas être trop ambitieux au départ mais chercher les bonnes techniques de base et travailler de façon modulaire.
-
Et quand je pense au écran tactile grand format je pleure.
Un écran tactile TFT avec tactile résistif 7”’coûte moins de 50€. Il est accompagné d’un contrôleur d’écran (SSD1963) supporté par un Arduino (mega, due, Teensy)
Un écran capacitif de taille équivalente en Oled couleur existe pour l’automobile à plusieurs centaines d’€, mais c’est sûrement l’avenir. Il faut attendre sans doute un peu pour trouver des bibliothèques pour Arduino qui supportent ces écrans.
-
je suis en train de repenser le projet,
ne serait il pas mieux de recommencer le projet depuis le début de commencé une nouvelle discutions en prennent en compte vos idées et en avançant étape par étape (je crois avoir compris "vouloir allez trop vite").
Si je prends les organes que je vais avoir besoin pour le projet:
1 ordi (bus USB).
1 Arduino pour chaque chose (1 pour servo moteur,1 pour TCO,1 pour communication entre ordi et exemple bus I2C,etc.
1 TCO physique.
1 TCO virtuel (moniteur série pour commencé).
1 bus pour relier tout les éléments.
qu'en pensez-vous?
Frédéric
-
Moi je pense que procéder ainsi est certainement mieux. Cette phase initiale ne semble peut-être pas la plus réjouissante (j'ai dit peut être) mais elle est nécessaire. C'est souvent beaucoup de temps mais beaucoup de gains par la suite et d'erreurs évitées.
En procédant ainsi, tu vas progressivement ébaucher les solutions, tes demandes d'aide seront plus claires et tu auras donc plus de réponses. Et puis, toujours tester avant de poser sur le réseau. On crois souvent que l'on vient de trouver "la solution miracle" mais patatras, rien ne fonctionne comme prévu.
L'approche modulaire dont parlais Dominique, c'est aussi pour moi des modules physique, hors du réseau ou des maquettes, tant que tout n'est pas exactement conforme et posé sur le réseau uniquement quand tout est OK.
Et enfin, dernier petit conseil, commencer toujours par ce qui ne se voit pas. Comme on apprend de ses erreurs, les parties les plus visibles du réseau, à l'avant seront parfaites (et pas l'inverse).
Christophe
-
je ne sais plus par quoi commencé le projet en entier ou la première étape du projet?
-
Mon projet vous donnera quelques idées, peut-être:
https://forum.locoduino.org/index.php?topic=290.msg16407#msg16407 (https://forum.locoduino.org/index.php?topic=290.msg16407#msg16407)
Pour arriver au TCO, il faut commencer par un dessin du réseau.
A partir de là on peut combiner différentes formes de TCO, pourvu qu'ils communiquent sur le bus CAN.
J'ai choisi la solution de la programmation en C/C++ d'un Arduino avec interface graphique (bibliothèque UTFT).
Mais j'ai aussi envisagé un Rasberry Pi avec Processing, mais il y a plusieurs inconvénients majeurs qui m'ont fait renoncer :
- pas de bus Can intégré sauf à ajouter une carte PICan2 à 50€, et installer des drivers dans Linux et programmer en python.
- Processing tourne en Java sous Linux donc c'est un environnement différent de l'Arduino
- et integrer la messagerie Can dans Processing n'est surement pas tout simple.
Mais le résultat est propre et sympa comme le démontre le projet Locoduinodrome (voir le I et le II est en cours de développement).
-
Pour un TCO graphique sur Arduino avec carte graphique et bibliothèque UTFT, ce n'est pas trop compliqué et l'affichage est sympa.
(https://forum.locoduino.org/index.php?action=dlattach;topic=1663.0;attach=5853;image)
Le dessin du TCO est une suite de traits horizontaux et verticaux comme ceci :
// barre horizontale long=+/-, vers droite s1 l>0 ou gauche si l<0
void drawbarreH(int x, int y, int l) {
myGLCD.fillRect(x, y - 2, x + l, y + 2);
}
// barre verticale long=+/-, vers droite s1 l>0 ou gauche si l<0
void drawbarreV(int x, int y, int l) {
myGLCD.fillRect(x - 2, y, x + 2, y + l);
}
Pour les courbes, y compris dans les aiguilles, on a ceci :
void GA0::tracer(int c) { // c est la couleur du tracé dans le sens passant de l'aiguille
if (etat) { //droit
myGLCD.setColor(K_ferme);
geo.drawArc(90, 358, 38, 0, 45, 5);
myGLCD.setColor(c);
drawbarreH(90, 320, 27);
} else { // devié
myGLCD.setColor(K_ferme);
drawbarreH(90, 320, 27);
myGLCD.setColor(c);
geo.drawArc(90, 358, 38, 0, 45, 5);
}
}
Toute la difficulté est donc de déterminer les valeurs numériques de chaque segment de droite ou de courbe, à partir d'un dessin coté, ce qui est un boulot ingrat mais la récompense est à l'arrivée, rien qu'avec du code Arduino.
Par contre pour le tactile c'est pas terrible, mais il existe des solutions de contournement
-
Dominique ,
C' est superbe et bien pensé, pour mon projet perso je ne dis pas non,
Pour le projet de mon ami trop compliqué et sa va me prends trop de temps, en parallèle de la gestion, je vais construire son réseau HO (pose des voies fabrication, des supports servomoteur, câblage).
Il est plus tout jeune lol .
Je voudrais dans un premier temps:
lui faire un ovale double voie avec une gare pour qui puissent faire rouler ses trains.
les inversions de courant seront gérer par des relais piloté par le TCO en fonction de l' itinéraire.
L'alim traction sera 2 potentiomètres combiné à 2 L298N un pour chaque ovale.
Le TCO virtuel aura les même fonctions que le physique.
Je vais revenir au plus simple parce que je voie tout se que j' ai encore à apprendre, une fois se pallier atteint j' envisagerais la suite.
j' ai déjà dessiner le TCO complet de son réseau en processing que je garde précieusement et en refaire un avec uniquement l' ovale avec la gare.
J' ai aussi mon réseau N 400m de voie, 100 aiguillages, 140 itinéraires, 5 gares (d'on 2 caché)qui lui fonctionne mais pas terminé, de plus il manque tout la voie unique (faux métrique en N) pour que je puissent faire de la déco,
Qui est géré par ordinateur.
mes vidéos:
https://www.youtube.com/@lendanstoutsesetats5016 (https://www.youtube.com/@lendanstoutsesetats5016)
Il faut que je soi réaliste les journées ne fond que 24 h.
Grace à vous tous, le Train miniature est en train de prendre une autre dimension, et les outils que vous arrivé à convertir pour cette magnifique passion son magistral.
-
voici le TCO virtuel du réseau HO pas encore finis pour plus tard!
-
re à tous,
Ayant résolut mon problème du départ :donné un ordre depuis l'ordi pour commuté un aiguillage.
Cette discutions pourra est fermé.
Merci à tous, pour tout ses infos et le partage de vos projets, sa laisse à réfléchir pour la suite.
Cordialement
Frédéric
-
On ne ferme pas les discussions qui peuvent intéresser d'autres lecteurs.
Bon départ !
-
Dominique
Je pars pas lol
Peut-être que mon projet peux servir
amicalement
Frederic
-
Je voulais dire « bon départ du projet qui a tout l’air d’être prometteur »