Attention : nouvelle adresse mail depuis novembre 2017. Ne plus utiliser l'ancienne hébergée chez Yahoo!

mercredi 29 novembre 2017

RETRO-COMPUTING, Minipro TL866A

Petite information que je pense pouvoir être utile à ceux qui, comme moi, travaillent à l'occasion sur des anciennes machines équipées de composants programmables du type GAL.

Se procurer un programmateur de type professionnel est la plupart du temps d'un prix disproportionné par rapport au besoin. S'il est encore relativement aisé de se procurer un programmateur d'UVPROM digne de ce nom à pris correct, il n'en va pas du tout de même pour ces composants de type GAL.

Je possède depuis un peu plus d'un an ce type de programmateur assez connu qu'est le Genius 540 :


 Soyons clair : il est à déconseiller fortement. Plusieurs raisons à cela.

  • Le logiciel n'est plus mis à jour depuis longtemps.
  • Il ne fonctionne à peu près bien qu'avec des PC relativement lents.
  • La programmation des GAL plante lamentablement.
Je pense d'ailleurs que le protocole de communication USB n'est pas fonctionnel, ce qui a pour effet j'imagine, de ne pas respecter les temporisations minimum pour la programmation lorsque le PC est en mesure de délivrer trop rapidement les données. En ce qui me concerne, je n'arrive à programmer les UVPROM standards que sur un PC portable de dix ans d'âge. J'ai essayé sur trois autres machines plus récentes en obtenant un pourcentage d'erreur de programmation de plus de 90%. Et bien entendu la programmation de GAL plante, même sur le portable avec lequel cela se passe le mieux.

Après avoir lu un bon nombre de commentaires à son sujet, j'ai fini par adopter le 'fameux' Minipro TL866A pour une soixantaine d'Euros. 


A ce prix-là, il est intéressant de tenter le coup. Je n'ai pas encore testé la programmation d'UVPROM, mais je peux déjà indiquer que la programmation de GAL se passe effectivement très bien : 


Le message est clair. De plus, et de ce que j'ai pu constater, le fonctionnement en liaison avec le PC semble beaucoup moins hésitant qu'avec le Genius. J'ai lu par ailleurs que la programmation des GAL était fonctionnelle depuis la version 6.5 du logiciel. J'ai installé la version 6.60 disponible ici et ai pu constater le bon fonctionnement de la programmation d'une GAL de marque Lattice 16V8A.



L'objectif de cet achat, outre le fait de pouvoir travailler sur d'anciens équipements, était d'être en mesure de mettre à jour les fonctionnalités du Kit à Z80 de Wichit Sirichote


pour le rendre compatible avec le µPF--1 : 


qui, à la base, ressemblait à ceci : 


L'objectif est donc presque atteint. Il me reste à programmer une ROM avec le nouvel interpréteur de commande compatible µPF1 et ce sera chose faite.

Et donc, à moins que je rencontre des problèmes dans mes futurs opérations avec ce TL866A, je conseille fortement ce programmateur qui semble se comporter de façon correcte et dont le logiciel PC d'exploitation est toujours mis à niveau.

01 décembre 2017 : voilà la chose faite! Avec ce Minipro TL866A, j'ai pu programmer sans difficulté une nouvelle mémoire de type AM27C256 avec le nouvel interpréteur de commande créé par Wichit Sirichote :



Avec la GAL16V8A précédemment programmée par ce même TL866A, voici le résultat final :


Et de plus près :


Ce kit de développement est tout autre chose que la plateforme Arduino, l'approche est plus 'Hold Style' mais aussi plus fidèle à l'Esprit d'origine de la micro-informatique. Avec un bon compilateur SDCC, il devient de fait très facile d'expérimenter l'assembleur, même en ligne dans du source 'C'. Le connecteur présent sur la carte permet en outre bon nombre d'extensions. Donc, pour qui souhaite se familiariser au fonctionnement de base du microprocesseur, avec des circuits simples à comprendre et à programmer, ce type de kit est idéal.

Concernant le programmateur TL866A : durant son utilisation, j'ai pu constater que lors d'un chargement de fichier HEX dont une adresse se situe en dehors de la capacité d'adressage du composant sélectionné, le programme indique clairement le problème. Ce qui n'est pas le cas du programme du Genius 540. De même, l'application du TL866A retrouve et affiche les 'ID's des composants placés sur le support de programmation et en effectue la comparaison avec celle sélectionnée dans l'interface graphique. En cas d'erreur, le problème est signalé et permet donc d'éviter de détruire un composant avec une tension de programmation inappropriée, ce qui n'est pas le cas avec le G540. Je n'ai pas testé pléthore de composants avec ce TL866A mais au moins les opérations effectuées se sont toutes déroulées à leur terme, sans problème ni ambiguïté, ce qui n'est évidemment pas du tout le cas du G540 : c'est définitivement dit!

A noter que Wichit Sirichote propose nombre de kit de ce type basés sur différents processeurs dont le fameux 6502 ayant équipé l'Apple I et la famille des Apple ][. La description de ce kit peut être trouvée ici. La page générale de Wichit se trouvant à cet endroit : http://www.kswichit.com, et la disponibilité de tous ces matériels sur eBay...

Bonnes expérimentations.


mardi 28 novembre 2017

