LOCODUINO
Parlons Arduino => Vos projets => Discussion démarrée par: CATPLUS le décembre 14, 2016, 10:09:03 am
-
Bonjour
Je voudrais faire le montage de Rudys (voir le sujet)
https://rudysmodelrailway.wordpress.com/2015/10/15/use-an-attiny-with-usb-as-a-dcc-function-decoder/
Je ne trouve pas le fichier *.ino pour la programmation.
Quelqu'un peut-il m'aider?
Cordialement
-
Bonjour,
sauf erreur, un ATTiny n'est pas un Arduino et faute d'un bootloader ne peut être programmé par l'IDE d'Arduino (mais je ne sais pas tout)
Question encombrement, l'Arduino pro mini n'est pas mal et là, on a les sketches.
A connecter au PC le temps de la programmation avec un adaptateur RS232 USB (FTDI ...)
A interfacer ensuite avec un opto 6N135 et alimenter par le DCC mais je crois qu'on en a parlé dans ces colonnes ...
Voir également la library :
https://github.com/MynaBay/DCC_Decoder
et les réalisations :
http://model-railroad-hobbyist.com/node/24316
http://model-railroad-hobbyist.com/node/20739
http://model-railroad-hobbyist.com/node/19446 -> schéma qu'on trouve reproduit de nombreuses fois
http://model-railroad-hobbyist.com/node/19775
-
Bonjour
Merci pour ta réponse. Je connaissais les posts que tu as sélectionné (il est toujours bon de faire un rappel)
J'ai réalisé ces montages
Il semble que ma question n'était pas conforme à mes attentes.
Je souhaite faire le montage précédent pour plusieurs raisons
1 Fonctionnement en dcc
2 le nombre de sorties est limité (pour faire fonctionner 1 led, ou un relais) et surtout petit encombrement
J'avais fait des petits modules genre compresseur de frigo avec des 555 et je souhaitai les faire démarer avec ce montage le coût est dérisoir par rapport à un décodeur.
3 programmation aisé par le biais d'un arduino
https://www.indiegogo.com/projects/attiny-isp-shield#/
http://www.semageek.com/tuto-programmation-des-attiny45-avec-un-arduino/
Ma préoccupation comment programmer le ATTiny en mode dcc
Merci
Cordialement
-
Merci d'avoir complété mon information !
Et probablement en intéressera plus d'un pour réaliser des minis décodeurs.
Sur cette page, https://rudysmodelrailway.wordpress.com/software/
en suivant le lien :
Arduino DCC, S88, and more Download link
on récupère un zip qui contient un sketch qui concerne un Attiny. Est ce pertinent ?
comment ajoute-t-on les Attiny à la liste des cartes Arduino dans l'IDE : il semble que c'est là via un des liens fournis :
https://codeload.github.com/damellis/attiny/zip/master
merci pour les liens pour la programmation (aisée ?)
-
Petite utilisation maison d'un ATTiny pour jeu de lumières... https://4.bp.blogspot.com/-2ImM1FXzQp4/V_lv_mAlbfI/AAAAAAAAA3Q/nWcVPA-YRnoM7rTvyBL_QKZjFj1red27ACLcB/s1600/premier%2Bpcb%2Bcomposants.jpg (https://4.bp.blogspot.com/-2ImM1FXzQp4/V_lv_mAlbfI/AAAAAAAAA3Q/nWcVPA-YRnoM7rTvyBL_QKZjFj1red27ACLcB/s1600/premier%2Bpcb%2Bcomposants.jpg) Certe, le résultat est quasiment aussi gros qu'un Arduino Mini, mais c'est fait maison ;)
Ma préoccupation comment programmer le ATTiny en mode dcc
Que veux-tu dire par: programmer le ATTiny en mode dcc ?
-
Bonjour
Quand tu regarde la vidéo et le titre parle de lui même
https://rudysmodelrailway.wordpress.com/2015/10/15/use-an-attiny-with-usb-as-a-dcc-function-decoder/
il programme le ATTiny avec un numéro DCC, je ne trouve pas le programme pour faire la même chose
IL y a un raccourcis https://app.box.com/s/nekqcwvfc3z11imc1ksxr6htroenxjrs
mais impossible de charger
Cordialement
-
Salut,
Ok je comprends ce que tu veux dire: tu veux donner une adresse au décodeur et non pas programmer les CV du décodeur en utilisant le bus DCC tel que tu pourrais le faire sur un réseau...
Quoiqu'il en soit, si tu n'arrives pas à télécharger les fichiers, tu peux trouver la librairie NMRA DCC à d'autres endroits, en particulier ici http://mrrwa.org/download/ (http://mrrwa.org/download/). Dans les exemples fournis avec la librairie tu trouveras un fichier DDC_Decoder.ino ou DCC_AccessoryDecoder.ino ou un nom équivalent. Je n'ai pas chargé le fichier ZIP pour vérifier, mais en général, toutes les versions sont à peu près faites de la même manière...
Ensuite, une fois la librairie installée, pour donner une adresse à ton décodeur, tu devrais trouver dans le programme d'exemple, une structure avec un champs DCC_Address ou équivalent. Il te suffit de renseigner ce champs avec l'adresse qui t'intéresse et de compiler le programme. Ca ne devrait pas être plus compliqué que cela...
Remarque: certaines librairies renseignent l'adresse du décodeur sur 2 octets différents plutôt qu'avec un seul entier/valeur. Il faut bien vérifier lequel des deux octets est celui de poids fort et celui de poids faible. Sinon, en inversant les deux valeurs, tu crées une adresse différente.
Si tu as encore des difficultés, je pourrai essayer de poster une réponse plus détaillée dans la soirée ou ce week-end.
Patrick
-
Bonjour
Merci
Tu as tout à fait compris ma requête, c'est exactement ce que cherchais (oui je souhaite donner une adresse DCC à l'ATTiny et en sortie lui attribuer une tache, led, relais, etc....)
Donc je vais suivre tes recommandations et je vous ferais part de mes tests.
Cordialement
-
Pour l'instant, cela dépasse mes compétences mais dans le lien de mon précédent message il y a le fichier zip correspondant au raccourci https://app.box.com/s/nekqcwvfc3z11imc1ksxr6htroenxjrs
Dans ce fichier Arduino_DCC_S88 inaccessible par le raccourci, il y a le sketch RB_DCC_Decoder_Function_ATtiny.ino ci-dessous
Est-ce que cela permet de programmer un Attiny ? Je vois que l'adresse DCC est en dur. Merci pour vos précisions.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DCC Function Decoder
// Author: Ruud Boer - October 2015
// This sketch turns an Arduino into a DCC function decoder for F0 - F12
// Output pins used: 3-19 (14-19 = A0-A5). Pin is HIGH when Function is ON.
// The DCC signal is fed to pin 2 (=Interrupt 0).
// Optocoupler schematics for conversion of DCC - 5V: www.rudysmodelrailway.wordpress.com/software
// Many thanks to www.mynabay.com for publishing their DCC monitor and -decoder code.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// IMPORTANT: GOTO lines 15 - 28 to configure some data!
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int decoderAddress = 1830; // This is the decoder address, change into the number you want.
#define F0_pin 1 // Define the output pin for every Function number in use
#define F0_pin2 3 // 2nd pin for same function is possible. Can use forward / reverse direction ... see line 97.
#define F1_pin 0 // Available pin numbers: 0,1,3,4,5
#define F2_pin 0
#define F3_pin 0
#define F4_pin 0
#define F5_pin 0
#define F6_pin 0
#define F7_pin 0
#define F8_pin 0
#define F9_pin 0
#define F10_pin 0
#define F11_pin 0
#define F12_pin 0
#include <DCC_Decoder.h>
#define kDCC_INTERRUPT 0
byte Func[4]; //0=L4321, 1=8765, 2=CBA9, 3=F20-F13, 4=F28-F21
byte instrByte1;
int Address;
byte forw_rev=1; //0=reverse, 1=forward
boolean RawPacket_Handler(byte pktByteCount, byte* dccPacket) {
Address=0;
if (!bitRead(dccPacket[0],7)) { //bit7=0 -> Loc Decoder Short Address
Address = dccPacket[0];
instrByte1 = dccPacket[1];
}
else if (bitRead(dccPacket[0],6)) { //bit7=1 AND bit6=1 -> Loc Decoder Long Address
Address = 256 * (dccPacket[0] & B00000111) + dccPacket[1];
instrByte1 = dccPacket[2];
}
if (Address==decoderAddress) {
byte instructionType = instrByte1>>5;
switch (instructionType) {
case 2: // Reverse speed
forw_rev=0;
break;
case 3: // Forward speed
forw_rev=1;
break;
case 4: // Loc Function L-4-3-2-1
Func[0]=instrByte1&B00011111;
break;
case 5: // Loc Function 8-7-6-5
if (bitRead(instrByte1,4)) {
Func[1]=instrByte1&B00001111;
}
else { // Loc Function 12-11-10-9
Func[2]=instrByte1&B00001111;
}
break;
}
// F0 is an example of two output pins that alternate based on loc forw_rev driving direction.
if (Func[0]&B00010000) {digitalWrite(F0_pin,forw_rev); digitalWrite(F0_pin2,!forw_rev);} else digitalWrite(F0_pin,HIGH);
if (Func[0]&B00000001) digitalWrite(F1_pin,LOW); else digitalWrite(F1_pin,HIGH);
if (Func[0]&B00000010) digitalWrite(F2_pin,LOW); else digitalWrite(F2_pin,HIGH);
if (Func[0]&B00000100) digitalWrite(F3_pin,LOW); else digitalWrite(F3_pin,HIGH);
if (Func[0]&B00001000) digitalWrite(F4_pin,LOW); else digitalWrite(F4_pin,HIGH);
if (Func[1]&B00000001) digitalWrite(F5_pin,LOW); else digitalWrite(F5_pin,HIGH);
if (Func[1]&B00000010) digitalWrite(F6_pin,LOW); else digitalWrite(F6_pin,HIGH);
if (Func[1]&B00000100) digitalWrite(F7_pin,LOW); else digitalWrite(F7_pin,HIGH);
if (Func[1]&B00001000) digitalWrite(F8_pin,LOW); else digitalWrite(F8_pin,HIGH);
if (Func[2]&B00000001) digitalWrite(F9_pin,LOW); else digitalWrite(F9_pin,HIGH);
if (Func[2]&B00000010) digitalWrite(F10_pin,LOW); else digitalWrite(F10_pin,HIGH);
if (Func[2]&B00000100) digitalWrite(F11_pin,LOW); else digitalWrite(F11_pin,HIGH);
if (Func[2]&B00001000) digitalWrite(F12_pin,LOW); else digitalWrite(F12_pin,HIGH);
}
}
void setup() {
DCC.SetRawPacketHandler(RawPacket_Handler);
DCC.SetupMonitor( kDCC_INTERRUPT );
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
}
void loop() {
DCC.loop();
}
-
En effet, il semble s'agir du programme recherché. Il est basé sur DCC_decoder.h/.c.
La fonction RawPacket_Handler() agit comme une callback dans laquelle on peut ajouter la fonctionnalité désirée. Le principe de callback garantit que la fonction sera appelée lorsque le bon paquet DCC sera reçu. Elle est instanciée avec:
DCC.SetRawPacketHandler(RawPacket_Handler);
Dans cet exemple, RawPacket_Handler() est appelé à chaque fois qu'un paquet générique (raw) est reçu (il peut s'agir d'un paquet décodeur de fonction ou décodeur de locomotive, etc...). Une des premières tâches est de décoder l'adresse du destinataire transportée par le paquet.
Address=0;
if (!bitRead(dccPacket[0],7)) { //bit7=0 -> Loc Decoder Short Address
Address = dccPacket[0];
instrByte1 = dccPacket[1];
}
else if (bitRead(dccPacket[0],6)) { //bit7=1 AND bit6=1 -> Loc Decoder Long Address
Address = 256 * (dccPacket[0] & B00000111) + dccPacket[1];
instrByte1 = dccPacket[2];
}
Ensuite, le code va vérifier que l'adresse reçue correspond à l'adresse du décodeur. Dans le cas contraire, le paquet est ignoré. De plus, libre à chacun d'utiliser l'adresse qu'il veut ici...
int decoderAddress = 1830; // This is the decoder address, change into the number you want.
(...)
if (Address==decoderAddress)...
Si c'est le cas, alors le paquet "est arrivé au bon endroit". Il ne reste plus qu'à décoder le numéro de fonction et son contenu, et d'exécuter l'action désirée (digitalWrite()... etc...).
J'espère que cela clarifie le problème...
-
Merci pour la réponse. Je l'ai comprise mais je ne veux pas en poser d'autres car avant je dois lire les articles auxquels le sujet se réfère et dans lesquels je trouverai certainement au moins les réponses de base. (et voir ce que fait le DCC_decoder.h etc.)
Mon intérêt est de placer un mini décodeur embarqué dans la voiture de queue d'une rame nouvellement digitalisée pour allumer feux rouges et blancs (soit parallèlement à l'adresse de la locomotive avec gestion du sens, soit indépendamment). Pour cela, je n'ai besoin que de deux sorties.
-
C'est un beau petit projet pour commencer avec les décodeurs embarqués.
Ceci-dit, si tu veux utiliser ton décodeur comme un décodeur de fonctions (par exemple dans la motrice de queue d'un TGV), tu devrais plutôt prendre un peu de temps pour examiner la librairie NMRA. Je pense qu'elle est plus adaptée pour ce cas-là. En effet, il y a déjà un exemple de décodeur loco (ou fonctions) ici: https://github.com/mrrwa/NmraDcc/blob/master/examples/NmraDccMultiFunctionDecoder_1/NmraDccMultiFunctionDecoder_1.ino (https://github.com/mrrwa/NmraDcc/blob/master/examples/NmraDccMultiFunctionDecoder_1/NmraDccMultiFunctionDecoder_1.ino)
La librairie est disponible au complet ici: https://github.com/mrrwa/NmraDcc (https://github.com/mrrwa/NmraDcc)
Quoiqu'il en soit, tu devrais obtenir à peu près les mêmes résultats avec ton approche...
Tiens-nous au courant...
Patrick
-
Bonjour
Merci à Patrick et msport
Après avoir lu et relu, testé, chargé un tas de programmes pour les essais la première phase fonctionne
Mis le programme dans le NANO (voir pièce jointe)
Tester sur le banc d'essai avec le 6N137 et ma central ZIMO, fonctionnement correct, juste un soucis sur les 9 Leds qui doivent fonctionner la sortie 7 ne donne rien (à suivre)
La prochaine phase adapter le programme pour le ATTiny
Cordialement
-
Tiens-nous au courant...
un grand merci pour le lien. J'y étais déjà allé mais bien rangé dans mes favoris, je ne l'avais pas exploité.
et merci d'un rappel au raisonnable déjà validé. Pour l'ATTiny, je crois que je me laisse aller à trop de curiosité et d'enthousiasme ... Je vais déjà tenter le décodeur sur base d'un arduino Mini *, pour l'ATTiny ce sera plus tard, d'autant que sauf erreur, une fois programmé, si il y a une erreur, c'est fini.
Mais je lirai avec plaisir tous les développements ! Merci CATPLUS.
* En fait, pour l'encombrement, les composants autour prennent beaucoup de place. j'attends des CMS dont le prix est en rapport avec la taille.
-
un grand merci pour le lien.
Avec plaisir...
d'autant que sauf erreur, une fois programmé, si il y a une erreur, c'est fini.
??? Que veux-tu dire?
-
Bonjour
Je me suis fait un programme de nettoyage pour tout type d'Arduino
Sauf erreur de ma part, l'ATTiny peut être le programmé autant de fois que tu veux.
https://www.youtube.com/watch?v=D33NieHwyHw
https://www.youtube.com/watch?v=kq4VsR8gHtc
Pour le Ho et le Zéro la taille des composants devraient aller. Peut être beaucoup plus difficile pour le N
Utiliser des produites CMS sont bien mieux
Cordialement
-
Bonjour à tous,
Grâce à Dominique, je viens de prendre connaissance de ce forum ; cela tombe bien car j'ai proposé à la publication des articles sur la programmation de l'ATtiny et je peux peut-être apporter une modeste contribution, en étant désolé pour le retard.
Bonjour,
sauf erreur, un ATTiny n'est pas un Arduino et faute d'un bootloader ne peut être programmé par l'IDE d'Arduino (mais je ne sais pas tout)
Je vais donc commencer par de bonnes nouvelles : l'ATtiny ressemble fortement à Arduino ! C'est ce que je développe dans mes articles. En quoi ? Simplement parce que sa structure interne se rapproche fortement de la structure interne du µC ATmega328P des modules Arduino Uno.
Autre bonne nouvelle : l'ATtiny se programme grâce à un module Arduino Uno et une platine d'essai (breadboard). Simplicité garantie d'autant que la version 1.6.13 de l'IDE prend tout en charge. Et de nombreuses fonctions sont traductibles en langage machine de l'ATtiny !
Après ces deux bonnes nouvelles, je vais regarder plus en détail le contenu de ce fil pour voir si je peux y apporter quelque chose de plus.
Bien cordialement.
Christian
-
Je viens de parcourir ce fil. Je dois reconnaître que, ne pratiquant pas le DCC, je ne suis pas un spécialiste dans ce qui est le sujet de vos préoccupations, un décodeur basé sur un ATtiny, mais je pense qu'un décodeur de fonctions doit être faisable et peut-être aussi un décodeur tout court puisque l'ATtiny fait de la PWM mais il faut aussi l'électronique capable de passer du courant alternatif de la voie à cette PWM pour entrainer le moteur.
Je pense que vous vous êtes lancé un beau défit et c'est ce qui vous fera progresser, peut-être simplement en commençant par le décodeur de fonction, puis, pourquoi pas, le décodeur tout court.
Quant à la reprogrammation de l'ATtiny, la mémoire flash peut être programmée et reprogrammée jusqu'à 10 000 cycles d'écriture-effacement (données constructeur) : vous vous lasserez avant ! ;)
Je vais surveiller ce fil et j'interviendrai si je peux vous apporter une quelconque aide.
-
Petit commentaire concernant les deux vidéos du dessus :
- Celle du haut montre qu'il existe de petits shields permettant de programmer toute la gamme des ATtiny (24/44/84 et 25/45/85), mais vous pouvez aussi réaliser vous-même ce shield, ou bien vous en passer et utiliser une simple platine d'essai (breadboard).
- Celle du bas est hélas obsolète puisque basée sur la version 1.0.6 de l'IDE. Or depuis les versions plus récentes (et l'actuelle 1.6.13), il n'y a plus besoin d'importer la bibliothèque ATtiny, car celle-ci est fournie dans l'IDE, pour toute la gamme (donc, pas besoin de réfléchir où placer cette bibliothèque). De plus, la compilation d'un programme pour ATtiny ne génère plus de message d'erreur (ce qu'on voit en orange sur fond noir dans la vidéo). Systématiquement, je conseille de graver la séquence d'initialisation à la première programmation de la puce, pour justement éviter un programme qui fonctionnerait mais pas à la bonne fréquence, comme on le voit dans la vidéo.
Cette vidéo dure 10 min car il fallait bien prendre la peine d'expliquer, mais franchement avec un peu d'habitude, cette programmation se fait en moins de deux minutes. ;)
-
J'ai certainement mal interprété mais on parle de "fuse" pour les ATTiny (?)
Je viens de télécharger l'IDE 1.6.13 je n'ai pas les ATTiny (et d'ailleurs pas non plus Wire, ce qui m'étonne) Qu'ai je oublié ?
Dans la video du bas, il est effectivement indiqué de télécharger les drivers dans "hardware"; ça aurait du être automatique avec le 1.6.13 que j'ai. Fâché avec W7 ?
Enfin il est clair qu'on peut les reprogrammer.
-
Pour ma part, ma version 1.6.13 a été téléchargée sous forme d'un fichier ZIP (nous sommes plusieurs à Locoduino à préférer cette solution "transportable").
Une fois dézipé, le fichier contient tout ce qui est nécessaire.
Les ATtiny se trouvent dans Outils > Type de cartes et tout en bas. Il y a d'abord ATtiny25/45/85 (ceux à 8 broches) et au-dessous ATtiny24/44/84 (ceux à 14 broches).
-
Bonjour
Apparemment ce sujet intéresse
Pour ma part, si je reprends le début de mon post, je souhaitais faire un décodeur avec une adresse simple (pas de décodeur pour machine)
Quoi qu'il en soit les réponses apportées sont au delà de mes espérances et l'en suis ravi.
J'attends avec impatience la suite (montage, etc....)
J'attends mes ATtiny 85, à suivre
Cordialement
-
Je suis content de voir qu'une petite communauté s'intéresse aux ATtiny.
Je les utilise depuis plus d'un an pour de petits montages autonomes trouvant leur place sur un réseau, et franchement, j'en suis content (économique et facile à programmer, rien à voir avec le PIC16F84 que j'ai aussi pratiqué).
De plus, la mise au point de leur programme peut se faire à partir d'un module Arduino, alors c'est vraiment très simple.
Pour ton décodeur d'accessoire, as-tu lu les écrits de Thierry (décodeur d'accessoires universel) et serait-ce possible d'adapter à un ATtiny ? (je n'y connais pas grand chose en DCC, donc ce que je viens de dire est peut-être une ânerie...)
En tout cas, puisque le titre de ce post est Utilisation d'ATtiny, on aura peut-être d'autres locoduineurs qui rejoindront le mouvement et plus on est de fous, plus on progresse vite...
-
Pour ma part, ma version 1.6.13 a été téléchargée sous forme d'un fichier ZIP ...
Merci pour cette précision car j'ai chargé l'exe de 84.5 Mo pour Windows et en regardant son contenu avec 7z, il n'y a pas les ATTiny, ni Wire ...
Et je suivrais moi aussi ce fil avec beaucoup d’intérêt, j'ai commandé quelques ATTiny13.
-
Bon, j'ai eu du mal ...
j'ai installé en dézippant la version zip (de 150Mo, c'est donc qu'il y en a plus que dans l'exe de 85 Mo) mais toujours rien dans la liste des cartes. Et pourtant il y a les ATTiny dans le hardware. Il y a peut-être lieu de les installer, mais comment ? je n'avais rien dans le gestionnaire de carte ?
Mais pas battu pour autant, une recherche sur google
On poursuit la recherche et on tombe sur :
https://forum.arduino.cc/index.php?topic=150870.0
avec un mode d'emploi et un lien :
http://code.google.com/p/arduino-tiny/
qui conduit à différentes archives dont la plus récente :
https://storage.googleapis.com/google-code-archive-downloads/v2/code.google.com/arduino-tiny/arduino-tiny-0150-0020.zip
Mais il est dit qu'il faut mettre dans le répertoire de ses sketches un répertoire hardware avec un fichier fourni. Pas de chance c'est déjà périmé : l'IDE signale qu'il manque un fichier boards.txt.
Enfin, un autre lien, un qui marche :
http://highlowtech.org/?p=1695
dit comment ajouter un lien dans l'IDE via Préférences URL de cartes supplémentaires et propose :
https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json
Ensuite via Outils / Type de Carte / Gestionnaire de carte / More info, choix d'une version on fait Installer et enfin les ATTiny figurent dans la liste.
Mais dites moi, vous avez fait tout ça ? ou c'est moi qui n'ai pas su faire simple ?
-
Si cela peut te rassurer, la procédure afin d'ajouter des définitions de hardware est bien celle-là (utilisation du gestionnaire...). J'ai installé plusieurs hardwares différents et c'est toujours la même chose...
Bon, en tout cas, ça fonctionne 😉
-
Bon, j'ai eu du mal ...
j'ai installé en dézippant la version zip (de 150Mo, c'est donc qu'il y en a plus que dans l'exe de 85 Mo) mais toujours rien dans la liste des cartes. Et pourtant il y a les ATTiny dans le hardware. Il y a peut-être lieu de les installer, mais comment ? je n'avais rien dans le gestionnaire de carte ?
.........
dit comment ajouter un lien dans l'IDE via Préférences URL de cartes supplémentaires et propose :
https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json
Ensuite via Outils / Type de Carte / Gestionnaire de carte / More info, choix d'une version on fait Installer et enfin les ATTiny figurent dans la liste.
Mais dites moi, vous avez fait tout ça ? ou c'est moi qui n'ai pas su faire simple ?
Cela fait quelques temps que j'utilise les versions ZIP (au moins trois versions différentes) et j'ai toujours eu la surprise de voir les cartes ATtiny.
Mais vu ce qu'il t'arrive, je commence à me poser des questions.
En effet, il a fallu un jour que j'importe les bibliothèques ATtiny, mais c'était il y a pas mal de temps, avec une version installée.
Serait-il possible que la version bundle (dans le répertoire) retrouve ce que j'avais installé il y a longtemps, je me le demande.
J'ai donc fait un essai, retirer le répertoire ATtiny de la version installée --> j'ai observé que cette version ne peut donc plus proposer les cartes ATtiny, par contre les versions 1.6.12 et 1.6.13 (origine ZIP) les ont toujours.
Je remets le répertoire ATtiny dans le répertoire Hardware de la version installée --> celle-ci retrouve les cartes ATtiny.
Pour en avoir le cœur net, il faudrait que j'installe une version ZIP sur un ordinateur qui n'a jamais reçu Arduino (celui de mon fils quand il rentrera de vacances).
Ensuite, je vous tiendrai au courant (cela veut dire qu'il faudra peut-être que je rajoute un paragraphe sur mon article ATtiny N°2, car j'étais persuadé que cette version proposait les cartes sans aucune intervention).
Ce que tu as décrit servira peut-être à d'autres, quant à moi, je vais vérifier si oui ou non, elles sont présentes sur la version 1.6.13.
-
Ce que tu as décrit servira peut-être à d'autres, quant à moi, je vais vérifier si oui ou non, elles sont présentes sur la version 1.6.13.
J'ai installé récemment cette version (sur Linux) et il m'a fallu installer la librairie à la main. Ceci sur un ordi "propre". Donc, pas de ATTiny dans l'installateur.
J'ai l'impression que dans le cas Windows, les libraries sont installées dans un répertoire Documents/Arduino. Ainsi, ce répertoire est persistent quelque soit la version ou les versions de l'IDE qui sont installées ou désinstallées.
A une certaine époque, l'IDE créait un répertoire Arduino1.0, puis Arduino1.1, etc... dépendant de la version de celui-ci. Or depuis quelques versions je pense que le nom du répertoire est le même (ne contient plus de version) d'où la réutilisation des librairies...
Hmmm... J'espère que ce n'est pas trop du charabia...
Patrick
-
Merci de me rassurer, je craignais d'être le seul à ne pas être doté des super pouvoirs !
Mais ça reste mystérieux :
apparemment d'origine avec la version zip j'avais des fichiers (tous ?) nommés ATTiny dans :
C:\Program Files (x86)\Arduino\hardware\tools\avr\lib\gcc\avr\4.9.2\device-specs
comme specs-attiny13
par contre, je ne voyais pas comment les mettre dans la liste des cartes ... (et actuellement je n'ai pas d'attiny13 dans ma liste, seulement séries 24 et 25)
Avec l'installation "automatique" permise par le lien dans préférence, il n'y a rien de plus (ATTiny*) dans Mes documents/Arduino (les sketches)
Donc réinstallation probable lors du prochain changement de version d'IDE, sauf si vous me dites que vous n'avez pas eu de problème à fusionner le nouveau zip avec l'ancien répertoire.
mais l'enquête se poursuit ...
-
Pour complément d'infos:
Si jamais vous n'avez pas les cartes ATTiny listées dans le gestionnaire de cartes, il faut ajouter la bibliothèque comme ceci:
Arduino IDE: dans Fichier, Préférences, URL de gestionnaire de cartes supplémentaires.
Ajouter cet url : https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json
Puis revenir dans le gestionnaire de cartes, les cartes Attiny devrait apparaitre et pourront être téléchargé et installé.
D’autres bibliothèques listées ici :
http://playground.arduino.cc/Main/ArduinoOnOtherAtmelChips
Bonnes fêtes de fin d’année :)
-
Bravo,
Je viens d'installer l'ATtiny dans l'IDE 1.8.0 sur OSX et je vois bien les ATtiny
merci pour ce bon tuyau
-
Je confirme que ça marche aussi sous Windows 10, IDE 1.6.9.
La subtilité, c'est que quand on est dans le gestionnaire de cartes, on a le choix (en haut à gauche) "possible mettre à jour" qui ne fait pas apparaître les ATTiny.
En effet, il ne s'agit pas d'une mise à jour, mais d'une installation.
Il faut donc choisir "tout" et aller tout en bas où, cette fois, apparaissent bien les ATTiny de Michael Damellis.
On les installe et on les a bien en choix dans le gestionnaire de cartes.
Merci à tous.
-
J'ai l'impression que c'est encore plus subtil que ça ...
Je pense que la liste de base dans le gestionnaire de cartes est celle téléchargée à partir de http://downloads.arduino.cc/packages/package_index.json
Si windows est de mauvaise humeur (on ne lui a pas permis de faire n'importe quoi depuis le web), il ne télécharge rien ou rien de plus.
Pour en avoir plus, il faut mettre dans préférence une adresse comme :
https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json pour les ATTiny de MICHAEL Damellis.
Ensuite on peut demander la mise à jour du package en cliquant More info dans la fenêtre concernée via le gestionnaire de cartes (avec Type "Tout").
-
Toute l’équipe de www.locoduino.org vous présente ses meilleurs vœux pour l’année 2017 et vous souhaite de nombreux projets dans le cadre du modélisme ferroviaire.
Pour nous, les projets ne manquent pas et nous sommes heureux de commencer cette nouvelle année en ouvrant dans nos colonnes une nouvelle rubrique concernant la programmation des microcontrôleurs ATtiny.
Voici le premier d’une longue série d’articles :
http://locoduino.org/spip.php?article188
En espérant que cette rubrique vous plaira. :)
-
Merci et également une excellente année 2017 à tous !
Tout ce qu'on avait envie de savoir sans oser le demander : très bien ce début d'une série d’articles. On a vraiment envie d'en savoir plus.
Une question : et l'ATtiny 13, où se place t il dans la gamme ?
-
Je viens de parcourir la datasheet de l'ATtiny13 et je ne suis pas perdu car je retrouve des caractéristiques similaires à l'ATtiny45 :
- 8 broches multiplexées
- même tension d'alimentation
- même fréquence horloge sous 5 V
- 1 seul timer au lieu de 2 (mais 2 canaux PWM)
- un ADC sur 10 bits
- 6 E/S mais en fait seulement 5 car une sert de RESET
- mémoire deux fois moindre que l'ATtiny25 (1 k flash programme, 64 SRAM, 64 EEPROM)
L'IDE d'Arduino ne contient pas les définitions pour l'ATtiny13, ce qui veut dire qu'il faut les créer et cela demande de bien connaître le composant. Vu la taille de sa mémoire, il est réservé à de très petites applications. Son prix 0,83 euros pièce alors que l'ATtiny45 (4 fois plus de mémoire) vaut 1,03 euros pièce chez un fournisseur.
A moins d'avoir un stock, je ne conseille pas de prendre ce µC. Ceux qui en ont peuvent toujours essayer de les programmer avec les définitions de l'ATtiny25 mais je ne garantis pas le résultat (cela peut marcher quand même mais je n'ai pas essayé). Ceux qui réussiront pourront toujours partager leur expérience sur ce forum.
-
Tout ce qu'on avait envie de savoir sans oser le demander : très bien ce début d'une série d’articles. On a vraiment envie d'en savoir plus.
Dans un premier temps, nous comptons publier un article tous les quinze jours (à peu près) pour laisser le temps aux lecteurs pour s'équiper et surtout pour bien assimiler les notions. Il y a déjà 4 articles préparés ; cela nous reporte donc mi février. Ensuite, nous verrons comment cette série d'articles sera perçue par la population. N'hésitez donc pas à faire connaître vos attentes dans ce domaine, et n'hésitez pas non plus à pratiquer (l'investissement n'est pas très élevé pour découvrir ce petit circuit intégré).
Les articles proposés sont des articles pratiques, proposant des réalisations simples pour un réseau de train miniature ; c'est à la portée de tout le monde puisque schéma de câblage et programme sont donnés. Et en plus, il y a ce forum en complément pour aider ceux qui auraient des difficultés.
Plus aucune excuse pour ne pas s'y mettre... ;)
-
A moins d'avoir un stock ...
commandés quand un fil a démarré sur le sujet :
reçus 10 en CMS à 0,27€ pièce
et 5 en DIL à 0,52€ pièce. (mais le but n'était pas de faire des économies !)
Promis, je testerai.
-
Et bien voilà, j'ai le plaisir de t'apprendre que tu es désormais le responsable en chef des tests sur l'ATtiny13 ! :)
Si tu arrives à le programmer comme l'ATtiny25/45/85, ce dont je ne doute pas, tu vas découvrir toutes les possibilités qui s'offrent à toi.
Donc, tiens nous au courant.
Et le vrai challenge sera sans doute d'économiser les mémoires avec un code irréprochable, un peu comme au début de l'informatique. Ce défit aussi reste intéressant.
Alors ne regrette pas d'avoir acheter celui-ci plutôt que celui-là, tu as sous la main de quoi t'amuser un bon bout de temps avant d'arriver au bout de la bête.
-
A toutes fins utiles, on trouve chez TXHANG (voir l’article sur Les Achats) un kit de développement ATtiny85 pour 1,26€.
Ce kit contient un prise microUSB et il est compatible avec l’IDE Arduino sans matériel supplémentaire.
http://www.ebay.fr/itm/Mini-ATTINY85-Micro-USB-Development-Board-for-Digispark-Kickstarter-/400911402692?hash=item5d582e86c4 (http://www.ebay.fr/itm/Mini-ATTINY85-Micro-USB-Development-Board-for-Digispark-Kickstarter-/400911402692?hash=item5d582e86c4)
Du coup j'en ai commandé 5 pour voir (je ne sais plus combien de dizaines d'Arduino j'ai dans mes tiroirs, et maintenant des ATtiny en plus :P :P :P)
-
J'ai déjà utilisé ces attiny85 digispark. Très bien pour des petits projets basse consommation :)
Bien suivre à partir de l'étape 3 de ce tuto:
http://www.instructables.com/id/Digispark-DIY-The-smallest-USB-Arduino/?ALLSTEPS
Pour les utiliser.
En effet ils utilisent un bootloader spécial (déjà gravé) pour être utilisable sur USB. Donc il faut le driver et un IDE avec la plateforme reconnue.
-
Nous avons le plaisir de vous présenter le deuxième article sur les µC ATtiny :
Le microcontrôleur ATtiny45 (2) (http://locoduino.org/spip.php?article189)
Cet article revient sur la méthode de programmation de ces puces.
La suite d'ici une quinzaine de jours pour commencer les premières réalisations (ce qui vous laisse le temps de vous procurer le matériel et vous entraîner comme indiqué dans l'article). ;)
-
Bonjour,
et merci pour ce deuxième article.
j'ai voulu tester, j'avais déjà installé Damelis mais entretemps je suis passé à l'IDE 1.8.
Manifestement Windows 10 ne supporte pas qu'on installe un programme en le dézippant dans Program Files (il lui refuse l'accès internet sans rien dire)
Je l'ai mis sur le bureau, W10 a fini par demander si le parefeu pouvait le laisser passer et j'ai pu faire l'installation de Damelis.
Conclusion, on attendra demain pour voir la LED qui marche, marche pas, marche, etc. (avec un ATtiny 13)
PS : peut-être rappeler où est la pin1 sur le schéma.
-
Bonsoir,
le responsable en chef des tests sur l'ATtiny13 vous communique :
essai réussi ! la LED clignote (enfin si on peut dire qu'un cycle allumage extinction de 20s est un clignotement, alors que sur le sketch il y a 1s/1s)
L'IDE m'a dénoncé : il a vu que ce n'était pas un ATTiny 25 qui était monté et a refusé de télé-déverser.
D'où recherche sur Internet :
https://sourceforge.net/projects/ard-core13/?source=typ_redirect et à télécharger :
http://sourceforge.net/projects/ard-core13/files/latest/download
Installation du core ITTiny13 dans \hardware du répertoire des sketches , redémarrage de l'Arduino et c'était bon.
Mon problème d'horloge vient certainement de ce que j'ai télé-déverser le bootloader pour ATTiny, horloge à 8Mhz et télédéverser pour un ATTtiny à 9,6MHz.
J'ai tenté de recharger le bootloader, avec l'ATTiny 13
Arduino : 1.8.1 (Windows 10), Carte : "Attiny 13A standalone 9.6Mhz"
mais j'ai eu le message d'erreur :
Erreur lors de la gravure de la séquence d'initialisation : le paramètre de configuration « bootloader.tool » est manquant
Nota, j'ai alimenté mon ATTiny en 3V comme vu par ailleurs.
PS : sur la photo jointe, en marge : comment s'utilise ce "Development programmer" qui se connecte bien en USB mais n'est pas reconnu par W10.
Il ressemble à celui de Dominique (voir un peu plus haut) mais est vendu pour les ATTiny 13 (aussi).
-
Bonsoir,
pour aujourd'hui une réponse et une question :
1 en programmant avec pour cible l' ATTiny (13) standalone 1,2 MHz, le clignotement passe bien à ~ 1/1 s.
2. dans les messages détaillés de compilation j'ai :
Fichier du bootloader spécifié mais absent: C:\Users\Michel\Documents\Arduino\hardware\attiny13\avr\bootloaders\empty
effectivement il n'y a pas de répertoire bootloaders dans ...\avr\
je poursuis la chasse au bootloader pour ATTiny ...
-
Bonsoir,
pour aujourd'hui une réponse et une question :
1 en programmant avec pour cible l' ATTiny (13) standalone 1,2 MHz, le clignotement passe bien à ~ 1/1 s.
2. dans les messages détaillés de compilation j'ai :
Fichier du bootloader spécifié mais absent: C:\Users\Michel\Documents\Arduino\hardware\attiny13\avr\bootloaders\empty
effectivement il n'y a pas de répertoire bootloaders dans ...\avr\
je poursuis la chasse au bootloader pour ATTiny ...
Bonjour Michel,
Tout d'abord, félicitations pour ces succès ; je vois que j'ai bien fait de te désigner volontaire pour être responsable des projets ATtiny13. :)
Tu peux arrêter ta chasse au bootloader d'ATtiny car pour moi, cela n'existe pas. Le bootloader est une invention Arduino qui aide à la programmation des modules du même nom. Ici, nous travaillons non plus avec de l'Arduino (sauf celui qu'on utilise comme programmateur) mais avec un µC de chez Atmel. Quand on grave la séquence d'initialisation, ce n'est pas un bootloader que l'on grave mais simplement quelques variables qui servent au microcontrôleur pour savoir dans quel mode il doit travailler. En tout cas, je l'ai compris comme cela car j'avais la même chose, une quinzaine d'années plus tôt, avec le µC PIC 16F84.
Par mode de travail, j'entends quelle horloge choisir (interne, externe) et quelle fréquence (voir les choix proposés par l'IDE). C'est pour cela que la programmation de cette séquence d'initialisation n'est à faire qu'une seule fois (lors de la première programmation) ou bien si on change de mode de travail (horloge, fréquence, ...). Et ceci explique aussi que si la séquence de travail n'est pas celle qui convient, le programme fonctionne (ou pas) avec un rythme qui n'est pas le bon (20 s au lieu d'une seconde). Ceci n'est pas grave, cela m'est arrivé avec un ATtiny45 car j'avais oublié de graver cette séquence ; j'ai donc recommencé et ensuite nickel !
Même si l'ATtiny13 n'est pas un composant d'avenir, ton travail sera très utile à la communauté ; en tout cas, il démontre qu'avec un peu de persévérance et de recherches sur internet, on peut résoudre les problèmes. C'est ce que tu as fait, alors bravo. ;)
-
Bonsoir Chris,
je suis comblé par tant de compliments !
mais je dois reconnaitre quelques lacunes : j'ai confondu bootloader et séquence initialisation ... et ai imaginé qu'un bootloader était indispensable pour que l'ATTiny accepte de démarrer.
A priori les timings de l'ATTiny 13 sont très approximatifs et je crains qu'en tant que décodeur d'accessoires il ait du mal à reconnaitre les séquences de bits qu'on lui envoie.
Donc pour trouver une utilisation à mon circuit, je lui ai confié un chenillard à 5 LED, (doublées) suivant photo et programme joint.
Ai-je bien compris que si on utilise la broche 1 (reset) le circuit ne peut plus être reprogrammé ?
-
Ai-je bien compris que si on utilise la broche 1 (reset) le circuit ne peut plus être reprogrammé ?
Pour utiliser la broche RESET en tant que broche I/O, il faut lui défaire sa fonction de RESET et ceci n'est possible qu'en programmant un registre fusible appelé RSTDISBL. Or une fois que c'est fait, on ne peut plus programmer le µC avec notre programmateur de fortune Arduino as ISP. Néanmoins, d'après la doc ATMEL, il peut être reprogrammé à nouveau mais avec un programmateur série "Haut voltage" (en fait 12 V). Ceci se trouve en page 103 de la datasheet :
"When programming the RSTDISBL fuse, High-voltage Serial programming has to be used to change fuses to perform further programming."
Voilà pourquoi, pour une utilisation simple de ce genre de µC, je conseille de ne pas utiliser la broche 1 autrement que pour du RESET, sauf si on ne peut pas faire autrement, auquel cas, il faut bien étudier comment programmer le fuse RSTDISBL.
Pour ce qui concerne la fréquence de travail, en étudiant un peu la datasheet, tu dois pouvoir trouver comment améliorer la fiabilité ; pour ma part, cela fonctionne déjà assez bien quand je programme l'ATtiny45 avec l'horloge interne de 8 MHz. Bien entendu, une horloge interne ne sera jamais aussi précise qu'un quartz externe, mais qui consomme des broches (voir le module Arduino Uno par exemple).
Bravo pour ton chenillard, c'est déjà un premier résultat et tu verras que tu trouveras une utilité à ton stock d'ATtiny13 (avec 5 sorties, on fait déjà plein de jeux de lumières comme tu le verras dans les prochains articles sur l'ATtiny). Et pour une application plus sophistiquée, tu peux toujours commander des ATtiny84 (plus de mémoire et plus de sorties).
-
Merci pour ces précisions.
J'ai commandé quelques 45 et 85. Mon objectif étant de commander une LED rouge et une LED blanche, 5 pins devraient suffire ...
A suivre.
-
Bonjour
Suite à ma première question sur l'ATTiny et voir tous ces posts, je suis admiratif "Merci à tous"
Bien, je ne sais pas qui a dit que la persévérance ça paye, il avait raison.
Après avoir lu et relu, édité toute la documentation je me suis fabriqué un mini banc d'essai (voir photo) et enfin j'ai programmé mon premier ATTiny et la c'est magique cela fonctionne (je me suis quand pris un peu la tête)
Maintenant je vais pouvoir faire quelques montages
Je vous recommande de lire
http://www.locoduino.org/spip.php?article188
http://www.locoduino.org/spip.php?article189
et tous les posts
Cordialement
Marcel
-
Bien, je ne sais pas qui a dit que la persévérance ça paye, il avait raison.
C'est moi, c'est moi ... ;D ;D ;D ;D (fayot !!)
-
Un peu facile Denis ! Il faut donner des preuves scientifiques ou techniques de ce que nous postons ! :)
Et bien de la technique, en voilà pour tous ceux qui suivent assidûment ce fil : le troisième article sur les µC ATtiny !
Le microcontrôleur ATtiny45 (3) (http://locoduino.org/spip.php?article190)
Cette fois, nous abordons la pratique en proposant deux montages très simples qui trouveront leur place sur un réseau de trains miniatures : un chenillard et une enseigne d'hôtel.
A vos platines d'essais et à vos fers à souder et bon modélisme... électronique ! ;)
-
Réalisation de l’Enseigne Lumineuse HOTEL avec ATtiny85 plutôt avec un Digispark 85
J’ai acheté plusieurs Digispark (vu sur le net la facilité de programmation via le port USB)
Je me suis lancé, chargé les Librairies et comme d’habitude à l’écran tout va bien mais en pratique cela ne fonctionne pas (donc recherche, etc…)
Je n’aime pas rester sur un échec, mon ex métier m’obligeait à trouver une solution. J’ai bricolé et trouvé ce qui suit (Je n’ai pas trouvé de post sur ce sujet)
Le 1er problème, après installation des librairies Digispark, j’ai perdu les librairies pour ATtiny. En réinstallant les librairies pour ATtiny cela a fait le contraire (possible que l’IDE, Windobe, ou mon incompétence, soient fâchés avec ce type de matériel)
1ère question : Quelle est la différence entre un ATtiny 85 et un Digispark 85 ?
Réponse : ls portent tous les 2 le même nom, - la différence Digispark utilise un régulateur de tension 5volts
2ème question : Peut-on programmer le Digispark comme l’ATtiny ?
Réponse : Oui, quelques fils et cela fonctionne
J’ai fait une prise côté Digispark 6 fils « récup ordinateur » Côté Arduino j’ai soudé les fils dans un support 8 broches et rajouter les 2 fils pour l’alimentation 5volts (voir photo)
J’ai installé un support USB en supprimant les connections à l’intérieur uniquement pour maintenir le Digispark à la verticale
Ensuite le Process écrit par Chistian Bezanger
http://www.locoduino.org/spip.php?article188
http://www.locoduino.org/spip.php?article189
http://www.locoduino.org/spip.php?article190
Mise en place du programme et tout il est correct.
J’ai refait le programme à la sauce Marcel (le principal, cela fonctionne et cela me convient. Je vais surement avoir les foudres de nos amis programmeurs, j’ai les mêmes quand je fais les macros dans Excel)
Cordialement
Marcel
-
suite
-
suite
-
Bonjour Marcel,
Moi aussi j'ai succombé au prix alléchant du Digispark. Mais je les ai récupérés le jour de mon départ à la neige. Je reviens la semaine prochaine et j'ai hâte d'essayer aussi sur Mac.
Amicalement
Dominique
-
Bravo pour cette réalisation à partir d'un Digispark 85. Au vu des photos, ton enseigne a plus de gueule que celle que j'ai hâtivement bricolée pour faire ma vidéo ! :D
J’ai refait le programme à la sauce Marcel (le principal, cela fonctionne et cela me convient. Je vais surement avoir les foudres de nos amis programmeurs, j’ai les mêmes quand je fais les macros dans Excel)
Cordialement
Marcel
Peu importe ce que pensent les ayatollahs de la programmation. Ce qui comptent en premier, c'est que le programme fonctionne sans boguer. De plus, on fait un loisir, il n'y a pas à être compétitif ou suivre des normes. Enfin, la programmation se peaufine au fil du temps : dans un an, tu ne coderas plus de la même façon qu'aujourd'hui car tu auras appris plein de choses en programmant à ta façon, en lisant les programmes des autres, etc.
Il n'y a pas de complexe à avoir. C'est comme pour l'anglais, c'est pourtant vrai que les Français parlent mal l'anglais ... mais au moins, ils le parlent ! Et cela, les anglo-saxons sont les premiers à le reconnaître et à nous en remercier. Il n'y a que nous pour nous dévaloriser.
Programmez et tant que ça marche, soyez-en fiers ! ! ! ;)
-
Etant programmeur de métier depuis plus de trente ans, je fais partie de ces ayatollahs dont parle Christian (sans rancune !). Il y a des constructions de code qui me hérissent le poil mais tu peux me croire: la toute première qualité d'un logiciel, c'est qu'il fasse ce qu'on lui demande ! Après seulement viennent la lisibilité et la facilité de maintenance, qui ne sont au final utiles que si tu comptes revenir un jour sur ton code pour le corriger ou l'améliorer, voire pour le donner à d'autres. Dans ce cas là, un passage vite fait pour nettoyer, reformater et documenter s'impose. Mais sinon, tant que ça fait ce que l'on veut...
-
Bonjour
Merci on va continuer (je suis la réalisation d'un bruitage de compresseur pour car avec décodeur)
Pour l'enseigne quelques bouts de plasticard, 5 leds blanches, un peu de fils émaillés.
Je me suis inspiré de ce que j'avais fait sur le MRS
A l'époque j'avais (qui fonctionne toujours) mis des lampes avec un montage à transistors + diodes (à l'occasion ce sera remplacée par un Digispark + ULN28003
-
Ayatollah bis ! ;)
Moi aussi, j'ai commencé en programmant sans me préoccuper de l'indentation, du nom des variables, des commentaires etc...
Tant que le programme marchait, c'était bon.
Disons que jusqu'à une centaine de lignes, on s'y retrouve quand même. Après ... on s'en mord les doigts.
Après, si peu qu'on l'abandonne quelques jours, on n'arrive plus à se relire ("Et pourtant, c'est moi qui ai écrit ce programme", se dit-on. "Mais qu'est que j'ai f** ?"
Maintenant que je me balade dans plus de 5 000 lignes, il y a longtemps que j'ai pris de bonnes résolutions et que je m'y tiens.
OK, ça n'est pas nécessaire, ça fait perdre un tout petit peu de temps, mais c'est largement compensé par une relecture plus facile et un dépannage plus aisé.
Ceci dit, en changeant complètement de sujet : magnifique photo ;D ;D ;D ;D
Un vrai plaisir à voir. Une réelle atmosphère.
Bravo.
Denis
-
Etant programmeur de métier depuis plus de trente ans, je fais partie de ces ayatollahs dont parle Christian (sans rancune !).
En parlant d'ayatollahs de la programmation, je ne pensais ni à toi Thierry, ni à toi Denis, mais plutôt aux donneurs de leçons qui sont souvent forts en théorie mais n'ont jamais montré la moindre réalisation : tous les deux, vous avez un joli palmarès à votre actif alors je ne me permettrai pas de vous traiter de termes barbares... :-[
De plus, nous sommes bien d'accord ; au début, ce qui compte c'est que le programme fonctionne et dans ce sens, je ne peux qu'encourager ceux qui programment à continuer à le faire à leur manière pourvu que le résultat soit atteint. Après, et nous sommes toujours d'accord, il faut se débarrasser de ses défauts et apprendre à bien présenter son code, bien l'indenter, bien choisir la taille des variables, bien structurer, utiliser des boucles plutôt que des répétitions, etc. etc. Mais après ! Et il ne faut pas attendre d'être au niveau d'un expert pour tenter de faire quelque chose. Sinon, on ne fait jamais rien ...
Comme toute phase d'apprentissage : en premier les bases avec sans doute des erreurs, en deuxième s'améliorer dans ce qui constitue aussi un art, la programmation. ;)
-
Voici le quatrième article sur les µC ATtiny :
Le microcontrôleur ATtiny45 (4) (http://locoduino.org/spip.php?article191)
Une fois de plus, deux montages très simples qui trouveront leur place sur votre réseau de trains miniatures, vous sont proposés : un simulateur de soudure à arc et des feux de carrefours routiers. Le tout bien sûr pour un prix défiant toute concurrence ! 8)
Bon modélisme... électronique ! ;)
-
Bonjour
Une petite pause pour un miniblock_fictif mais fonctionnel.
Dans les expositions, sur de nombreux réseaux (un peu moins maintenant) il y a des signaux qui hélas sont souvent soient éteints, toujours au vert même quand le train passe devant le dit signal , parfois posés et même pas câblés.
Je trouve que cela est injuste de ne pas faire fonctionner ce matériel.
Une détection (cela ne manque pas)
Une alimentation 5volts (alime de PC)
Sur le site ptitrain
http://www.ptitrain.com/electronique/index.htm
Il y a bon nombres d’articles dont je me suis inspiré (surtout le TTT), je vous invite à consulter.
L’article pour ce post reposait sur le » BalBid » il semble que l’accès ne fonctionne plus pour cet article.
C’était un montage simple et surtout très efficace.
J’avais réalisé un montage quelque peu similaire avec un CI 555 (tempo + relais) qui fonctionne encore sur le MRS (à terme qui sera remplacé par un Digispark)
Aujourd’hui force est de constater qu’une nouvelle technologie est arrivée l’ Arduino et les Attiny.
Comme d’habitude j’ai repris le Digispark (ou un ATtiny) pour réaliser ce petit montage qui peut s’implanter sur tous réseaux et surtout pour les réseaux modulaires.
Matériel nécessaire :
Un module Digispark ou ATtiny, un signal avec Leds Rouge et Verte (moins commun avec une résistance de 150Ω)
Pour les Entrées (2)
La première est destinée au contact de la détection
La seconde (pas nécessaire) pour une aiguille mal positionnée, un train dans le canton N+1, etc….
Pour le/les contacts » bouton poussoir, ils , etc….. » (ils doivent venir du moins 5volts)
Pour les Sorties (2)
Raccorder les Leds Rouge et Verte (NE PAS oublier la résistance)
Sur la photo le signal est à l’échelle N (fabrication personnelle)
Le programme
-
Bonjour
Sur le site ptitrain
http://www.ptitrain.com/electronique/index.htm
L’article pour ce post reposait sur le » BalBid » il semble que l’accès ne fonctionne plus pour cet article.
C’était un montage simple et surtout très efficace.
Merci pour tout.
Effectivement plus d'accès au "balbid".
Les schémas sont joints. J'avais réalisé le premier (4538) pour un diorama. c'est sympa.
Mais maintenant c'est un gadget à incorporer facilement dans un programme pourvu que l'on ait un "top" de détection.
-
Bonjour
Une petite pause pour un miniblock_fictif mais fonctionnel.
Bonjour CATPLUS,
Tout d'abord, bravo pour tes signaux qui sont des réalisations personnelles en N !
Par contre, je n'ai pas compris ce que réalise ton montage... :-[
Je suis en train de cogiter pour qu'un ATtiny45 puisse gérer son canton, c'est-à-dire détecter s'il est libre ou occupé et aubiner le signal en fonction de l'occupation des cantons aval. Pour le moment, je bute un peu car il me manque une entrée-sortie. Solution : passer à 6 E/S, ce qui veut dire ne plus pouvoir programmer l'ATtiny45 simplement ou bien passer à un ATtiny44. Je vous tiens au courant.
En attendant, une de mes prochaines fiches pratiques de Loco-Revue devrait donner un exemple de simulateur de B.A.L, c'est-à-dire un montage qui réagit comme un signal de B.A.L mais sans assurer l'espacement. Et c'est parfait pour un petit réseau. Cela résout, très simplement, le problème du signal éclairé de façon fixe au vert même quand un train passe. Un peu de patience dans la mesure où je ne décide pas des dates de parution des FP de LR. ;)
Et avant la fin de ce mois, un nouvel article sur l'ATtiny45 sur le site LOCODUINO avec une application à vous couper le souffle ! Enfin, j'espère... ;) (c'est fou ce que l'on peut faire avec des puces, comme dirait Rantamplan ! :D )
-
Bonjour Chris
Je croyais l'avoir expliquer dans le titre, ce montage serre uniquement a faire fonctionner en l'absence de cantonnement un signal fictif au passage d'un convoi (pas d'arrêt du dit convoi) uniquement pour le fonctionnement un signal (Rouge/Vert)
Il peut être utilisé n'importe où, dés lors qu'il y a une détection
Une pâle copie de ce que faisait le site de Ptitrain (voir la réponse précédente)
J'avais un peu de temps libre (je suis sur la programmation du DCC avec un Digispark) donc j'ai bricolé ce montage.
Si toute fois ce post ne correspond pas au attente de nos Amis Locoduinoistes. On délete.
Je n'en prendrais pas Ombrage
Cordialement
Marcel
-
Sans en être certain, c'est ce que j'avais cru comprendre.
Et du coup, cela rejoint ce que j'ai prévu pour une prochaine fiche pratique, déjà envoyée à la publication. On pourra donc comparer nos solutions. ;)
Nous allons réfléchir à une possibilité d'article mais cela prendra certainement un peu de temps car des articles, nous en avons encore en réserve et nous avons déjà beaucoup fait attendre leurs auteurs.
Tout cela pour dire que le travail ne manque pas et c'est la preuve que LOCODUINO fonctionne et que les microcontrôleurs ont fini par s'imposer dans notre hobby.
-
Bravo à tous pour vos réalisations. J'aime particulièrement l'hôtel avec son enseigne ainsi que son environnement.
Les Attiny sont tout à fait adaptés à des réalisations ferroviaires, mais j'utilise plutôt l'Attiny 2313 en boîtier DIP à 20 pattes. Il comporte plus d'entrées-sorties et je l'ai déjà utilisé dans 3 projets: la gare et le TCO de mon réseau, une commande de PN à servos et feux clignotants, une commande gare cachée.
Bonne fin de semaine et meilleures salutations.
-
Bonsoir Marc-Henri,
TCO ? ça m'intéresse, bien sûr.
Peux-tu faire un fil spécifique pour nous expliquer ça ? :P
Denis
-
Bravo à tous pour vos réalisations. J'aime particulièrement l'hôtel avec son enseigne ainsi que son environnement.
Les Attiny sont tout à fait adaptés à des réalisations ferroviaires, mais j'utilise plutôt l'Attiny 2313 en boîtier DIP à 20 pattes. Il comporte plus d'entrées-sorties et je l'ai déjà utilisé dans 3 projets: la gare et le TCO de mon réseau, une commande de PN à servos et feux clignotants, une commande gare cachée.
Bonne fin de semaine et meilleures salutations.
A partir de quoi programmes-tu tes ATtiny2313 ? Un module Arduino UNO ou bien un programmateur dédié ?
Sinon, 18 lignes d'E/S ça commence à faire, là où l'ATtiny44 n'en offre que 12 et l'ATtiny45 seulement 6 (bon retirer 1 pour garder le RESET !)
-
J'ai trouvé ceci
http://www.ernstc.dk/arduino/2313.htm
http://www.instructables.com/id/How-to-Program-ATtiny2313-Current-and-Updated/
https://oscarliang.com/program-attiny2313-using-arduino/
-
Merci Jean-Luc,
Sympas, ces sites.
Le lien du deuxième envoie sur le sommaire et on apprend à faire du pain ! ;D ;D ;D
Mais il suffit de se balader un petit peu pour trouver ce qu'on cherche sur Arduino.
Denis
-
Zut, erreur de copier-coller, c'est corrigé 8)
-
A partir de quoi programmes-tu tes ATtiny2313 ? Un module Arduino UNO ou bien un programmateur dédié ?
Sinon, 18 lignes d'E/S ça commence à faire, là où l'ATtiny44 n'en offre que 12 et l'ATtiny45 seulement 6 (bon retirer 1 pour garder le RESET !)
Bonjour Christian,
J'utilise mySmartUSB light http://doczz.fr/doc/385084/mysmartusb-light (http://doczz.fr/doc/385084/mysmartusb-light) pour la programmation des Attiny et Atmega. Il se pilote aisément depuis avrdude.
J'ajouterais que je suis sous Ubuntu et que tous les outils sont disponibles dans les dépôts logiciels: AVR-gcc, avrlib, avrdude. Le makefile avec diverses cibles pour compiler et programmer le microcontrôleur est appelé depuis l'éditeur gedit.
Pour la petite histoire, je n'ai jamais touché à un Arduino, mais l'approche reste quasiment la même et je ne me sens pas dépaysé sur Locoduino. ;)
Bonne fin de semaine et meilleures salutations.
Marc-Henri
-
J'ai trouvé ceci
http://www.ernstc.dk/arduino/2313.htm
http://www.instructables.com/id/How-to-Program-ATtiny2313-Current-and-Updated/
https://oscarliang.com/program-attiny2313-using-arduino/
C'est donc la même chose que pour programmer l'ATtiny45 à partir du module UNO, ce qui ne m'étonne pas puisque la structure des deux µC est à peu près la même.
-
Bonjour Christian,
J'utilise mySmartUSB light http://doczz.fr/doc/385084/mysmartusb-light (http://doczz.fr/doc/385084/mysmartusb-light) pour la programmation des Attiny et Atmega. Il se pilote aisément depuis avrdude.
Marc-Henri
Bonjour Marc-Henri,
J'ai déjà vu ce genre de petits programmateurs USB pour les µC AVR Atmel.
Tout de même, que de progrès en quelques années pour programmer simplement les µC !
Raison pour laquelle je fais de moins en moins d'électronique classique et de plus en plus d'électronique programmable. ;)
-
Bonsoir,
Si certains sont comme moi qui je cherche des réponses simples (et surtout je ne trouve pas)
Quelles sont les différences entre tous ces ATtiny?
Même tension
Même brochage
Uniquement la taille de la mémoire
ATtiny 13 => 1KB
ATtiny 25 => 2KB
ATtiny 45 => 4KB
ATtiny 85 => 8KB
C'est bon pour la mémoire !!!!!!
Cordialement
Marcel
-
Bonsoir Marcel,
Les paramètres qui distinguent les Attiny (comme les Atmega) sont:- la mémoire programme (FLASH), c'est ce que tu as mentionné.
- la mémoire de travail (SRAM), pour les variables du programme.
- la mémoire non volatile (EEPROM), pour conserver des données hors tension.
- les fonctions, tous ne disposent pas d'un convertisseur analogique-numérique.
- le nombre de pattes.
- le type de boîtier, pour les amateurs, il est plus facile de travailler avec les boîtiers PDIP traditionnels et éviter les versions à souder en surface.
- la consommation électrique, il existe des versions pico-power
- la tension ne semble pas être un paramètre, la plupart fonctionnent entre 1.8 et 5.5 V.
Le site du fabricant Atmel liste les 2 familles:- les Attiny: http://www.atmel.com/products/microcontrollers/avr/tinyavr.aspx (http://www.atmel.com/products/microcontrollers/avr/tinyavr.aspx)
- les Atmega: http://www.atmel.com/products/microcontrollers/avr/megaavr.aspx (http://www.atmel.com/products/microcontrollers/avr/megaavr.aspx)
Meilleures salutations.
Marc-Henri
-
Merci pour ces renseignements
Marcel
-
Voici un nouvel article sur le microcontrôleur ATtiny45 :
http://locoduino.org/spip.php?article192
Une fois de plus, nous vous proposons un montage qui trouvera sa place sur votre réseau de trains pour un prix très modique.
Bonne lecture.
Christian
-
Bonjour à tous,
Petite info : dans le dernier Loco Revue, en première fiche pratique, un court article pour programmer le ATTINY45
-
Normal, la fiche pratique de LR837 ET les articles de Locoduino sont du même auteur : Christian Bézanger ;D
Il est sur tous les fronts et mérite nos applaudissements :D :D :D
-
Bonjour à tous ceux qui aiment se secouer les puces (ATtiny bien sûr !)
Je cherche quelqu'un qui utilise des puces de la série ATtiny24/44/84, enfin surtout 44 et 84 car le 24 n'a pas assez de mémoire pour ce que je veux tenter.
Si vous avez l'expérience et qu'il vous reste une puce que vous pouvez (re)programmer, je vous demanderai de réaliser une expérience pour moi.
Vous pourrez ainsi faire avancer la science... ;)
-
L'événement Trainsmania à Lille a été l'occasion pour l'équipe de LOCODUINO de se réunir (autour d'une bonne table mais aussi pour travailler !!!). Beaucoup de projets vont sortir mais en attendant, je vous propose un nouvel article sur l'ATtiny :
Le microcontrôleur ATtiny45 (6) (http://locoduino.org/spip.php?article193)
Encore un montage pour allumer des LED me direz-vous ? Oui, mais ce sera le dernier et celui-ci vous propose une astuce de montage à connaître pour économiser les ressources de l'ATtiny45.
Le prochain article (dans quatre semaines) parlera du contrôle d'un servomoteur avec... un ATtiny ! :) (Mais si c'est possible !)
-
Je reviens sur ma demande
comment programmer l'ATtiny avec le programme de "Rudysmodelrailway"
J'ai cherché et trouvé le code, hélas je n'arrive pas à faire fonctionner le dit ATtiny (surement quelque chose que je n'ai pas compris)
J'aimerai savoir où se trouve la ligne de code pour changer le numéro du décodeur
Cordialement
Marcel
#include <DCC_Decoder.h>
#define kDCC_INTERRUPT 0
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Fill in the number of accessories / functions you want to control
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const byte maxaccessories = 1;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct {
int address; // User Configurable. DCC address to respond to
byte mode; // User Configurable. Mode: 1=Continuous, 2=Oneshot, 3=Flasher
byte outputPin; // User Configurable. Arduino pin where accessory is connected to
byte outputPin2; // User Configurable. 2nd pin for AlternatingFlasher (e.g. railway crossing)
int ontime; // User Configurable. Oneshot or Flasher on time in ms
int offtime; // User Configurable. Flasher off time in ms
byte dccstate; // Internal use. DCC state of accessory: 1=on, 0=off
byte onoff; // Internal use. Output state of accessory: 1=on, 0=off
byte onoff2; // Internal use. Output state of AlternatingFlasher 1=on, 0=off
byte finished; // Internal use. Memory that says the Oneshot is finished
unsigned long onMilli; // Internal use.
unsigned long offMilli; // Internal use.
} DCCAccessoryAddress;
DCCAccessoryAddress accessory[maxaccessories];
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Fill in the attributes for every accessory / function
// COPY - PASTE as many times as you have functions. The amount must be same as in line 18 above!
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ConfigureDecoderFunctions() // The amount of accessories must be same as in line 26 above!
{
accessory[0].address = 1; // DCC address
accessory[0].mode = 1; // Continuous: HIGH until DCC switches the address off again
accessory[0].outputPin = 1; // Arduino pin to which this accessory is connected
/*
accessory[1].address = 2;
accessory[1].mode = 2; // Oneshot: HIGH for ontime ms, then LOW and stays LOW.
accessory[1].outputPin = 1;
accessory[1].ontime = 1000;
accessory[2].address = 3;
accessory[2].mode = 3; // Flasher: HIGH for ontime ms, LOW for offtime ms, repeats till DCC off
accessory[2].outputPin = 0;
accessory[2].outputPin2 = 1; // Flasher can use 2 outputs, they will flash on/off alternatively
accessory[2].ontime = 500;
accessory[2].offtime = 500;
accessory[3].address = 4; // DCC address
accessory[3].mode = 4; // Continuous: HIGH until DCC switches the address off again
accessory[3].outputPin = 3; // Green signal
accessory[3].outputPin2 = 4; // Red Signal
accessory[3].onoff2 = 1; // Initially set Red signal to ON
*/
} // END ConfigureDecoderFunctions
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DCC accessory packet handler
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
{
// Convert NMRA packet address format to human address
address -= 1;
address *= 4;
address += 1;
address += (data & 0x06) >> 1;
boolean enable = (data & 0x01) ? 1 : 0;
for (int i=0; i<maxaccessories; i++)
{
if (address == accessory.address)
{
if (enable) accessory.dccstate = 1;
else accessory.dccstate = 0;
}
}
} //END BasicAccDecoderPacket_Handler
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Setup (run once)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
ConfigureDecoderFunctions();
DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
pinMode(2,INPUT); // Interrupt 0, use an external pull up resistor on the opto coupler circuit !
pinMode(0, OUTPUT);
digitalWrite(0, HIGH);
pinMode(1, OUTPUT);
digitalWrite(1, HIGH);
pinMode(3, OUTPUT);
digitalWrite(3, HIGH);
pinMode(4, OUTPUT);
digitalWrite(4, HIGH);
pinMode(5, OUTPUT);
digitalWrite(4, HIGH);
} // END setup
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Main loop (run continuous)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop()
{
static int addr = 0;//0
DCC.loop(); // Loop DCC library
if( ++addr >= maxaccessories ) addr = 0; // Next address to test 0
if (accessory[addr].dccstate)
{
switch (accessory[addr].mode)
{
case 1: // Continuous
accessory[addr].onoff = HIGH;
break;
case 2: // Oneshot
if (!accessory[addr].onoff && !accessory[addr].finished)
{
accessory[addr].onoff = HIGH;
accessory[addr].offMilli = millis() + accessory[addr].ontime;
}
if (accessory[addr].onoff && millis() > accessory[addr].offMilli)
{
accessory[addr].onoff = LOW;
accessory[addr].finished = true; //this is reset to flase below in the 'else' statement
}
break;
case 3: // Flasher, is an 'alternating' flasher together with outputPin2
if (!accessory[addr].onoff && millis() > accessory[addr].onMilli)
{
accessory[addr].onoff = 1;
accessory[addr].onoff2 = 0;
accessory[addr].offMilli = millis() + accessory[addr].ontime;
}
if (accessory[addr].onoff && millis() > accessory[addr].offMilli)
{
accessory[addr].onoff = 0;
accessory[addr].onoff2 = 1;
accessory[addr].onMilli = millis() + accessory[addr].offtime;
}
break;
case 4: // Signal
accessory[addr].onoff = 1;
accessory[addr].onoff2 = 0;
break;
}
}
else //accessory[addr].dccstate == 0
{
accessory[addr].onoff = 0;
if (accessory[addr].mode == 4) accessory[addr].onoff2 = 1; else accessory[addr].onoff2 = 0;
if (accessory[addr].mode == 2) accessory[addr].finished = false; // Oneshot finished by DCCstate, not by ontime
}
// activate outputpin, based on value of onoff
if (accessory[addr].onoff) digitalWrite(accessory[addr].outputPin, LOW);
else digitalWrite(accessory[addr].outputPin, HIGH);
if (accessory[addr].onoff2) digitalWrite(accessory[addr].outputPin2, LOW);
else digitalWrite(accessory[addr].outputPin2, HIGH);
} //END loop
-
...Je cherche quelqu'un qui utilise des puces de la série ATtiny24/44/84, enfin surtout 44 et 84 car le 24 n'a pas assez de mémoire pour ce que je veux tenter.
Si vous avez l'expérience et qu'il vous reste une puce que vous pouvez (re)programmer, je vous demanderai de réaliser une expérience pour moi....
Bonjour,
Je ne sais pas si cette demande est toujours d'actualité, mais je viens de recevoir mes deux premiers ATtiny 84.
Je n'ai pas d'expérience particulière (j'en suis au stade de reproduire les exemples donnés ici :) ) mais je veux bien, si je suis guidé, réaliser une expérience, pour "faire avancer la science" ;D ;D ;D
Cordialement.
Jean-Michel
-
Bonjour,
Oui, cette demande est toujours d'actualité.
Si vous disposez d'ATtiny84 et si vous avez déjà réussi à les programmer avec un simple module UNO, il y a une expérience à faire.
Ce serait de charger le programme donné en exemple -> Servo -> Sweep et de voir s'il est possible de le téléverser sur un ATtiny84.
Ce programme compile bien pour l'ATtiny84 et utilise 2084 octets et 52 octets de RAM, donc logiquement on doit pouvoir le téléverser.
Ensuite, brancher un servomoteur sur la pin qui va bien (voir dans le programme) et observer si le servo obéit aux ordres de déplacement.
Si oui, cela ouvre un champ de possibilités avec la bibliothèque Servo.
Merci de me tenir au courant si la manip est faisable.
Christian
-
Bonsoir,
Je suis toujours volontaire pour "faire avancer la science", mais je ne remplis pas trop le cahier des charges :
. Je dispose d'ATtiny84 (ATtiny84A-PU)
. Mon module est un ATMEGA2560 (et non un UNO)
. Quand je compile à blanc le programme Sweep, celui-ci utilise 3128 octets (et non 2084) et 163 octets de RAM (et non 52)
. Je n'ai pas dans l'immédiat de servomoteur disponible, ce dispositif ne figurant pas dans mes axes de développement, mais je pense pouvoir en trouver un
La manip est elle faisable ?
Cordialement.
Jean-Michel
-
Bonjour Jean-Michel,
Tout d'abord, une question : as-tu déjà programmé un ATtiny84 avec ton module Mega ? (Il me faut quelqu'un qui maîtrise cette procédure)
Si oui, il n'y a pas de différence entre UNO et MEGA puisque les deux jouent simplement le rôle de programmateur.
Le nombre d'octets utilisés par la compilation de Sweep dépend du type de carte (processeur) utilisé ; ce n'est donc pas anormal d'avoir un chiffre pour l'ATtiny84 et un pour la carte Mega. J'ai compilé de mon côté pour une Mega et j'obtiens comme toi.
Le but de la manip est de téléverser le programme Sweep dans un ATtiny84 et de voir ensuite si celui-ci peut commander un servomoteur (attaché à la bonne sortie) pour obtenir ce mouvement de balayage. Si c'est le cas, cela veut dire que la bibliothèque Servo est utilisable avec l'ATtiny84, ce qui serait une aide précieuse pour utiliser des servos.
Christian
-
INFORMATION IMPORTANTE
Les articles concernant les microcontrôleurs ATtiny45 (actuellement, il y en a 6 et d'autres sont prévus) sont visibles dans l'onglet "Projets ferroviaires de niveau 2".
Je les ai retirés de l'onglet "Les composants électroniques" car cet onglet est situé dans la colonne réservée aux débutants. Or, cela ne me parait pas une bonne idée de chercher à programmer des microcontrôleurs tant qu'on n'a pas acquis de solides bases dans l'utilisation d'Arduino et de son IDE.
Après, chacun fait comme il en a envie, mais ma responsabilité d'auteur est de faire savoir que la programmation de microcontrôleurs est plutôt du domaine des initiés (pas forcément expert) et qu'il peut y avoir des problèmes à résoudre. Toute l'équipe de LOCODUINO est prête à vous aider, mais il est parfois difficile de trouver la cause d'un problème à distance.
Merci de votre compréhension.
Christian
-
Le but de la manip est de téléverser le programme Sweep dans un ATtiny84 et de voir ensuite si celui-ci peut commander un servomoteur (attaché à la bonne sortie) pour obtenir ce mouvement de balayage. Si c'est le cas, cela veut dire que la bibliothèque Servo est utilisable avec l'ATtiny84, ce qui serait une aide précieuse pour utiliser des servos.
Bonjour Christian,
Ben... malheureusement, ça ne marche pas :-\
Aucun mouvement du servo quand le programme "Sweep" est téléversé dans l'ATtiny84, alors que le mouvement de balayage du servo est bien observé quand ce même programme est téléversé dans l'Arduino Mega.
Bien évidement, j'ai adapté le numéro de la sortie en fonction de la carte utilisée :
Sortie 2 pour le module Mega
Sortie 1 (pin 12) de l'ATtiny84
Pour être certain de mon coup quand à la sortie 1 de l'ATtiny84, j'ai testé celle-ci avec le programme basique "Blink" (avec le rythme modifié pour être bien sûr que c'était le mien) et une LED (externe évidement ;D)
A toute fin utile, je précise que, une fois le programme "Sweep" téléversé dans l'ATtiny84, le fait de connecter une LED sur la sortie prévue pour la commande du servo allume celle-ci de manière fixe (en tout cas, visuellement parlant).
Je profite de ce message pour vous dire que, avant de tester le programme "Sweep" et à titre de mise en bouche puisque je débutais en programmation de µC, j'ai programmé un ATtiny85 en m'inspirant du programme "signal_BAL" paru dans le LR de mai 2017 (programme auquel il manque une ou deux lignes il me semble) en lui rajoutant une durée du "Jaune" paramétrable ainsi que l'allumage / extinction des LEDs de façon progressive. Ca fonctionne très bien :)
-
Bonjour Christian,
Finalement, j'ai trouvé pourquoi cela ne marchait pas : c'est la bibliothèque Servo.h utilisée dans le programme "Sweep" qui n'est pas adaptée.
En effet, cette bibliothèque est basée sur un timer 16-bit alors que les ATtiny utilisent en standard un timer 8-bit (l'ATtiny84 dispose bien d'un timer 16-bit mais son utilisation dans un programme n'est pas simple puisqu'il s'agit plutôt d'un artifice permettant de faire travailler de concert deux timers 8-bit).
Donc, en cherchant un peu, j'ai finit par trouver une bibliothèque basée sur un timer 8-bit et adaptée à l'ATtiny : SoftwareServo.h
En adaptant le programme "Sweep" à cette bibliothèque, ça fonctionne maintenant parfaitement : le servo connecté à l'ATtiny84 effectue bien son mouvement permanent de balayage.
En adaptant le port de sortie, ça fonctionne aussi bien sans autre adaptation avec un ATtiny85 :)
Cordialement.
Jean-Michel
-
Bravo jeanmi67 ! ;D
Cela confirme bien que l'ATTiny, sous des airs de matériel pour débutants liés au faible nombre de pattes, recèle des subtilités qui ne sont plus du niveau débutant.
Concernant les servos, cette bibliothèque est-elle affectée du "syndrome de l'essuie-glace" au démarrage ?
Denis
-
Bonjour Christian
En te lisant, tu t'exprime:
"Je profite de ce message pour vous dire que, avant de tester le programme "Sweep" et à titre de mise en bouche puisque je débutais en programmation de µC, j'ai programmé un ATtiny85 en m'inspirant du programme "signal_BAL" paru dans le LR de mai 2017 (programme auquel il manque une ou deux lignes il me semble) en lui rajoutant une durée du "Jaune" paramétrable ainsi que l'allumage / extinction des LEDs de façon progressive. Ca fonctionne très bien"
Pourrais-tu STP nous faire profiter des modifs que tu as apporté "inclure le programme sur le post de ce Forum"
Cordialement
Marcel
-
Concernant les servos, cette bibliothèque est-elle affectée du "syndrome de l'essuie-glace" au démarrage ?
Bonjour Denis,
Comme je le disais plus haut, je n'ai pas d'expérience particulière avec les servos, donc je ne connais pas le "syndrome de l'essuie-glace".
Si celui-ci peut-être représenté par un aller-retour complet du servo à sa mise en route, la réponse est non.
Je viens de faire quelques essais, servo toujours "conduit" par l'ATtiny84, et voici mon constat : quelque soit la position de départ du servo, à la mise en route il y a un premier mouvement très fugitif dans le sens des aiguilles d'une montre suivi immédiatement après par le déroulé normal du balayage commençant dans le sens inverse des aiguilles d'une montre, sens initial de déplacement donné par le programme.
Voila, j'espère avoir répondu à ta question. :)
Jean-Michel
-
Bonjour Christian
....
Pourrais-tu STP nous faire profiter des modifs que tu as apporté "inclure le programme sur le post de ce Forum"
Bonjour Marcel,
Je me permets de répondre à la place de Christian ;D ;D ;D
Je déposerai ici le programme complet dans le courant de la journée :)
Jean-Michel
-
Suite à la demande d'Albert, voici le programme complet et documenté de l'adaptation de celui de Christian paru initialement dans Loco-Revue de mai 2017 (simulation de BAL)
/* Simulation de Bloc Automatique Lumineux
Base tirée de Loco-Revue n° 837 - Mai 2017 (Christian Bézanger)
Adaptation *** jmB *** 04/05/2017
Durée du Jaune paramétrable
Allumage et extinction des LEDs de façon progressive
Testé sur ARDUINO MEGA2560 et sur ATtiny85
Fading repris de l'IDE Arduino : Exemples - 03.Analog - Fading
http://www.arduino.cc/en/Tutorial/Fading
Signal à anode commune, allumé par LOW
===>>> Version ATtiny85 <<<===
*/
// Déclaration des constantes
// => Assignation des broches d'entrées et de sorties
// ===>>> Version ATtiny85 <<<===
const byte ILS_entree = 3; // Pin 2
const byte ILS_sortie = 2; // Pin 7
enum FEU : const byte { VERT = 4, ROUGE = 0, JAUNE = 1 }; // Ordre des LEDs en partant du haut du signal (www.railexpert.fr/images/railexpert/photos-pave-droite/signal.jpg)
// ===>>> Version ATtiny85 <<<===
// => Gestion du fading
const byte fadeValue = 10; // Incrément de fading
const byte fadeDelay = 10; // Temporisation de fading
// Déclaration et initialisation des variables
unsigned int dureeJaune = 5000; // Durée du jaune : 1000 = 1 seconde
unsigned long debJaune = 0;
unsigned long time0; // Top pour le cyle d'extinction et d'allumage
unsigned long time1; // Top intermediaire
byte FEU = VERT; // Pour mémorisation de l'état du feu : ou VERT, ou ROUGE ou JAUNE
////////////////////////////////////////////////////
// Routine d'allumage et d'extinction progressifs //
////////////////////////////////////////////////////
void signal(const byte quelFeuA, const byte quelFeuE, byte fadingA, byte fadingE) // A=Allumage - E=Extinction
{
time0 = 0;
do {
time1 = millis();
if (time1 - time0 >= fadeDelay) {
analogWrite(quelFeuA, fadingA);
analogWrite(quelFeuE, fadingE);
time0 = time1;
fadingA = fadingA - fadeValue;
fadingE = fadingE + fadeValue;
}
} while (fadingE >= fadeValue);
analogWrite(quelFeuA, 0); // Fin de boucle : allumage 100%
analogWrite(quelFeuE, 255); // Fin de boucle : extinction totale
FEU = quelFeuA;
}
// Initialisation du module
void setup() {
// Déclaration des entrées et initialisation (HIGH) => ILS non enclenchés
pinMode(ILS_entree, INPUT_PULLUP);
pinMode(ILS_sortie, INPUT_PULLUP);
// Déclaration des sorties
pinMode(VERT, OUTPUT);
pinMode(ROUGE, OUTPUT);
pinMode(JAUNE, OUTPUT);
// Initialisation du signal
digitalWrite(VERT, LOW); // Vert allumé - Pas de fading à la mise sous tension
digitalWrite(ROUGE, HIGH); // Rouge éteint
digitalWrite(JAUNE, HIGH); // Jaune éteint
}
// Boucle principale
void loop() {
// surveillance ILS entrée
while (digitalRead(ILS_entree) == HIGH)
{
// ILS Entrée non enclenché
if (FEU == JAUNE)
{
if ((millis() - debJaune) > dureeJaune)
{
signal(VERT, JAUNE, 255, 0); // Ordre : allumage, extinction
}
}
}
// ILS Entrée déclenché
switch (FEU) {
case VERT:
signal(ROUGE, VERT, 255, 0); break; // Ordre : allumage, extinction
case JAUNE:
signal(ROUGE, JAUNE, 255, 0); break; // Ordre : allumage, extinction
}
// Surveillance de l'ILS de sortie
while (digitalRead(ILS_sortie) == HIGH)
{
// ILS Sortie non déclenché, ne rien faire
}
// ILS Sortie déclenché
signal(JAUNE, ROUGE, 255, 0); // Ordre : allumage, extinction
debJaune = millis();
}
Bonne journée à tous. :)
Jean-Michel
-
Super la réactivité
Je vais tester dés que possible
Cordialement
-
Je m'immisce dans ce sujet parce que j'ai trouvé par hasard un site décrivant un shield maison pour la programmation des Attiny... Comme l'idée semble aussi intéressante qu'économique, voici le lien
http://www.kaibader.de/attiny-isp-arduino-shield/
malgré l'adresse allemande, le site est en anglais...
PS: Inscrit depuis peu sur Pinterest, c'est grâce à ce réseau que je découvre des choses arduinesques plus ou moins sympas... Il suffit de trier.
-
Bonjour
Bricolage maison, un bout de Véroboard, support pour tous les types, quelques soudures et roule
Cordialement
Marcel
-
Bonjour à tous,
Cela fait longtemps que je ne suis pas venu sur cette page ; je suis confus... :-[
Je vais donc essayer de répondre à tous;
jeanmi67 : merci pour tes expérimentations. Donc il existe une bibliothèque pour les ATtiny. Peux-tu nous dire où la télécharger ?
DDEFF : effectivement, l'ATtiny demande déjà de bien maitriser différentes notions comme les registres, le type de mémoire, etc. C'est la raison pour laquelle j'ai supprimé ces petites bêtes de la colonne débutant du site LOCODUINO. Je pensais qu'un débutant arriverait à programmer ces puces en suivant mes procédures, mais dès qu'il y a le moindre problème, le pauvre se retrouve confronté à lui-même et s'il ne maitrise pas bien les bases, cela peut vite le faire patauger.
CATPLUS : effectivement, il manque une ou deux lignes dans le programme de la fiche pratique du LR mai 2017. J'en suis désolé et c'est de ma faute ; au départ, elles y étaient mais on m'a demandé de refaire la figure en haute définition et cela a fait sauté deux lignes de programme sans que je m'en aperçoive. J'ai immédiatement publié un correctif sur le site de Loco-Revue, sur le fil concernant ce numéro de mai 2017. D'ailleurs, lorsque je publie dans Loco-Revue, je complète éventuellement sur le forum de Loco-Revue, ne serait-ce que pour mettre un programme téléchargeable. Pensez a y faire un tour au cas où...
On peut paramétrer la durée du feu orange, mais pour ma part, je préfère mesurer la durée du feu rouge et l'affecter à la durée du feu orange. Ainsi, si on admet que les cantons ont la même longueur et que le train garde sa vitesse, chaque canton est parcouru dans le même temps ce qui donne des durées identiques pour rouge et orange.
La programmation d'ATtiny peut se faire grâce à de nombreux petits montages du commerce qu'on insère directement dans la sortie USB de l'ordinateur ou bien en bricolant soi-même un tel montage. Pour ma part, j'utilise une breadboard et six câbles pour raccorder à l'UNO. Mais c'est moins pratique.
Bon voici le programme de la fiche pratique de LR 838 de mai 2017 (Celui-ci est valide pour un ATtiny45/85 et fonctionne aussi pour un UNO avec des sorties différentes de celles employées dans la fiche pratique) :
/**********************************
* Signal_BAL_ATtiny - 30/11/2016 *
* ********************************
* Ce programme simule le fonctionnement d un signal lumineux a trois
* feux d un B.A.L Block Automatique Lumineux. Il n assure pas
* l espacement des trains. Lorsque la loco declenche le premier ILS,
* le signal se met au rouge. Lorsque la loco declenche le deuxieme
* ILS, le signal se met a l orange pour une duree egale a celle du
* rouge, puis repasse au vert.
*/
/* VARIABLES
* --------------------------------------------------------------
* debRouge : temps de debut du feu rouge
* finRouge : temps de fin du feu rouge
* dureeRouge ; duree du feu rouge
* debOrange : temps de debut du feu orange
* flagOrange : booleen 0 si feu orange eteint, 1 si allume
*/
/* BRANCHEMENTS
* --------------------------------------------------------------
* ILS E (entree) sur 3
* ILS S (sortie) sur 4
* feu vert sur 0
* feu rouge sur 1
* feu orange sur 2
*/
const byte ILS_entree = 3;
const byte ILS_sortie = 4;
const byte feu_vert = 0;
const byte feu_rouge = 1;
const byte feu_orange = 2;
unsigned long debRouge = 0;
unsigned long finRouge = 0;
unsigned long debOrange = 0;
unsigned long dureeRouge;
boolean flagOrange = 0;
void setup() {
pinMode(ILS_entree, INPUT_PULLUP);
pinMode(ILS_sortie, INPUT_PULLUP);
pinMode(feu_vert, OUTPUT);
pinMode(feu_rouge, OUTPUT);
pinMode(feu_orange, OUTPUT);
// Initialisation du signal a anode commune, allume par LOW
digitalWrite(feu_vert, LOW);
digitalWrite(feu_rouge, HIGH);
digitalWrite(feu_orange, HIGH);
}
void loop() {
// Surveillance de l ILS d entree
while (digitalRead(ILS_entree) == HIGH)
{
// ILS E non declenche
if (flagOrange)
{
if ((millis() - debOrange) > dureeRouge)
{
digitalWrite(feu_orange, HIGH);
flagOrange = 0;
digitalWrite(feu_vert, LOW);
}
}
}
// ILS E declenche
digitalWrite(feu_vert, HIGH);
digitalWrite(feu_orange, HIGH);
flagOrange = 0;
digitalWrite(feu_rouge, LOW);
debRouge = millis();
// Surveillance de l ILS de sortie
while (digitalRead(ILS_sortie) == HIGH)
{
// ILS S non declenche, ne rien faire
}
// ILS S declenche
finRouge = millis();
dureeRouge = finRouge - debRouge;
digitalWrite(feu_rouge, HIGH);
digitalWrite(feu_orange, LOW);
flagOrange = 1;
debOrange = millis();
}
-
Bonjour,
jeanmi67 : merci pour tes expérimentations. Donc il existe une bibliothèque pour les ATtiny. Peux-tu nous dire où la télécharger ?
J'ai trouvé cette bibliotèque sur le site de l'Arduino, et plus précisément ici : https://playground.arduino.cc/ComponentLib/Servo (https://playground.arduino.cc/ComponentLib/Servo)
CATPLUS : effectivement, il manque une ou deux lignes dans le programme de la fiche pratique du LR mai 2017.
Je pense que c'est plutôt moi qui avait émis cette hypothèse (message du 14-05-2017, 01:27:45), mais je ne suis pas jaloux ;D, l'important, me semble-t-il, est que chaque pierre apportée par chacun contribue à faire avancer la communauté :)
Bien cordialement.
Jean-Michel
-
Oui, désolé, tu as parfaitement raison !
La phrase de toi, a été reprise d'un post de CATPLUS mais je ne me suis pas rendu compte qu'il te citait.
Donc, rendons à César ce qui est à César... ;)
Maintenant, tout le monde a le programme dans sa totalité. Ouf !
-
Voici une petite vidéo qui vous montrera l'effet obtenu avec le montage décrit dans la fiche pratique III.42 du N°838 de Loco-Revue (mai 2017) :
https://vimeo.com/219999631
Cette fois, le montage a été réalisé avec un ATtiny45 pour économiser un module UNO, mais il fonctionne de la même manière.
Quant-au programme, il a été publié un peu plus haut dans ce fil.
-
Bonjour,
Merci pour cette vidéo :)
Pour ceux que cela intéresse, la version modifiée de ce programme intégrant l'extinction et l'allumage progressifs des LEDs a également été publiée un peu plus haut dans ce fil (version testé sur un montage réalisé avec un ATtiny85).
Jean-Michel
-
Pour faire suite
J'ai fait un montage que vous pourrez voir à FédéRail
Cordialement
Marcel
-
Juste pour mettre la photo d'une réalisation compacte des feux tricolores de Christian Bézanger, avec un ATtiny13. Pas encore en CMS !
-
Pour faire suite
J'ai fait un montage que vous pourrez voir à FédéRail
Cordialement
Marcel
Cette première journée à FédéRail à Rosny sous Bois s'est très bien passée : beaucoup de visiteurs s'arrêtaient pour poser des questions. L'idée de tenir un stand LOCODUINO vient de Dominique. Marcel et moi l'avons soutenu pour cette première journée. Aujourd'hui, le stand sera tenu par Dominique et Hubert. Vous avez donc encore l'occasion de rencontrer une partie de l'équipe qui a apporté du matériel de démonstration pour cette occasion. Un grand merci à la FFMF pour nous avoir invités.
LOCODUINO publie aujourd'hui un nouvel article concernant le microcontrôleur ATtiny45 :
Le microcontrôleur ATtiny45 (7) (http://www.locoduino.org/spip.php?article194)
Cette fois, nous proposons un automatisme de passage à niveau pour ligne à voie unique, réalisé avec un servomoteur.
Une bonne occasion de découvrir comment contrôler un servomoteur par un microcontrôleur.
Mais que cela ne vous empêche pas d'aller visiter FédéRail, l'article, vous pourrez toujours le lire plus tard... ;)
Fédé-Rail : centre aquatique Camille Muffat de Rosny sous Bois. 18 Mail Jean Pierre Timbaud. A86 sortie 17. N'hésitez pas à utiliser le parking souterrain sous le centre, il n'est pas cher (3,90 euros pour hier de 9h à 18 h 30). La gare de RER n'est pas très loin du centre aquatique pour ceux qui préfèrent le train.
-
Bonjour à tous
Très bonne journée avec Dominique Christian et le passage d'Hubert qui revient ce dimanche avec Dominique.
Merci à la FMFF .
Sur la photo de gauche à droite
Dominique, Christian et Hubert pour ma part je prends la photo.
Ce genre d'exposition est très riche, contacts, discutions. Je pense qu'il faut renouveler cette expérience.
Cordialement
Marcel
-
Belle photo. Je regrette de ne pas faire partie de la fête, mais je ne doute pas que l'occasion se représente...
Bonne évangélisation !
-
Un jour, on aura aussi une photo de Marcel... ;D
Bon courage à nos missionnaires !
Denis
-
J’utilise les Kits de Miller Engineering
http://www.microstru.com
la programmation du pic comporte 43 illuminations différentes, la sélection se fait avec un bouton poussoir.
Mon idée (comme je suis devenu un peu paresseux) remplacer l’appui du BP par Mr ATtiny85
Il n’y a rien à couper, uniquement souder un fil sur la carte (voir photo)
Installer un optocoupleur type 4N35 entre l’ATtiny et le Kit (voir plan)
Le programme TIMER_4_ATTINY
Il y a 5 boucles (c’est du n’importe quoi….) Je n’ai pas trouvé de solution pour programmer de 1mn à 1 heure (merci aux ayatollahs de la programmation de nous aider)
La 1ère boucle est de 1 seconde, quand l’ensemble du programme est terminé, on envoie une impulsion et le programme Signs change.
De la 2ème à la 5ème boucles le temps total correspond à un peu plus de 1mn (pourquoi 4 fois la même chose, si l’on programme plus de 30000, le systeme bloque, par contre 4 fois la même chose cela fonctionne………… Bizarre
Amicalement
Marcel
PS Je n'arrive toujours pas à programmer l'ATtiny en décodeur.......
-
Bonjour Marcel,
Un int fait 16 bits et est signé. On peut donc coder une valeur allant de -32768 à +32767. ceci explique pourquoi tu ne peux pas dépasser 30000 et des poussières. Si tu le fais, tu as un débordement, la valeur que tu crois positive devient en fait négative : 32767 + 1 = -32768. Tes intervalles deviennent donc négatifs. Par conséquent millis() - time_since_last_reset qui est positif car millis() renvoie un entier non signé sur 32 bits (de 0 à plus de 4 milliards) est toujours faux.
Voir http://www.locoduino.org/spip.php?article11
Sinon, pourquoi ne pas utiliser une ScheduleTable pour générer tes impulsions ? : http://www.locoduino.org/spip.php?article116
-
Merci Jean-Luc pour les explications.
C'est clair.
Pourquoi je n'ai pas utilisé "ScheduleTable" parce que je ne l'ai pas lu..... Mea-culpa.
Si j'ai bien tout compris, faut refaire la programmation? mais pas aujourd'hui.
-
Bonjour,
Quand les pros parlent il faut les écouter.
Donc j'ai refait le programme avec la librairie "ScheduleTable" et tout va bien (test de 1, 2, 4, 5, 10, 15, 30, 45 minutes & 1heure)
Le seul soucis, hélas cette librairie ne fonctionne pas avec un ATtiny.
J'ai fait le même montage avec un Nano.
Cordialement
Marcel
-
Bonjour à tous,
Je viens réveiller ce fil pour vous annoncer que nous avons publié un nouvel article sur l'ATtiny45 ; il est question de PWM, d'entrées analogiques et d'interruption.
Et tout cela le plus simplement du monde grâce à l'IDE d'Arduino.
Cerise sur le gâteau pour votre réseau : un clignoteur universel pour moins de 5 euros où vous pourrez régler la fréquence de clignotement, la durée de l'allumage et la luminosité de la LED.
Vous trouverez cet article ici : http://locoduino.org/spip.php?article195 (http://locoduino.org/spip.php?article195)
-
Bonjour CATPLUS
Le seul soucis, hélas cette librairie ne fonctionne pas avec un ATtiny.
Pourrais-tu préciser ? pb de compilation ?
-
Tout ce qui fonctionne pour un UNO ne va pas forcément fonctionner pour l'ATtiny. La raison vient du fait que la conception de l'ATtiny, bien que très proche du µC de l'UNO (l'ATmega328P), n'est pas rigoureusement identique. Par exemple, pas de timer 16 bits sur l'ATtiny25/45/85, donc les bibliothèques qui utilisent le timer 16 bits de l'UNO ne fonctionneront pas sur un ATtiny. C'est le cas de la bibliothèque Servo. Peut-être est-ce la même chose pour ScheduleTable ? (je ne me suis pas encore penché dessus et Jean-Luc en sait peut-être plus que moi sur elle).
Cela vaut pourtant la peine d'essayer, mais dans ce cas, il faut si cela ne marche pas, regarder de près le message d'erreur du compilateur pour voir la raison (exemple : un registre n'a pas été reconnu).
Dans le dernier article que je viens de publier, j'ai indiqué qu'on peut utiliser la fonction attachInterrupt avec l'ATtiny, mais il faut utiliser l'ancienne formulation (celle qui n'est plus recommandée) et non la nouvelle avec digitalPinToInterrupt(pin).
-
ScheduleTable n'utilise aucune spécificité matérielle et aucune bibliothèque. Elle n'utilise que millis().
-
Je viens de réaliser 2 petits montages:
1 Simulation de flammes dans le foyer d'une machine à Vapeur
2 Allumage de leds pour Rail Crossing
1 Imitation de flammes dans le Foyer « Machine à Vapeur »
Ce montage utilise 3 leds « 2 jaunes & 1 rouge »
Toutes les leds ont une intensité et une vitesse variable.
L’effet recherché est une impression de flamme dans le foyer de la machine (j’ai mis du papier alu autour des leds)
J’ai trouvé ce montage sur le site
http://model-railroad-hobbyist.com/node/29679
l’auteur utilise un Arduino UNO, j’ai fait des petites modifications pour l’utilisation d’un Attiny85.
Ce montage peut s’intégrer facilement dans du Zéro, éventuellement dans du Ho, mais j’ai un doute dans le N (ne pas sous-estimer les modélismes)
Modification des valeurs de base et des sorties
Ne possédant pas de machine vapeur dans mon parc, si un modéliste fait cette réalisation merci de nous faire des photos.
Cordialement
Marcel
-
Foyer suite
-
2 Cantilever Rail Crossing
Cantilever Crossing Signals
(http://)
Ho Scale Walthers Cornerstone 933-2303 Cantilever Crossing Signals
https://www.youtube.com/watch?v=8PT_xbVut2E
A l’origine ce montage fonctionne avec un Arduino UNO ou NANO, j’ai modifié quelques valeurs et les sorties pour le faire fonctionner avec un Attiny85.
http://www.spcoast.com/wiki/index.php/GradeCrossing
L’alimentation de ce CROSSING fonctionne sous 12 volts « SANS OUBLIER LA RESISTANCE de 1k »
Nous ne pouvons pas faire fonctionner l’Attiny avec une tension supérieure à 5volts et le CROSSING en 12volts, j’ai installé une petite interface avec 2 transistors 2N3904 sur les sorties de l’Attiny
Brancher le commun du CROSSING sur le (+) 12volts et les leds au (-) sur les transistors
Les pins de sortie Arduino / Attiny sont des plus (+) à brancher sur les bases des transistors.
Dans le fichier Attiny_CROSSING.ino , les instructions modifiées sont notifiées dans le programme.
« Traduction des commentaires de l’auteur »
L’utilisation des broches d'E/S sont les suivantes:
Broche numérique 2: Entrée de détection temporisée: Utiliser avec un circuit de détection actif à collecteur ouvert bas (-) des deux côtés du passage à niveau. Un niveau bas (-) sur cette entrée déclenchera une minuterie de 10 cycles à chaque déclenchement, si vous n'utilisez qu'un seul détecteur, assurez-vous de connecter également cette broche à la broche numérique 3, le détecteur "Road Blocked".
Broche numérique 3: Détection de route bloquée Entrée: "Toujours Flash" Détection, quand cette entrée est basse (-) le clignotant continuera à fonctionner
Broche 0 numérique : LED de croisement (pin 5 pour NANO)
Broche 1 numérique: "Autre" LED de croisement (pin 6 pour NANO)
Broche 13 numérique : Une option; LED de débogage; celle-ci est généralement visible sur la carte Arduino
Manque plus que du son, je vais faire le nécessaire.
Cordialement
Marcel
-
Montage
Cordialement
Marcel
-
De superbes photos, comme toujours !
Bravo !
Amicalement
Dominique
-
Bonjour,
Comme j'ai mis la main sur des ATTiny (45), j'ai vérifié qu'effectivement ScheduleTable ne compilait pas. En effet, le package logiciel de ces petits micros n'intègrent pas les fonctions d'allocation dynamique de mémoire que ScheduleTable utilise (utilisait maintenant). J'ai donc modifié ScheduleTable et c'est Ok, ça compile et ça fonctionne.
Je mettrai à jour l'article sur Locoduino et les exemples en même temps que je pousserai la dernière version sur GitHub.
-
Bonjour,
J'ai conçu une carte à base d'ATTiny84 (ou plus petit, 44 ou 24) pour détecter l'arrivée des locomotives en bout de remise.
Sur mon réseau la détection de présence se fait par consommation de courant. C'est fiable mais pas très précis car ça dépend de la captation de courant de la locomotive c'est à dire de la distance entre l'avant de la loco et le premier essieu consommateur.
Mes cantons ont une zone de pleine voie et une zone d'arrêt. L'idée est de commuter une charge, une résistance, pour simuler une présence sur la zone d'arrêt en fonction de l'état d'une barrière IR, la zone d'arrêt n'étant pas utilisée pour alimenter la locomotive. Lorsque la loco coupe le faisceau, la présence en zone d'arrêt est activée.
J'aurais pu faire une électronique sans micro-contrôleur mais comme j'ai des voies de remises parallèles, allumer en permanence le faisceau risque de provoquer des détections parasites. Donc les faisceaux ne sont allumés qu'au moment de la mesure et deux faisceaux ne sont jamais allumés en même temps.
Etant donné la simplicité de l'application, j'ai choisi d'utiliser un ATTinyX4 qui permet de gérer 3 voies.
J'ai donc commandé quelques ATTiny 84, J'ai installé ATTinyCore (https://github.com/SpenceKonde/ATTinyCore), je n'ai pas eu de soucis de mise en œuvre.
Ce qui m'a rapidement enquiquiné c'est l'utilisation d'une breadboard pour programmer le micro avec les erreurs de branchement possibles. J'avais un support de test qui trainait dans un tiroir et j'ai réalisé ceci qui me permet de programmer les x4 (14 broches) et les x5 (8 broches).
(http://www.locoduino.org/pic/IMG_1665.jpg)
Ce genre de shield existe déjà bien entendu mais c'est soit avec des supports ordinaires qui sont encore plus enquiquinant que les breadboards :
(https://cdn.instructables.com/FF7/90GR/I2F21G4V/FF790GRI2F21G4V.LARGE.jpg)
soit limités au 168/328 :
(https://www.elektor.fr/media/catalog/product/cache/3/image/9df78eab33525d08d6e5fb8d27136e95/i/s/isp-shield-for-arduino.jpg)
soit avec un unique support de test avec une myriade de switches pour router les signaux en fonction du type de micro (autant dire que les possibilités de se tromper sont infinies :)) :
(http://www.locoduino.org/pic/451.jpg)
Il existe aussi des versions avec des multiplexeurs qui résolvent le problème des switches mais qui complexifient le système.
Du coup hier soir, j'ai dessiné un shield pour Uno permettant de flasher les x4, x5, 2313, 13, 168 et 328 avec 3 support de test et pas de sélection par switch (si ce n'est placer le micro sur le bon support dans le bons sens et au bon endroit). J'y ai mis aussi un interrupteur permettant de mettre le micro que l'on programme hors tension afin de le mettre et de l'enlever sans débrancher le Uno de l'ordi.
(http://www.locoduino.org/pic/ISPShield.png)
Pour 10 exemplaires (contrainte Electrodragon ou Seeedstudio), j'ai évalué le coût, hors port, soit environ 7€ pièce.
Quelqu'un est tenté ?
| Locoduiniste | | Quantité |
| Thierry | | 1 ou 2 |
| Jean-Luc | | 2 |
| Dominique | | 2 |
| CATPLUS | | 1 |
| bobyAndCo | | 1 |
| msport | | 1 |
| chris_bzg | | 2 |
| Didier44 | | 1 |
| TOTAL | | 11-12 |
C'est bouclé, on est à 12
-
J'en prend un ou deux.
-
J'en prends 2
-
Bonjour
Si toujours dispo je suis preneur de 1
Cordialement
Marcel
-
Bonjour Jean-Luc,
Je suis preneur pour un... et merci pour la proposition.
Bien amicalement
Christophe
-
Bonjour Jean-Luc,
Je suis preneur pour un exemplaire.
Merci
Michel
-
Bonjour, :)
Merci pour votre proposition, mais ayant déjà réalisé un module "universel" (universel pour mes besoins évidement) à partir d'un support de test à 40 broches, je ne vais malheureusement pas vous passer commande.
Par contre, les photos que vous nous montrez ainsi que le schéma de votre shield pour Uno m'interpellent.
En effet, pour réaliser mon module, je me suis basé sur ce que Christian avait écrit et dessiné sur le site Locoduino concernant la procédure de programmation du microcontrôleur ATtiny45 (http://www.locoduino.org/spip.php?article189 (http://www.locoduino.org/spip.php?article189)).
Dans cet arcticle sur Locoduino, à aucun moment il n'est fait mention de condensateur, et j'ai déjà programmé sans problème plusieurs ATtiny45 comme celà.
Sur votre shield, je vois six condensateurs dont un polarisé.
De plus, en regardant le lien que vous avez donné concernant l'ATTinyCore (https://github.com/SpenceKonde/ATTinyCore (https://github.com/SpenceKonde/ATTinyCore)), je lis :To work correctly, these parts should be installed with a 0.1uf capacitor between Vcc and Ground, as close to the chip as possible
Mes questions sont donc les suivantes :
- Quelle est l'utilité de ces condensateurs ?
- Comment doivent-ils être connectés ?
- Quelles sont leur valeur ?
Je ne suis pas du tout électronicien de formation, j'ai fait un peu de programmation dans ma vie, vous m'avez fait découvrir l'électronique programmable et je vous en suis très reconnaissant.
Mon apprentissage se faisant avec vous, c'est donc vous que j'embête avec mes questions ;D et excusez moi par avance si les réponses ont déjà été données par ailleurs.
Bien cordialement.
Jean-Michel
-
Bonjour Jean-Michel
Ça n'est pas une démarche commerciale, juste une proposition de mutualisation de frais.
Les capas CMS jaunes sont effectivement les capas de 0,1µF (100nF) préconisés. Il s'agit de capas de découplage de l'alimentation (https://fr.wikipedia.org/wiki/Condensateur_de_découplage). Le chimique (C4) de 10µF sert de réservoir. Ils sont connectés entre le 5V et GND.
Ces capas servent à lisser les alimentations et à encaisser les appels de courant.
Ça peut marcher (à peu près) sans mais c'est mieux avec ;)
-
Merci pour votre réponse :D
Pour la mutualisation de frais, j'avais bien compris votre proposition dans ce sens, mais j'admets que ma formulation sur ce sujet était un peu maladroite ;)
Jean-Michel
-
Le condensateur de découplage est le remède magique à bien des dysfonctionnements inexplicables. On y pense souvent bien tard, après s'être inventé des causes inexistantes !
-
Bonjour
Voici les schémas de câblage des différents support de test. Pourriez vous les confronter aux différents tuto que l'on trouve sur le web ?
ATMega 168/328
(http://www.locoduino.org/pic/ATTiny/test328.png)
ATTiny 2313, ATTiny 13, ATTiny x5
(http://www.locoduino.org/pic/ATTiny/test2313x5.png)
ATTiny x4
(http://www.locoduino.org/pic/ATTiny/testx4.png)
Et l'Arduino Uno
(http://www.locoduino.org/pic/ATTiny/arduino.png)
-
Pour 10 exemplaires (contrainte Electrodragon ou Seeedstudio), j'ai évalué le coût, hors port, soit environ 7€ pièce.
Quelqu'un est tenté ?
| Locoduiniste | | Quantité |
| Thierry | | 1 ou 2 |
| Jean-Luc | | 2 |
| Dominique | | 2 |
| CATPLUS | | 1 |
| bobyAndCo | | 1 |
| msport | | 1 |
Tu peux me rajouter dans le tableau pour 2 exemplaires.
-
Bonjour,
Merci pour cette proposition.
Tu peux me rajouter également dans le tableau pour 1 exemplaire.
Didier
-
Bonsoir,
C’est donc bouclé. On est à 11 ou 12 exemplaires sachant que chez electrodragon ils en font 12 et éliminent ceux qui sont ratés mais ça ne m’est jamais arrivé et j’ai toujours eu 12 exemplaires.
Les composants sont commandés. Je les reçois demain. J’ai également pris un 328, un 2313 et un 13 afin des tester leur programmation.
Les plus attentifs auront remarqué que le shield fait moins de 60x60. Or La taille possible est de 100x100. Il y a donc de la place pour d’autres design, grosso-modo une carte 100x40 et une 60x40.
Pour ma part, je vais faire une carte, sans doute plus petite que 60x40 avec un 328 en boîtier TQFP32 cadencé à 20MHz, un CH340, un MCP2517 et un 2561 afin de tester une carte compatible Arduino avec du CAN FD.
Il reste donc pas mal de place, si vous avez des idées...
-
La série de cartes est bouclée.
Comme il y a deux cartes à réaliser, c'est mieux chez Seeedstudio. Par conséquent il n'y aura que 10 exemplaires. J'avais mis 2 pour moi mais une me suffit. Thierry avait dit 1 ou 2, ça sera donc une sauf protestation :)
| Locoduiniste | Quantité |
| Thierry | 1 |
| Jean-Luc | 1 |
| Dominique | 2 |
| CATPLUS | 1 |
| bobyAndCo | 1 |
| msport | 1 |
| chris_bzg | 2 |
| Didier44 | 1 |
| TOTAL | 10 |
-
Non, non. Ça me va. :)
-
SlowMotionServo sur ATTiny84 :)
http://locoduino.org/pic/sms/smsattiny84.mp4
-
Bonsoir,
je reprends le fil qui a vu le lancement des PCB.
Donc après avoir monté le shield programmateur et installé celui-ci sur un UNO, j'ai déversé l'exemple :
// ArduinoISP
// Copyright (c) 2008-2011 Randall Bohn
dans ce UNO, avec succès.
J'ai chargé le B.A.L Block Automatique Lumineux de Christian, choisi Programmateur Arduino as ISP. Choisi ATTiny13 Standalone 1.2Mz.
J'ai mis un ATTiny13 sur le socket du milieu, pin 1 collé coté levier, mis la tension (vu le ON), et lancé la vérification.
Ça c'est arrêté avec :
avrdude: Version 6.3, compiled on Jan 17 2017 at 12:00:53
Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
Copyright (c) 2007-2014 Joerg Wunsch
System wide configuration file is "C:\Users\Michel\AppData\Local\Arduino15\packages\arduino\tools\avrdude\6.3.0-arduino9/etc/avrdude.conf"
Une erreur est survenue lors du transfert du croquis
Using Port : usb
Using Programmer : arduinoisp
avrdude: Error: Could not find USBtiny device (0x2341/0x49)
avrdude done. Thank you.
Est-ce du à l'ATTiny13, un problème de communication avec la carte ou un petit détail ?
Thank you.
Très jolis les effets de lumière, mais je les aurais préférés coté Tiny.
-
Je sais pas
Je viens de flasher un ATTiny 13 et ça marche. As tu gravé la « séquence d'initialisation » aka les fusibles ?
C'est un peu capricieux, graver la séquence d'initialisation n'a pu se faire qu'après avoir débranché et re-branché.
-
J'ai négligé ce que je prenais pour un avertissement :
Fichier du bootloader spécifié mais absent: C:\Users\Michel\Documents\Arduino\hardware\attiny13\avr\bootloaders\empty
Le bootloader est spécifique ou non ? Je peux récupérer un pour ATMega ?
De mes précédentes expériences, je pensais qu'il n'y avait pas besoin de bootloader. Je vais aussi tester en parallèle avec un 2e Arduino (un vrai 16U2 ;) ).
Je voulais éviter de rater quelque chose d'évident.
-
Séquence d'initialisation ≠ bootloader
La séquence d'init c'est la programmation des fuses pour la source d'horloge et sa fréquence, le BOD, etc
-
Au moins ça me manque :
Erreur lors de la gravure de la séquence d'initialisation : le paramètre de configuration « bootloader.tool » est manquant.
je vais reprendre le problème.
Mémoire courte : j'avais déjà confondu séquence d'initialisation et bootloader en janvier 2017.
-
Mon package ATtiny13 a du souffrir lors de mises à jour ...
Les ATTiny85 et autres avaient disparus, réinstallation du package de Freeman. Un pas de plus, mais
C:\Users\Michel\AppData\Local\Arduino15\packages\arduino\tools\avrdude\6.3.0-arduino9/bin/avrdude -CC:\Users\Michel\AppData\Local\Arduino15\packages\diy_attiny\hardware\avr\2018.3.11/avrdude.conf -v -pattiny85 -carduinoisp -e -Ulock:w:0xFF:m -Uefuse:w:0xFE:m -Uhfuse:w:0b11011101:m -Ulfuse:w:0xE2:m
avrdude: Version 6.3, compiled on Jan 17 2017 at 12:00:53
Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
Copyright (c) 2007-2014 Joerg Wunsch
System wide configuration file is "C:\Users\Michel\AppData\Local\Arduino15\packages\diy_attiny\hardware\avr\2018.3.11/avrdude.conf"
Erreur lors de la gravure de la séquence d'initialisation.
Using Port : usb
Using Programmer : arduinoisp
avrdude: Error: Could not find USBtiny device (0x2341/0x49)
avrdude done. Thank you.
En fait même message qu'en l'absence de composant sur le support, je vais (re)vérifier mes soudures.
-
En vérifiant les continuités, je constate que je n'ai pas de liaison entre la pin 1 de chaque support et la broche qui va au Reset de l'Arduino.
J'ai bien continuité entre les pins 1 et les soudures qui semblent correctes, par contre, il me manque une continuité (piste) entre les deux supports petit et moyen. Et comme j'ai soudé les yeux fermés sans vérifier le PCB ... si on peut dire.
Je vais insister sur ces points, la métallisation des trous n'assure peut-être pas correctement le contact.
Edit : J'ai insisté : 10s sans résultat, je vais mettre des straps.
Sinon, ça semble OK pour les cinq autres signaux.
-
Le dessin des pistes est le suivant :
(http://www.locoduino.org/pic/ISPShield.png)
En bleu ce sont les piste côté composants, en vert, côté « cuivre »
Les support de test étant soudés le piste du reset est masquée.
Note que sur le petit, le reset est sur la pin 4, pas 1. Les schémas sont plus haut
-
Bonne remarque, je vais faire attention pour les straps.
Edit : Bon, je vérifierai d'abord à partir du typon la prochaine fois, car c'est Ok. Et je cherchais le reset sur le reset de l'Arduino, comme le donne certains schémas. Je teste d'abord en direct avec l'arduino (clone) avant de mobiliser de l'aide à nouveau ...
Edit2 : Finalement le shield était parfait. Simplement deux arduino CH340G réfractaires à la programmation comme ISP.
J'ai retrouvé celui (CH340G aussi) qui m'avait permis de faire mes premiers essais réussis il y a plus d'un an, et là, gravure sur ATTiny13 de la séquence d'initialisation plus petit programme chenillard sans souci.
Désolé de ne pas avoir commencé par là. Et pas de 16U2 en magasin.
Donc problème résolu.
-
Bonjour,
en complément à ce shield, il existe des adaptateurs pour les boitiers CMS tels que :
https://www.ebay.fr/itm/SOP8-to-DIP8-Wide-body-Seat-Wide-200mil-Programmer-Adapter-Socket/182470081376 pour les 8 pattes
attention les narrow (150 mil) sont trop étroits.
et
https://www.ebay.fr/itm/SOP8-to-DIP8-PLCC32-to-DIP32-Socket-Adapter-Converter-Programmer-IC-Test-Socket/382167093948 pour les 16 pattes
choix SOP16 to DIP8 300mil
je ne les ai pas encore reçus, donc je ne peux pas encore valider qu'ils conviennent en largeur et en connectique.
Peut-être les avez vous déjà expérimentés ?
Utile si le connecteur ISP n'a pas été prévu et si vous n'avez pas encore soudé le composant.
-
Bonjour
En complément du post de Michel
http://forum.locoduino.org/index.php?topic=601.msg6788#msg6788
Quelques copies d'écran et mon pense bête pour programmer les Digispark
Marcel
-
Bonjour
Reste t il dispo un bouclier de prog multi devices?
Je serai preneur d un exemplaire.
Pour ma part j ai réalise un bouclier pour le 328 soit en format DIP28 soit TQFP32 via adpatateur ( soit a 32 broches soit a 28 broches)
Avis au amateurs...
Laurent
-
Bonjour,
Non, mais je peux fournir les Gerber.
Si d'autres personnes sont intéressées, l'une d'entre elle peut commander et distribuer.
-
Bonsoir
Je suis preneur je lancerai un lot de pcb avec d autres commandes que je dois lancer aussi très bientôt
D avance merci
Laurent
-
Voici :)
-
Merci
Pour R1 à R4 tu mets combien? 1K?
Laurent
-
Bonjour,
Oui 1k c'est très bien
L'interrupteur est celui ci : https://www.tme.eu/fr/details/esp2010/commutateurs-a-glissiere/ece/
-
Hello
Son role est de mettre OFF avant extraction/ et ON avant insertion je presume?
-
C'est ça
-
Bonsoir,
J'ai acheté une carte ATtiny85 (pas Digispark) équipée d'une prise microUSB.
J'ai chargé l'ATtiny 85 dans l'IDE ARDUINO.
Le port reste grisé.
Il doit à priori manquer le driver pour brancher cette carte directement sur le PC.
Je n'arrive pas à trouver un driver USB pour ATtiny, s'il existe !
Merci
-
Bonjour,
j'imagine que même si la carte n'est pas une Digispark (nombreux clones), le driver (qui n'est pas basé sur le même principe que celui des Arduino via l'IDE) doit fonctionner de la même manière : donc à tester comme décrit là :
http://forum.locoduino.org/index.php?topic=601.msg8169#msg8169
-
Merci.
J'ai suivi la procédure, mais le port est toujours grisé.
De plus, le son correspondant à l'introduction d'une clef USB se déclenche tout le temps
(en même temps que le gestionnaire de périphérique qui fait une RAZ).
Je n'ai qu'un seul port com (USB-SERIAL CH340 (COM6)) qui doit, je pense, servir pour un arduino.
-
Redisons qu'il n'y a pas de port Arduino dans l'IDE pour ces cartes.
Avez vous installé ces cartes via http://digistump.com/package_digistump_index.json (dans Préférences puis Gestionnaire de cartes) ?
Il faut lancer DPinst64.exe directement (et non via les .bat qui plantent) pour un système x64.
Le driver n'apparait que dans les périphériques cachés du gestionnaire de périphériques en tant que "libusb-win32 devices"
Et vous n'avez pas noté qu'il ne faut connecter la "clé USB" qu'après la compilation quand l'IDE vous le demande.
-
Ok, j'ai repris la procédure avec :
Carte débranchée
Programmateur : USBasp
Type de carte : Digispark (Default-16,5 mhz)
puis vérifier/compiler
puis téléverser
Attente du message :
Running Digispark Uploader...
Plug in device now... (will timeout in 60 seconds)
> Please plug in the device ...
-> Branchement carte ATtiny sur USB
Résultat :
> Starting the user app ...
running: 100% complete
>> Micronucleus done. Thank you!
Le résultat est-il correcte d'un point de vue mise en œuvre ATtiny ?
Je n'ai pas encore brancher de leds.
Nota : le port est toujours grisé dans l'IDE
-
... correct d'un point de vue mise en œuvre ATtiny ?
oui, en interface USB du topic 601 (et pas en programmation directe comme décrit dans ce fil)
Nota : le port est toujours grisé dans l'IDE
Et le restera dans cette configuration.
-
Ok, merci.
En fait, j’espérais pouvoir monter facilement un décodeur à base d'ATtiny85 dans une petite locomotive (type 030) à l'échelle 0 (un forumer fcot2002 semble intéressé).
Il est nécessaire d'ajouter à l'ATtiny :
- une interface opto-électronique pour récupérer le signal voie DCC
- une carte Alim -> 7805
- un pont en H
- des leds
- du fil, du fil . . .
Problème : avec la bibliothèque NmraDcc et avec un ATtiny85, il manque 82Bytes !
Il est peut-être possible de simplifier le programme : https://github.com/mrrwa/NmraDcc/tree/master/examples
-> NmraDccMultiFunctionMotorDecoder - added another example of s simple DCC Multifunction (Locomotive) decoder- last month
Personnellement, je travaille en échelle 1 (Märklin) voir échelle 0.
Je continue mon projet de 2D2 5500 (1 Arduino Nano + 1 Teensy 3.2 + EEprom pour le son) +
- une interface opto-électronique pour récupérer le signal voie DCC
- une carte Alim -> 7805
- un pont en H
- des leds
- un ampli audio
- un haut-parleur
- un paquet de fil
Dans une 030 Märklin Echelle 1, cela rentre déjà au chausse-pied !
-
Ok, j'ai repris la procédure avec :
Carte débranchée
Programmateur : USBasp
Type de carte : Digispark (Default-16,5 mhz)
puis vérifier/compiler
puis téléverser
Attente du message :
Running Digispark Uploader...
Plug in device now... (will timeout in 60 seconds)
> Please plug in the device ...
-> Branchement carte ATtiny sur USB
Résultat :
> Starting the user app ...
running: 100% complete
>> Micronucleus done. Thank you!
Le résultat est-il correcte d'un point de vue mise en œuvre ATtiny ?
Je n'ai pas encore brancher de leds.
Nota : le port est toujours grisé dans l'IDE
Donc,si je comprends bien, pas de port COM donc pas de moniteur série.
Comment faire pour debugger à part utiliser un Arduino pour debugger.
Puis, lorsque le programme est au point, "vérifier et compiler" sur ATtiny, puis téléversersur l'ATtiny.
-
Donc,si je comprends bien, pas de port COM donc pas de moniteur série.
Comment faire pour debugger à part utiliser un Arduino pour debugger.
Puis, lorsque le programme est au point, "vérifier et compiler" sur ATtiny, puis téléversersur l'ATtiny.
Les cartes Digistump à base d'ATtiny85 sont équipées d'un port USB qui ne fonctionnent pas comme les autres Arduino.
Le port USB est paramètré comme un USB HID (Human Interface Device, c.à.d comme un clavier ou une souris) et c'est donc normal qu'il n'apparaisse pas dans la liste des ports (série) de l'IDE. Donc le moniteur de l'IDE ne peut pas fonctionner comme d'habitude
J'ai trouvé ceci sur le site de digistump : http://digistump.com/board/index.php/topic,2375.msg11196.html#msg11196 (http://digistump.com/board/index.php/topic,2375.msg11196.html#msg11196)
#include <DigiUSB.h>
void setup() {
// put your setup code here, to run once:
DigiUSB.begin();
}
void loop() {
// put your main code here, to run repeatedly:
/* Check USB is still working */
if(DigiUSB.available()) /* Just hit "Enter" in the digiterm to check USB */
{
DigiUSB.read(); /* just to clear the Rx buffer */
DigiUSB.println(F("DigiUSB is still alive!"));
}
DigiUSB.refresh();
delay(100);
}
Cela se compile bien avec la bibliothèque digiUSB.h.
Maintenant je n'ai pas testé ce code n'ayant pas de carte sous la main, ni de Windows.
Cela nécessite sans doute un émulateur de terminal comme digiterm :
# digiterm
Looking for Digispark running DigiUSB...
Attached to <Digispark:DigiUSB:@5.29>
Type control + c to exit
DigiUSB is still alive!
^C
Vous trouverez certainement une réponse complète sur le site http://digistump.com/board/ (http://digistump.com/board/)
-
En cherchant un peu, la solution la plus récente est là :
https://digistump.com/wiki/digispark/tutorials/digicdc (https://digistump.com/wiki/digispark/tutorials/digicdc)
Ce n’est pas DigiUSB mais DigiCDC qu’il faut utiliser. Il y a au moins un exemple (DigisparkCDC) disponible dans l’IDE.
You must explicitly include the DigiCDC library - by placing the following at the top of your sketch
#include <DigiCDC.h>
It uses a lot of RAM - half of the Digispark's RAM - so only include it when needed and watch your RAM usage. You can wrap strings in F() (ie. SerialUSB.print(F(“test”)) ) to put the string in flash memory instead of RAM
You use it the same as Serial on an Arduino but with SerialUSB instead (ie. SerialUSB.read() instead of Serial.read() ) - The Pro also has Serial defined - but that refers to the hardware Serial port on Pins 6 and 7.
The begin statement does not need a baudrate - it is a CDC device so it does not have a set baud rate - just use SerialUSB.begin()
You must install the driver for windows - it is part of the driver package found in the Digispark Arduino release.
It is slow - it transfers data very slowly (5ms per character) - because it is a low speed USB device doing the job of a Standard speed device - and doing it all virtually without actual hardware support!
Like all of our V-USB libraries you must use its delay function instead of delay() - so use SerialUSB.delay() when you need a delay in your code.
SerialUSB.delay() or SerialUSB.refresh() must be called every 10ms or less in your code if no other SerialUSB call is made in that code
-
Bonjour,
Quelques photos, en espérant que cela puisse aider
-
Merci.
You must install the driver for windows - it is part of the driver package found in the Digispark Arduino release.
Dans le répertoire "Digistump Drivers"
c'est quel driver ?
- Install Drivers
- DPinst64
- Launcher
- micronucleus
-
Bonjour,
Je veux bien me joindre à la prochaine commande de programmateur ISP... ;D
(http://www.locoduino.org/pic/batch/IMG_1731.jpg)
Bravo pour ce shield qui me semble très pratique...
Toujours dans le monde Attiny, un site concernant le modélisme bateau, mais le besoin de place est également une contrainte.
http://bateaux.trucs.free.fr/ageneral.html (http://bateaux.trucs.free.fr/ageneral.html)
La section microprocesseur
Merci et bon confinement
Yannick
-
Le schéma du programmateur n'étant pas très compliqué, il est possible de s'en faire un avec un shield prototype et les supports ziff. Bien sur, moins pratique.
https://www.ebay.fr/itm/Proto-Screw-Shield-Board-For-Arduino-A6-A7-Compatible-Improved-version-support/282100794216
https://www.ebay.fr/itm/20-Pin-Universal-Zif-Dip-Tester-Test-Socket-mf/113187241012
https://www.ebay.fr/itm/14-Pin-Universal-Zif-Dip-Tester-Test-Socket-mx/113185314673
https://www.ebay.fr/itm/2-Pcs-New-ZIF-28-pin-28-Pins-Test-Universal-IC-Socket-NEW/192175032674
-
Bonjour,
Je peux mettre les fichiers Gerber + les références des composants (si ce n'est pas déjà fait, je ne m'en souviens plus) en téléchargement sur ce fil de discussion. À la charge des gens motivés d'organiser une commande groupée (5 ex à 1€85 + 11€ de port chez JLCPCB + le port de répartition).
-
Bjr,
Merci pour les réponses.
Oui Jean-Luc, les fichiers sont à la page 11, réponse 156 ;)
Carte et liste du matériel
L’idée est plutôt de ne pas commander 12 cartes par personne, mais de centraliser les candidats ;D
Yannick
-
Ouvre un nouveau sujet et je l'épingle. :)
-
L'idée du partage est sympathique.
En temps normal (hors confinement) le port chez jlcpcb pour 5 pièces est de 4,16€ (9,15€ actuellement) et les 5 cartes 1,74€. Soit 2,20€ pièce aujourd’hui, 1,20€ demain (le 11/5)
Le timbre écologique étant en France à 0,97€ x n, c'est peut-être avec les supports ZIF et autres composants que cela peut être intéressant. Peut-être avec un UNO qui serait programmé à demeure.
Nota, je suis équipé, fonctionnement irréprochable, montage simple.
-
Tu as sans doute raison, il est urgent d’attendre.
Je garde mon montage pour le moment et regarderai dans 1-2 mois...
Merci du conseil
Yannick
-
Bonsoir
Depuis un certain temps, je n'arrivai plus à programmer les Attiny type Digispark.
En cherchant j'ai retrouvé ce site (en anglais) qui devrait vous aider à sortir de cette galère.
Perte des drivers
https://digistump.com/board/index.php?topic=2479.0
https://www.youtube.com/watch?v=MmDBvgrYGZs
Cordialement
-
Oui, ça été signalé dans le message ci-dessous. Mais ça mérite quelques précisions ...
http://forum.locoduino.org/index.php?topic=601.msg6783#msg6783
-
Bonjour
Avant propos
Le Railcom => transfert d'informations DCC entre le décodeur et la centrale, dans les 2 sens "lecture, écriture"
Tous les décodeurs du marché ne sont pas compatibles avec cette norme.
Ma question?
Pourrais-t-on utiliser un Attiny85 et de l'utiliser comme Railcom: je m'explique.
Programmer un signal carré de différente largeur (0 & 1).
L'idée serait de transformer le dit signal en lecture "Ex: Identifiant de la Machine" & le lire dans un Arduino (Ecran, Lcd, etc...)
Il est petit (surtout en CMS), facilement intégrable dans les échelles au-dessus du N (quoi que ?)
Ce montage serait un aditif branché en parallèle avec le décodeur de la loco
Il y a UNE INCONNUE, ce signal serait-il compatible avec le DCC?
https://skyduino.wordpress.com/2012/06/14/attiny-generateur-de-signaux-dds-dac-software/
http://www.train35.fr/dcc4.html
https://forum.arduino.cc/t/resolue-generation-dun-signal-carre-par-une-arduino-mega/478522/7
A suivre
En rapport avec el lien
http://forum.locoduino.org/index.php?topic=1252.0
Cordialement
-
Bonjour Marcel,
Le problème, avec le DCC, est que la centrale émet des 0 et des 1 en permanence dans le seul sens centrale -> locos. Il n'y a pas d'alternat : émission-réception (comme en wifi ou en série ou en Can..).
Railcom oblige la centrale (ou plutôt le booster local) de stopper les émissions DCC un bref instant (le CutOut) pour permettre au décodeur de placer son message. C'est un peu tordu comme méthode. Il aurait mieux valu faire un signal DCC bidirectionnel, mais au prix d'une perte de débit qui ne serait pas négligeable.
La meilleure méthode serait que les décodeurs puissent poster leurs messages en wifi ou BT, mais avec des risques de contention (collisions entre plusieurs messages).
La solution du pilotage intégral par radio (sujet développé par Gboule et Christophe : http://forum.locoduino.org/index.php?topic=1252.0 (http://forum.locoduino.org/index.php?topic=1252.0)) est particulièrement élégante, mais trop gros pour le N.
Mais la suggestion est excellente, il y a tellement de réalisations à base de BTLE que ce doit être accessible, même kau N.
A cogiter dar dar...
-
Bonjour,
on n'a pas prévu que LaBox implémente Railcom pour l'instant. Ce sera certainement pour quand on aura résolu les problèmes actuels.
Coté décodeurs, vu le mal qu'on a à implanter un décodeur de taille adapté à chaque échelle, il me semble qu'il vaut mieux choisir les décodeurs qui ont la fonction Railcom d'origine (LENZ, ESU, Uhlenbrock, Tams Elektronik)
Mais la NMRA a intégré le standard de Lenz comme sous-norme (la s-9.3.2), un challenge à relever.
-
Bonjour
Suite au post de PETER41
http://forum.locoduino.org/index.php?topic=1506.msg16269#msg16269
J'ai fait ce circuit pour Digispark 85 (fabrication Eric) Non compatible DCC.
Commande 3 Feux, composants CMS (il me reste des circuits, si vous en voulez me contacter en MP)