Changement d'adresse mail de contact.

Parce qu'à un moment il faut quand même se résoudre à quitter le service mail de Yahoo pour quelque chose d'un peu plus efficace, j'ai donc ouvert une nouvelle boîte mail chez netcourrier.com :





lundi 6 novembre 2017

JX10P, MKS70...

Ceci n'est pas un article à proprement parlé mais juste un petit 'pense bête' concernant le synthétiseur Roland JX10P : 




J'ai eu l'occasion par le passé, de m'intéresser à cette machine lors de la remise en état de l'exemplaire que je possède, et force est de constater qu'il y a aujourd'hui un bon nombre de nouvelles améliorations disponibles. Elles sont assez bien résumées sur cette page, que je mets donc en référence http://super-jx.com :

http://super-jx.com

ou ici pour les dernières nouveautés JX10P News.

RETROAKTIV PG-800 MINI Bare PCB & Overlay Kit for JX-8P & Super JX :


samedi 21 octobre 2017

Ecran tactile pour PLC. Episode 2

Après la réalisation matérielle de ce type de projet, et les inévitables séances de débogage, vient le temps de la programmation. A noter que ce montage simple n'a présenté aucun défaut de conception, si ce n'est un petit souci que j'évoquerai plus bas.

Je n'ai pas souhaité rendre ce montage compatible Arduino, c'est donc avec l'outil d'Atmel, Studio 7, et le programmateur AVR Dragon que j'ai effectué la totalité la programmation. Rien de bien compliqué ici sachant que son rôle consiste 'juste' à transmettre des données reçues en RS485 avec une vitesse de 2400 à 115200 Bauds, à un écran 'intelligent' réglé à une vitesse de communication de 115200 Bauds. Le gros principe de l'application étant juste la gestion de buffers circulaires de mise en tampon des donnés.

Les premiers test ce sont effectué en situation presque réelle :


Un écran intelligent est connecté sur le module de conversion de vitesse et de type d'interface, ce module étant relié en RS485 à un automate Controllino. L'automate est alimenté par son port USB directement sur le PC de développement. Le module de conversion et l'écran sont reliés à une alimentation de 12V.


Le bouton de droite 115200 permet de configurer la vitesse de communication de l'écran à 115200 Bauds. Le bouton Display... permet d'afficher la valeur en cours du Baud rate. Plusieurs informations en provenance de l'automate en 19200 Bauds sont retransmises à l'afficheur en 115200 Bauds. Il s'agit de l'heure et de la date qui sont transmises au début de l'application, puis de la valeur de comptage qui est simplement incrémentée dans la boucle principale du programme de l'automate :

#include <Controllino.h>

  int ledPin = 13;
  unsigned char Buffer[32];
  unsigned char EndBuffer[] = {0xFF, 0xFF, 0xFF, 0x00};
  unsigned char NumberBuffer[8];
  unsigned int  NumberTest = 0;

void setup() {
 
  DDRJ = DDRJ | B01100000;
  PORTJ = PORTJ & B10011111;
  PORTJ = PORTJ | B01000000;
  pinMode(ledPin, OUTPUT);
  Serial.begin(19200);
  Serial3.begin(19200);
  strcpy(Buffer, "rtc3=17");
  strcat(Buffer, EndBuffer);
  Serial3.print((char *)Buffer);
  strcpy(Buffer, "rtc4=36");
  strcat(Buffer, EndBuffer);
  Serial3.print((char *)Buffer);
  strcpy(Buffer, "rtc5=00");
  strcat(Buffer, EndBuffer);
  Serial3.print((char *)Buffer);
  strcpy(Buffer, "rtc2=21");
  strcat(Buffer, EndBuffer);
  Serial3.print((char *)Buffer);
  strcpy(Buffer, "rtc1=10");
  strcat(Buffer, EndBuffer);
  Serial3.print((char *)Buffer);
}

void loop() {

  delay(1000);
  digitalWrite(ledPin, HIGH);
  strcpy(Buffer, "n6.val=");
  itoa(NumberTest++, NumberBuffer, 10);
  strcat(Buffer, NumberBuffer);
  strcat(Buffer, EndBuffer);
  Serial3.print((char *)Buffer);
  Serial.print((char *)Buffer);
  delay(1000);
  digitalWrite(ledPin, LOW);
}

Programme de test réalisé sans aucune volonté de perfection...

Les instructions
DDRJ = DDRJ | B01100000;
PORTJ = PORTJ & B10011111;
PORTJ = PORTJ | B01000000;
servent 'juste' à configurer les pattes /RE et DE du tranceiver interne du Controllino afin que les données émises sur le port série n°3 partent bien en RS485.
La variable EndBuffer initialisée à {0xFF, 0xFF, 0xFF, 0x00} est obligatoire car toute instruction transmise à l'écran doit se terminer de la sorte. Les différentes variables rtcx correspondent à l'initialisation des différentes variables de l'heure et de la date qui sont mises à jour automatiquement par l'afficheur lui-même. Enfin n6, correspond à la variable affichée au milieu de l'écran, mise à jour toutes les secondes par l'automate.

Les premiers tests s'avèrent concluants. Même avec une communication RS485 en 2400 Bauds, l'écran répond correctement en 115200 Bauds. Ne connaissant pas la façon dont est effectué la gestion de la communication série au sein de l'écran, il était en effet possible qu'un time-out un peu trop 'serré' à la réception de caractères empêche ce dernier de considérer une trame correcte,  valide. Mais il n'en est rien, à ma grande satisfaction.

Que reste-t-il à faire? D'un point de vue programmation, il reste à gérer la manipulation en temps réel du bloc de switchs afin de configurer le ports série du processeur qui gère le port série RS485 en temps réel.

D'un point de vue matériel, la partie alimentation à découpage implémentée sur cette carte d'interface est un peu trop juste pour l'écran de 7". La puissance demandée par les écrans de taille inférieur ne pose pas de problème au régulateur à découpage, mais le 7", avec ses 500mA de consommation, arrive en limite de ce qu'est capable de débiter l'alimentation. Dans ce cas, le régulateur ainsi que la self montent déjà un peu trop en température. Il faudra donc envisager une solution d'alimentation un peu plus cossue.

26 octobre 2017 : Après avoir implémenté la gestion des erreurs de communication, l'heure du bilan à sonné. Un peu de la même façon que ce qui est arrivé avec le switch MIDI (qu'il faut que je continue de développer d'ailleurs) et le processeur PIC utilisé au départ, puis remplacé par la suite par un processeur ARM de chez ST, je vais étudier une nouvelle version équipée elle aussi d'un processeur ARM de ST.

La raison principale de ce choix est, la aussi, un manque de flexibilité des processeurs de type ATmega. Sur ces derniers, il est difficile d'effectuer un débogage en temps réel. Or, avec le peu de temps dont je dispose pour mes développements, il m'arrive souvent de tester des petits bouts de code sur un montage laissé de côté depuis un certain temps. Ne me souvenant plus de tous les détails, il devient alors compliqué de comprendre la raison du non fonctionnement du code en test.
Pouvoir jeter un œil sur un registre devient alors primordial. Et puis l'IDE Atmel est lourd, vraiment trop lourd. Installer des centaines de méga pour du processeur 8 bits... Allez donc voir ce que propose Zilog depuis des décennies avec le ZDSII. Si seulement Zilog avait eu la bonne idée de rajouter un peu de RAM dans ses micro-contrôleurs. Mais ceci est une autre histoire.....

Je vais aussi en profiter pour améliorer un peu le concept de cette carte en y ajoutant quelques fonctionnalités qui me semblent intéressantes afin de la rendre un peu plus versatile que ce qu'elle est aujourd'hui. Un port RS232 me semble une option valable. Il y a en effet quantité de matériels 'anciens' qui fonctionnent avec ce type d'interface. Pouvoir les passer en 485 opto-isolé me semble être une bonne idée.

A suivre... 

01 décembre 2017 : après avoir cherché des solutions d'alimentations à découpage qui ne soient pas trop complexes à implémenter sur une petite carte, d'un prix 'acceptable' et d'une capacité en courant suffisante, j'ai décidé de tester une solution à base de LM2596. Pour effectuer des tests sans avoir à développer quoi que ce soit, j'ai acquis sur eBay quelques modules de ce type pour quelques Euros :


Ce qui est intéressant avec ce type de module, c'est qu'en plus de la plage de tension d'entrée qui peut monter à 40V, la sortie réglable de quelques volts à plus de 30V sous 3A max permet de s'en servir en petite alimentation d'appoint pour effectuer quelques tests. A noter que ce type d'alimentation ne peut guère servir en alimentation définitive sur du long terme vu le type et la qualité des condensateurs chimiques.

Et à propose de test, j'ai pu vérifier le fonctionnement correct de l'écran tactile en version grand format de 7 pouces :



Après une petite heure de fonctionnement, les éléments du module d'alimentation sont à peine tiède pour un débit d'environ 500mA, ce qui me semble plus pertinent comme solution que celle adoptée en premier lieu sur ma carte de développement. Je vais quand même sortir l'oscilloscope pour vérifier à minima l'allure de l'alimentation ainsi que son bruit.


mercredi 11 octobre 2017

PC : les ventes baissent toujours.

Ah, il est vraiment fini le temps ou l'ordinateur représentait un potentiel de développement et de créativité personnel. Les machines à publicité qui nous sont vendues aujourd'hui, ne servent finalement qu'à faire du Minitel évolué ou à faire fonctionner des applications de gestion globalement mal développées. C'est sur, le PC n'a plus la côte!

Je n'ai pas demandé l'autorisation à Reuters...
Il y a quelques années encore, l'arrivée d'un Linux un peu plus ergonomique, notamment avec l'initiative Ubuntu (Canonical), aurait pu faire penser à du mieux. Hélas, depuis 10 ans, que dire de l'évolution de Linux pour PC. A se demander si des 'taupes' de Microsoft ne travaillent pas chez les contributeurs de Linux pour l'empêcher d'évoluer vers un 'vrai' système pour les utilisateurs.

C'est sans doute une des raisons de l'engouement actuel pour le rétro-computing. Elles étaient finalement sympa ces petites machines qui permettaient de créer plein d'applications, soi-même, sans grandes connaissances en programmation.

mardi 3 octobre 2017

Ecran tactile pour PLC.

Depuis presque deux ans maintenant, j'utilise des écrans tactiles fabriqués en Chine, qui ont l'avantage par rapport à d'autres solutions, d'être très facilement programmable. Cependant ce type d'écran présentait plusieurs problèmes. Les premières versions ne disposaient pas de l'heure sauvegardée. Le tactile était de type résistif, donc assez peu pratique à manipuler, ou en tout cas interdisant les objets affichés de petite taille. Récemment, le fabricant à amélioré le sujet en proposant plus spécialement un écran de 7 pouces, de type capacitif, avec heure temps réel sauvegardée, présenté dans un boitier qui n'est pas inélégant :


Reste quand même quelques caractéristiques techniques qui contraignent un peu l'utilisation de ce type d'écran. La première contrainte concerne l'interface de communication qui se trouve être exclusivement de type TTL 5V. Il est donc impossible de raccorder ce type d'écran directement à un PLC, notamment par l'intermédiaire d'une interface standard RS485.

Le deuxième problème vient de la façon dont réagit cet écran, et notamment du format des informations bidirectionnelles. Elles ne répondent à aucun format standard comme le protocole Modbus par exemple, et est totalement propriétaire.

Dans quel cas utiliser ce type d'écran alors? Dans un premier temps il est tout à fait possible d'envisager une connexion à un automate de type Controllino :


Ce type d'automate se laisse facilement programmer en langage 'C', et est donc tout à fait capable de gérer directement des chaines de caractères, dialecte utilisé par l'écran. Ce type de configuration est particulièrement adaptée à l'automatisation et/ou le contrôle d'habitations ou de petits bâtiments. Que manque-t-il alors pour connecter ces deux appareils? Tout simplement une interface de communication de type TTL/RS485.

Le problème étant posé, il est dès lors assez simple d'établir les besoins minimum pour l'interface à réaliser :

- Le premier sera de convertir la nature des signaux série TTL/RS485.
- Le deuxième consiste à en profiter pour permettre l'adaptation de la vitesse de communication.
- Le troisième : fournir une alimentation régulée et relativement généraliste pour permettre une alimentation sans véritable contrainte.

Les solutions adoptées :

- Utilisation d'un convertisseur dédié permettant l'isolation du bus RS485.
- Utilisation d'un processeur offrant une adaptation simple de la vitesse de communication par rapport aux contraintes du terrain, sans avoir à reprogrammer l'écran.
- Utilisation d'une alimentation à découpage interne (7 à 26V en entrée), en mesure de fournir l'alimentation à l'écran ainsi qu'à la carte d'adaptation.

Et cela se présente comment?
Comme ceci :
Carte prototype
Il s'agit d'une carte prototype ou les composants sont soudés à la main, raison pour laquelle le design est très aéré. Un produit industrialisé devrait pouvoir occuper à peine la moitié de la surface actuelle.

Il y a un peu plus d'un an, j'avais réalisé le même type de carte, de plus compatible Arduino, dont l'avantage était d'être programmable, mais l'inconvénient, donc, de devoir être programmée par l'utilisateur :


Dans cette nouvelle version, le programme sera développé directement avec l'outil Atmel (Microchip maintenant), et gravé une fois pour toute dans la puce.

Il ne reste plus qu'à effectuer le travail de programmation de la nouvelle carte, et à tester le tout avec l'écran et l'automate Controllino.

A suivre...

jeudi 21 septembre 2017

AMIGA32

Le cas Amiga : je me souviens qu'au début des années 1990 il m'arrivait d'acheter une revue dont les sujets principaux étaient les systèmes informatiques dits 'alternatifs', qui avaient fait le bonheur de ma génération jusqu'à ce que le terrible PC écrase tout. Dans cette revue on y parlait de machines comme la série Next, de systèmes comme le BeOS, et évidemment des errements de la marque Amiga.



J'ai du cesser de rêver à ces machines accessibles vers 1993 lorsque que la saga Commodore fût définitivement morte. De toute ces belles (et parfois de vraiment moins belles) machines de la décennie 80, il ne reste plus aujourd'hui beaucoup de sujets actifs. Il existe bien quelques recréations de ZX80-ZX81, de Spectrum, de MSX le plus souvent en FPGA, mais pas grand chose de plus.

Des deux ordinateurs 13/32 bits de l'époque l'Atari ST eût sa petite heure de gloire à la fin des années 2000 avec la machine Suska, dont le firmware est toujours mis à jour :

https://www.experiment-s.de/en/boards/suska-iii-t/

Et plus actuellement le M.I.S.T. que je possède et qui fonctionne très bien, édité par LOTHAREK :

http://lotharek.pl/product.php?pid=186
Ces deux machines fonctionnent avec des émulation du processeur d'origine, à savoir un 680x0 quelconque et la majorité des périphériques, à l'intérieur d'un FPGA. La compatibilité avec le matériel d'origine est alors très élevée.

Une autre voie a été prise par le projet FireBee, débuté en 2008, qui a consisté à créer une machine 'compatible' avec l'Atari d'origine, en partant d'un processeur ColdFire MCF5474 capable d'émuler les instructions du 68000 d'origine, mais en impliquant quand même de grosses modifications logicielles :

http://firebee.org/fb-bin/index?lng=FR

J'ai pu assister à une démonstration de cette machine grâce à Vincent Rivière, développeur logiciel de la machine, qui en possédait un exemplaire. J'avais été très impressionné par le travail effectué. La machine est relativement chère et la partie soft est toujours activement en cours de développement. Il s'agit donc plus d'une machine pour gros passionnés de la programmation que d'un matériel apte à rendre de suite quelques services.

Ce sont les trois machines que je considère comme actuelles, naviguant dans la sphère de l'ancien ATARI ST.

Et à propos de l'Amiga? J'ai bien entendu parler des machines crées dans les années 90 et début 2000, mais n'ai jamais vraiment porté attention à ces réalisations. Hormis le Minimig dont j'ai entendu parler il y a quelques années de cela, pas grand chose.

Hors il semblerait que les choses changent actuellement de façon très dynamique, particulièrement grâce à l'entreprise Applo Accelerators, fabriquant des cartes accélératrices Vampires :

http://www.apollo-accelerators.com
Ces cartes accélératrices sont disponibles pour A600 et A500, avec une version A1200 prévue, et aussi et surtout, une version autonome qui rassemblerait tout le hard d'un Amiga sur une même carte, il s'agirait de la Vampire V4 :


Je n'ai pas tout suivi l'affaire Amiga mais il me semble que l'aspect logiciel n'est pas en reste non plus. Et vues les démos que sont capables d'effectuer ces cartes, il est légitime de penser que l'on se trouve en présence d'un vrai eco-système sur base Amiga.

Alors si vous souhaitez en savoir plus, il pourrait être intéressant de participer à l'évènement Amiga 32 qui se tiendra à Neuss en Allemagne le 28 octobre 2017 (j'ai déjà eu l'occasion dévoquer cet évènement ici ) :


Pour se procurer un billet, c'est ici : http://www.amiga32.de

Physiquement ca se trouve ici :


Cette fois, je me laisserais bien tenter ;-)

mercredi 20 septembre 2017

Recreating the Sequential Circuits Prophet VS.

Comme le titre le laisse à penser, j'ouvre ici un billet dont le sujet est la recréation totale du synthétiseur de Sequential Circuits, le Prophet VS.

Pourquoi? Parce que le Prophet VS est une machine assez intéressante. Parce que j'ai toujours estimé qu'elle n'avait pas été très bien conçue et que le concept pouvait 'sonner' un peu mieux. Parce que j'ai étudié il y a quelques années la faisabilité de la mise en FPGA de l'ensemble de la carte mère du Prophet VS, et que le résultat obtenu était pertinent. Que finalement, cela peut aussi être bien de mener à terme un projet qui m'a déjà occupé un bon paquet d'heures. Quant à faire mieux que les développeurs de l'époque chez Sequential Circuits : a voir...

'THE' Prophet VS

Le travail déjà effectué à consisté à implémenter dans une carte à base de FPGA, l'ensemble de la carte mère du VS :

La carte mère du Prophet VS.
Absolument tous les composants de cette carte sont émulés, sauf la gestion du clavier. Je n'ai d'ailleurs pas l'intention de m'attaquer à la gestion du clavier du VS sachant que je projette d'élaborer une version 'desktop' de ce synthétiseur.

Lors de mon étude précédente, je me suis arrêté à celle du circuit 'custom' responsable de la génération des formes d'ondes des oscillateurs. Je viens donc de m'attaquer à ce sujet important, car une fois ces quatre circuits 'décodés', il deviendra possible d'intégrer absolument toute la partie numérique de ce synthétiseur dans un gros circuit de type FPGA. Cela va encore demander un certain travail...

28/08/2017 : après avoir ressorti l'analyseur logique et effectué une série de tests afin de se faire une première idée de la façon dont fonctionnent les circuit custom de ce Prophet VS, il est temps de se préparer un circuit d'interface pour permettre le raccordement d'une carte FPGA sur la carte de synthèse du VS.
Parce que le gros problème de ce type de machine Vintage, c'est que tous les circuits numériques fonctionnent en 5V. Alors que les entrées/sorties des FPGA actuels sont, au mieux, en 3,3V. Cela peut poser des problèmes lorsqu'il s'agit de faire 'rentrer' un signal de 5V sur une entrée qui ne supporte QUE 3,3V max.
Le circuit étudié se contente de tamponner tous les signaux d'un circuit CUSTOM en 3,3V avec une connectivité facilitée pour le raccordement à une carte FPGA :


Ce circuit se positionnera directement à la place d'un des circuits CUSTOM sans avoir quoi que ce soit à modifier de la carte de synthèse, tout en conservant une bonne intégrité des signaux.

Et en attendant de recevoir ce circuit imprimé, il est temps de s'occuper du traitement audio qui suit directement ces circuits CUSTOM, à savoir la conversion numérique/analogique, les VCAs d'onde et le démultiplexage analogique final des signaux audio. J'ai quelques idées pour améliorer et simplifier toute cette partie avec des composants modernes. Il me faut tester la viabilité de ces idées...

lundi 11 septembre 2017

A la découverte de l'automate UniPi Neuron S103-G (en live, c'est plus dynamique...)

Depuis quelques mois maintenant, des automates programmables développés sur une base Arduino sont disponibles sous diverses formes. Le phénomène se propage actuellement sur la technologie Raspberry Pi 3, à la faveur du portage par CODESYS de la norme 61131-3.
 
Le sujet de ce billet porte donc sur la mise en œuvre d'un PLC à base de PI 3 comportant de plus un module GSM. Le but en étant l'application à un cas concret.

La première chose à faire consiste donc à commander et à recevoir un PLC de type S103-G de chez UniPi :

Fraichement arrivé!
Fraichement déballé...
Sera-t-il aussi performant que le n°007?
Le n°4 de la ligne de production. N'est-ce pas un peu risqué? Pour le savoir, il ne reste plus qu'à rendre cet automate opérationnel. Pour cela, il est nécessaire tout d'abord de copier l'image du système Neuron sur une carte SD, puis de placer cette carte SD dans le S103G. L'opération est simple, elle consiste à récupérer l'image sur le site D'UniPi à cette adresse (version UniPian-Neuron-OS-2017-08-30), puis à la copier après l'avoir préalablement dézippée, sur une carte SD à l'aide du logiciel Win32 Disk Imager.

Carte SD avec OS validé.

Jusqu'ici, les opérations effectuées sont totalement triviales. A titre d'information, une version plus 'amateur' de ce concept peut être trouvé à cette adresse :

http://alltwincat.com/codesys/raspberry-pi-plc/
Une fois le S103G démarré sur sa carte SD, il reste encore à s'y connecter en réseau parce que la sortie HDMI n'est évidemment pas accessible. SSH est actif par défaut sur les distributions Raspbian dont semble être issu l'OS UniPian d'UniPi. Par contre, le protocole de boot par défaut utilise le DHCP via l'interface Ethernet. Quand tout l'environnement réseau fonctionne en WiFi, comme c'est le cas chez moi, la seule solution consiste à connecter ce S103G directement sur un des ports Ethernet du routeur réseau. Une fois cette connexion réalisée, l'accès au système est de suite possible en SSH avec le login root:unipi.

Avec en prime l'adresse MAC de la bête, afin de la configurer en statique dans le DHCP.
Passons aux choses sérieuses...

Pour programmer ce type d'automates il existe plusieurs possibilités. A la limite, des scripts en Python pourraient 'suffire'. Je pense néanmoins qu'il est plus judicieux d'utiliser l'environnement de programmation Mervis fourni par le constructeur, et compatible avec la norme 61131-3.  Il y a deux années de cela, j'ai eu l'occasion de programmer des automates à base de processeurs ARM qui utilisent cette norme de programmation et d'en constater la facilité de mise en oeuvre :

Configuration quelque peu artisanale, mais efficace!

Mervis fonctionne de la même façon que la solution Codesys. A savoir un runtime temps réel implémenté sur l'automate qui exécute le programme édité et 'compilé' sur un IDE fonctionnant dans mon cas sous Windows. Pour implémenter une solution Mervis, il convient donc de télécharger et d'installer sur la SDcard de l'automate, l'image du système contenant le runtime Mervis. Une fois fait, un ssh à l'adresse IP du PLC permet de se connecter au système Linux embarqué de la même façon que cela fût le cas avec le système Linux 'standard'.

La ou cela devient intéressant, c'est qu'une fois le logiciel de développement installé sur le PC, il devient possible de se connecter, via ce logiciel, directement au Neuron S103-G. Il 'suffit pour cela de demander l'ajout d'un contrôleur :


Et d'attendre que la recherche automatique ait eu lieu pour que l'automate soit reconnu depuis le réseau, wifi dans mon cas :


Une fois l'automate sélectionné et cette fenêtre validée, l'IDE Mervis est en mesure de montrer les détails du PLC nouvellement détecté :

Et voilà!
Allez, je renomme ce PLC en S103-G. Passons à l'étape suivante qui va consister à écrire le premier 'Hello World', à savoir faire clignotter une des sorties de ce PLC.

Pour l'instant le logiciel, bien qu'ayant reconnu le type d'automate en ligne, ne connait absolument rien des périphériques disponibles dans ce S103-G. Or, tous les périphériques sont accessibles VIA le protocole ModBus. Il est donc nécessaire de déclarer ce type de bus au sein de l'environnement de développement afin qu'il puisse converser normalement avec l'automate. Cela se faire de la façon suivante :


Puis dans le panneau propriété, de sélectionner le protocol ModBus. J'en ai aussi profité pour modifier le nom du 'channel' en l'appelant TcpModbus. A remarquer que cette liaison ModBus se fera sur le réseau Ethernet de la Pi3.


Ça n'est pas fini. Alors que le type d'automate a été déclaré précédemment, cette déclaration ne concerne pas la définition de ses périphériques qui demeurent encore inconnus par le logiciel de développement. Une procédure 'purement administrative' doit donc avoir lieu, qui consiste à déclarer tous les périphériques sous forme de variables utilisables dans les futurs programmes. Pour cela, il faut déclarer le type de 'device' attaché au bus ModBus, ce qui aura pour effet de générer les variables d'entrées/sorties associées :

Dans mon cas, il s'agit d'un modèle S10x.
Un fois ce 'device' de type S10x reconnu, il suffit de demander l'auto-génération des variables pour obtenir la liste de toutes les entrées/sorties disponibles dans l'automate :


Dans l'onglet 'View' du logiciel, il est possible de demander le panneau 'Variables Browser', pour obtenir comme on peut s'en douter, le panneau avec toutes les variables déclarées :


On est presque au bout. Je vais faire clignoter la LED 01 de l'automate, matérialisée par la variable $Neuron S10x_ULED_1.01$ dans le fichier des variables globales générées lors des opérations précédentes dans la rubrique 'generated' du type de variables 'Globals' du programme que j'ai nommé 'Mervis-Test' dans la partie 'Executable projects' de mon premier projet 'Mervis-Test'. L'esprit humain adore la hiérarchie ;-) ...

Dans ce projet, j'ai donc créé un source principal nommé 'Main'. Pour un début, je n'ai pas cherché l'originalité. Cela se fait facilement de la façon suivante :


Dès lors, il est possible de commencer à rentrer du code dans la partie d'édition dédiée. Le code est extrêmement 'complexe' puisqu'il s'agit de faire clignoter une seule LED à une fréquence d'à peu près le Hertz :

PROGRAM Main

VAR
   Delay : TON;
END_VAR

    Delay(IN:=TRUE, PT:=T#1S);
    IF NOT(Delay.Q) THEN
           RETURN;
    END_IF;

    Delay(IN:=FALSE);
    IF(hw.$Neuron S10x_ULED_1.01$ = FALSE) THEN
        hw.$Neuron S10x_ULED_1.01$ := TRUE;
    ELSE
        hw.$Neuron S10x_ULED_1.01$ := FALSE;
    END_IF;

END_PROGRAM

Je ne rentre pas dans les détails, notamment de la variable de type TON. Tout ce qui est écrit ici se trouve sur le Net. C'est l'avantage du langage à la norme 61131-3. Et pour plus de référence, il 'suffit' de rechercher les informations disponibles sur la toile avec le mot-clé Codesys puisque c'est l'entreprise de 'référence' en ce qui concerne ce langage. La compilation de ce source se passe sans problème.

Est-ce suffisant pour que cela fonctionne? Et bien NON!

Il est encore nécessaire de déclarer cette tâche au sein de l'automate en lui affectant un temps de fonctionnement. Il serait possible de discuter sur les raisons de cela, Il faut juste prendre conscience que sur un bus de type ModBus c'est toujours le Maître qui demande des 'choses'. Un périphériques ne peut JAMAIS interrompre un programme maître. Du coup, pour savoir ce qui se passe sur des entrées, par exemple, la seule solution consiste à faire du pooling sur l'entrée surveillée. C'est tout simplement cette notion de pooling, ou de fausse interruptions, qui est implémentée de la sorte de façon généralisée dans les automates. Cela reste évidemment extrêmement moins efficace que de la vraie gestion d'interruption processeur, mais c'est ainsi...

Un double 'click' sur l'automate permet de changer les icônes du bandeau supérieur du logiciel pour voir apparaître celui des Tâches. Il convient dès lors d'en ajouter une, en renseignant le programme concerné et le temps machine alloué, même si ce programme ne gère absolument aucune entrée :


Un 'clik droit sur l'automate pour demander un 'Full run' dans la rubrique 'PLC Operation' permet, après avoir déployé la solution, de démarrer 'réellement' la tâche et de constater le clignotement de la LED X1 sur le joli boitier bleu: magique!

A noter que lors de la mise sous tension du PLC, le programme démarre automatiquement après seulement quelques secondes de boot de la carte Pi3. On s'en serait douté, mais autant le confirmer.

13/10/2017 Bon, une LED qui clignote sur la face avant de l'automate c'est bien, et quoi d'autre?

Un des intérêt de cet automate de chez UniPi, c'est qu'il possède en interne un module GSM. J'ai choisi cet automate aussi pour cette raison parce que l'application que je développe doit prévenir en cas de problème. Un moyen 'simple' de le faire est donc de profiter de l'infrastructure réseau du téléphone mobile.

Le problème (le monde technique n'est QUE problèmes. Mais les résoudre est un vrai challenge, n'est-ce pas, surtout quand la réflexion profite à soi même, et non pas à Micro-Logiciel!), c'est qu'il n'y a absolument aucune connexion entre ce moduler GSM et l'automate.
Impossible donc de disposer d'une sortie type relais de l'automate, propre à déclencher quelque chose sur le module téléphone. En fait, il existe une solution, simple dans l'idée, mais un peu compliquée à mettre en œuvre.

Comme l'automate est connecté avec la carte Pi3 par le biais d'un liaison de type TCPModBus, et bien il 'suffit' de la même façon, d'implémenter sur le système de la Pi3 un client ModBus en TCP qui déclenchera le contrôle du module téléphone, qui lui, est connecté par port série sur la carte Pi3.

L'idée est simple, reste à la mettre en pratique. Pour ce faire, je vais d'abord effectuer des tests à l'aide d'un client démarré sur le PC de développement, raccordé en WiFi au réseau sur lequel est connecté l'automate.

La première étape consiste donc à déclarer un client ModBus par liaison TCP dans l'environnement de l'automate en ajoutant en Device dans la liaison TCPModBus comme ceci :



Contrairement à ce qui a été fait précédemment, il ne faut pas installer quoi que ce soit à partir de la 'Library Device' parce que, forcément, mon client ModBus n'a jamais été déclaré ou que ce soit étant donné que je le crée quasiment en live.

Voici les propriété que j'ai configuré pour ce client ModBus :


Pas grand chose de vital mis à part l'adresse IP du client, ainsi que le port réseau d'écoute. Le reste des paramètres se comprend aisément, tellement, que je n'ai touché à rien d'autre, hormis le nom.
Ah oui, pourquoi installer un client ModBus et non pas un Serveur? Parce que c'est l'automate le patron, c'est lui qui VA lire ou écrire à l'extérieur.

Une fois le client déclaré, il faut maintenant déclarer les registres de ce client auxquels il va falloir accéder, parce qu'il n'existe aucun fichier de déclaration pré-établi.

Première chose à faire, il faut déclarer en fait le type de variables auxquelles l'automate devra accéder. J'ai choisi de déclarer un groupe de variables de type 'Single Coil', autrement dit, un pool de relais dont j'en déclencherai un pour indiquer une action à effectuer vers le module téléphone.

Un 'clic' droit sur le Client ModBus permet d'ouvrir l'éditeur et d'accéder à l'ensemble de ce qu'est 'censé' contenir le client en terme de registres, d'entrées/sorties etc etc...


Et la page des ressource matérielle du client :


Je triche un peu, normalement le contenu de cette page est vide à la création. Mais ici, on voit le Group de ressources qui a été créé, et quelle est la ressource utilisée dans ce groupe.

'Clic' droit sur cette fenêtre permet d'accéder à la création du groupe de ressources :


Puis la sélection du Groupe permet d'en configurer les paramètres :


Donc, je déclare un 'tas' de variables, en fait il y en aura une, mais de type Byte, qui commencera à l'index n°1 et qui sera considérée comme un 'paquet' de relais qui accepteront simplement d'être 'écrits', toutes les 100ms. Le choix de la fréquence est important parce que pour mon test, je vais évidemment insérer la mise en ON puis OFF de la variable à l'endroit du code ou je mets la LED du panneau avant de l'automate en ON puis en OFF. Et comme je le fais toutes les secondes, une écriture toutes les 100ms me donnera donc au maximum un retard d'un dixième de secondes à l'actualisation de la variable du client ModBus par rapport à l'actualisation de la LED de l'automate. Vous suivez toujours?...

Ceci fait, la même manipulation permet de déclarer... la variable finale, cette fois ci en déclarant un 'Data Point' :



Il reste encore à positionner les propriétés de cette variable pour pouvoir l'utiliser :


Les paramètres les plus importants sont le groupe auquel appartient cette variable, ici le groupe 'Group' (comme c'est original!), le type de variable, j'ai choisi une sortie de type bit, donc 'bool'. Il est important de renseigner l'endroit ou se trouve la variable dans le paquet de huit 'bool' déclarés, à savoir la première position, avec le paramètre Write Offset Gap, puis d'indiquer la taille totale de la variable à écrire lors du changement d'état de la variable booléenne, ici un octet. Parce-que ModBus ne sait pas traiter des données de 1 bit, mais à minima des octets. Il suffira donc d'envoyer l'octet ou se trouve la variable à modifier vers le client.

Et ça n'est pas fini. Il faut maintenant générer la variable globale associée à cette variable pseudo physique. Simple, il suffit de demander l'auto-génération de la variable :


pour se retrouver avec la nouvelle variable globale de l'application :


C'est fait, nous voici avec une bien jolie variable. Qu'il suffit maintenant d'utiliser dans le programme initial :


J'utilise toujours le même programme qui consiste à faire clignoter une LED de la face avant de l'automate. Cette fois, je fais aussi clignoter la sortie virtuelle associée à la nouvelle variable. Bien évidemment, au redémarrage il ne se passe pas grand chose sur l'automate. Et pour cause, je suis censé faire clignoter une sortie sur un automate quelque part sur le réseau.

Or donc, il reste encore à démarrer un client sur le PC portable relié en WiFi au réseau. J'utilise l'esclave pyModSlave :


Après avoir configuré cet esclave ModBus pour fonctionner en TCP à l'adresse IP et au PORT adéquat, je peux constater qu'effectivement la première variable de type 'Coil' c'est à dire de type  relais, ou tout simplement de type 'tout ou rien', clignote en rythme avec la LED de l'automate, à quelques dixièmes de secondes près :


Bien que l'image soit statique par essence, le seul bit à '1' correspond bien à la variable positionnée toutes les secondes par l'automate qui se situe... à l'autre bout de l'habitation : cool, voir carrément fun! (chacun ses plaisirs). A remarquer que l'adresse IP et le PORT correspondent à ce qui a été positionné sur le logiciel de l'automate pour créer le client virtuel. Les 'packets' indiquent en fait les trames ModBus valides qui ont été reçues. Par contre le client n'affiche pas un octet de variables, mais 10 bits. Je n'ai pas creusé la question parce que cela n'a aucun importance (pour le moment).

Et maintenant? Il ne s'agit la que d'un test de faisabilité. Il me faut maintenant implémenter un client ModBus directement sur l'automate, puis m'en servir pour déclencher un script de gestion du module GSM afin qu'il y ait bien émission d'un SMS lors d'un évènement surveillé. Je ne suis pas au bout de mes peines...