Color Maximite 2

La saga des Micromite/Maximite a commencé il y a maintenant neuf ans, en 2011. Ce n'est que quelques années plus tard, en 2014 c'est à dire quasiment au tout début de ce blog que j'en ai parlé, en septembre 2014.

A cette époque, il existait le Maxite de base et le Maximite couleur :

Le Maximite monochrome.

Le Maximite couleur.

Plus tard, sont arrivés les Micromite, plus dépouillés mais toujours avec la même puissance de traitement. J'avais d'ailleurs réalisé une carte d'étude permettant un emploi aisé de ce type de processeur :

La caractéristique principale de la famille Micromite/Maximite est d'utiliser le langage BASIC comme moyen de programmation. Certes, cela peut faire sourire puisqu'il s'agit d'un langage quasiment oublié pour cause d'obsolescence programmée, de manque de performance et de mauvaise réputation puisque associé irrémédiablement aux machines du début des années 80.

Impossible en effet de prendre au sérieux un langage de programmation collant aux touches du ZX80 :

Source Wikipedia.

De mon avis personnel, le langage Basic n'est ni meilleur ni pire que n'importe quel autre langage. Le PHP ressemble à mon sens exactement au Basic... en pire! Il est juste particulièrement adapté à certaines situations.

Basic est particulièrement intéressant pour l'apprentissage de la programmation. Il est rapide à comprendre et à maîtriser et permet donc une mise en situation rapide. Il peut être totalement 'non structuré', ce qui permet une mise en évidence immédiate de l’intérêt de structurer son source et par la-même ses pensées. Et surtout, il permet de passer rapidement d'une idée à un prototype en autorisant des tests d' algorithmes sans devoir partir sur du matériel compliqué et des langages comme l'assembleur ou le C++, et sans avoir à tenter de pénétrer les arcanes insondables de la programmation sous Windows.

Evidemment, Basic implémenté sur une 'petite' machine sera forcément interprété, donc lent. Oui mais... Dès la fin des années 80, des processeurs rapides permettaient déjà une exécution plus véloce des programmes écrits par exemple sur un Intel 8052AH Basic :

en remplaçant ce circuit par un équivalent Dallas environ 10 fois plus rapide à 33MHz:

Ces solutions ne permettaient cependant pas l'écriture de gros programmes du au fait de sévères limitations matérielles  : peu d'entrées/sorties, pas de sortie vidéo, pas de sortie son etc... Hormis le Visual Basic proposé par Microsoft sous Windows, dès le début des années 90 ce langage était définitivement abandonné.

L'utilisation de processeur de type PIC permetta à Geoff Graham de proposer en 2011 son 'fameux' Maximite. L'appareil était équipé d'un port d’extension permettant la connexion de diverses interfaces, d'une sortie vidéo certes limitée mais permettant la-aussi une interactivité facilité avec l'utilisateur, ainsi qu'un port clavier de type PS2. Cette 'machine' ne peut s'apparenter aux Arduinos qui restent des matériels embarqués nécessitant un ordinateur sur lequel est installé le système de développement et les outils de téléchargement du programme vers la carte. De plus, Arduino se programme en C++ édulcoré (la majorité des caractéristiques objets du langage est passée sous silence). Sauf pour ceux désireux de développer une librairie particulière qui devront se conformer à sa mise à disposition sous forme de classe.

A l'époque, j'avais effectué un rapide test de performances du Basic interprété fonctionnant sur un PIC32MX à 40MHz par rapport à un SHARP PC1500A, une machine considérée comme professionnelle à l'époque.

2 200FF en 1984 soit 335€ ou dit autrement, plus d'un demi SMIC en 1984 (~550€)

Une simple boucle comptant de 0 à 100 000. J'avais obtenue ce résultat...

Le Basic du Micromite était donc environ 130 fois plus rapide que celui du SHARP.

Bien que les Micromites/Maximites n'aient pas vraiment rencontré de succès dans nos contrées, j'avais cependant nourri quelques espoirs de voir la machine décoller avec l'annonce par Microchip d'un successeur au PIC32MX, à savoir le PIC32MZ. Ce successeur de la famille MX offrait un nombre plus important de périphériques et surtout une vitesse d'exécution plus élevée.

Mais hélas, depuis 2015 il ne se passait plus grand chose autour de ce système, hormis la publication de nouvelles versions du Basic.

Et puis, il y a quelques jours de cela est apparu l'annonce du Color Maximite 2. Cette fois, la machine est basée sur un processeur ARM et les caractéristiques sont impressionnantes (informations source) :

Processor	32-bit ARM Cortex-M7 at up to 480MHz with 2MB of flash. 1MB on-chip RAM plus 8MB off-chip RAM for BASIC variable storage and video pages.
BASIC	Built in full featured BASIC interpreter with double precision floating point, 64-bit integers and string variables, long variable names, arrays of floats, integers or strings with multiple dimensions, extensive string handling and user defined subroutines and functions
Program Editor	Full screen editor includes colour coded syntax, search and copy, cut and paste.
Memory	516KB for the BASIC program, enough for large complex programs (typically 25,000 lines or more).  5MB RAM for variables, arrays and buffers
Speed	Typically executes programs at 270,000 lines per second.
Display	Colour VGA output with VGA standard timing.
VGA Resolutions	800 x 600 (default), 640 x 400, 320 x 200, 480 x 432 and 240 x 216 The last two emulate the resolutions available on the original Colour Maximite.
Graphics Colours	8-bit (256 colours; default), 12-bit (4096 colours plus 16 levels of transparency) or 16-bit (65,536 colours).
Keyboard	Standard USB keyboard with either US or UK layout.  Can be a wireless keyboard (USB).
Storage	SD Cards up to 128GB formatted in FAT16, FAT32 or exFAT
Graphics	Set pixels, draw lines, boxes, circles, etc.  Features include BLIT, Sprites, multiple video layers (with transparency).  Rotate and scale images.
Images	Load images in BMP, JPG, PNG and GIF (including animated) formats.  Images can be loaded anywhere on the screen and be scaled and rotated.
Audio	Stereo audio output for amplified speakers. Can play WAV, FLAC and MP3 files, computer generated music (MOD format), robot speech and sound effects as well as generate precise sine wave tones
Compatibility	Generally compatible with the Maximite and original Colour Maximite.  Special legacy mode for older graphics commands.
Games	Extensive features for creating computer games. These include multiple video planes, support for Blits and Sprites, the ability to create computer generated music, sound effects and computer generated speech.
Nunchuk	Full support for up to three Nunchuk games controllers with one connected via the front panel..
External I/O	Twenty eight input/output pins with 12 capable of analog input. Connector is compatible with RPi Hats.  Built in support for an IR remote control and temperature and humidity sensors.
Protocols	Communications protocols supported include I2C, asynchronous serial, RS232, IEEE 485, SPI and 1-Wire.
Remote Console	Supports serial over USB protocol so a desktop PC or laptop can access the BASIC console for entering and running programs.
PC Integration	Programs can be easily transferred from another computer (Windows, Mac or Linux) using the SD card, XModem protocol or by streaming the program over the serial console input.
Clock	Battery backed clock will keep the correct time with the power disconnected.
Firmware Updates	The firmware can be updated via USB with a desktop or laptop computer running Windows, MacOS or Linux.
Power	5 volts at approx 220mA typical (from a USB port or charger).

Tout cela, proposé sur une carte aux dimensions somme toute réduites :

La particularité de cette 'première' version du Color Maximmite 2, consiste en l'utilisation d'un module processeur disponible chez WaveShare. L'avantage de cette solution est de permettre un montage plus facile de la machine. Souder un tel processeur requiert en effet un minimum de savoir faire et d'expérience en composants cms.

Il est bien évidemment très intéressant de tester une telle machine. Je ne la possède hélas pas pour le moment. Je prévois cependant d'en monter un exemplaire rapidement. Cet ordinateur compacte et puissant possède tous les attributs nécessaires à la mise en place d'un banc de tests automatisé tel celui que j'ai du développer sous Windows pour la qualification du convertisseur CV/Gate précédemment évoqué sur ce blog.

Cette machine ne possède absolument pas d'environnement fenêtré et donc aucun dispositif de pointage. Il me faudra donc faire avec cette limitation. C'est le seul point un peu négatif que je vois. Il est vrai que pouvoir pointer un élément sur l'écran pour en changer la valeur est une fonctionalité bien pratique. Peut-être que l'utilisation du port joystick permettra de palier ce manque.

En attendant, voici quelques vidéos que j'ai pu trouver sur Internet au sujet de cette nouvelle version du Maximite :

Intéressant, n'est-il pas?

Micromite MkII VERSION 5.0

J'ai eu l'occasion à plusieurs reprises d'écrire sur ce processeur de la famille PIC32 fonctionnant avec un puissant interpréteur Basic créé par Geoff Graham. La dernière version de l'interpréteur Basic que j'ai pu tester était la version 4,6b. Version que j'avais implémenté sur ma carte de développement spécialement créée pour Micromite :

Carte pratique et efficace ;-)

Comme cette carte le permet, il suffit d'y 'plugger' l'interface de programmation PicKit3 :

Facile...

Et de lancer l'interface de programmation de chez Microchip afin de programmer le circuit avec le nouveau firware en version 5 :

J'aime qu'un plan se déroule sans accrocs!

Et enfin de constater quelques instants plus tard, que le processeur contient bien le nouvel interpréteur Basic :

Et voilà.

Bien. Et alors?

Je passerai sur les améliorations en tous genres que Graham à porté à son Basic pour pointer une caractéristique bien intéressante : la gestion directe des afficheurs graphiques commandés par un contrôleur ILI9341. Pour avoir tenté, et réussi, d'implémenter ce type de gestion d'afficheur sur un petit processeur Atmel, je n'ai pu qu'être séduit par le fait de disposer de telles ressources disponibles sous la simple forme de quelques commandes Basic.

Le type d'afficheur dont il est question :

Cet afficheur possède de plus une interface tactile.

Il est possible de trouver ces afficheurs en taille de 2,2",  2,4" ou 2,8", équipé ou pas, de l'interface tactile. Pour mes tests, je disposais d'un afficheur sans interface tactile, ce qui devait suffire cependant à évaluer le système.

Le type d'afficheur utilisé, avec contrôleur ILI9341.

Le montage utilisé se compose donc de ma carte de développement spécialement étudiées pour Micromite, d'un afficheur adéquat sans interface tactile et, pour mettre en pratique le petit code d'exemple fourni dans la documentation du Basic, d'un module d'horloge temps réel obtenu sur la 'Bay' :

Des fils partout mais cela reste simple!

Un petit mot au sujet du module Temps réel : de la même façon que pour l'afficheur couleur graphique, l'interpréteur Basic possède les instructions nécessaires à la gestion simple d'un tel module équipé d'une puce de type DS1307 de chez Maxim. Il est possible de trouver ce genre de modules équipé non pas d'un DS1307 mais d'un circuit DS3231, plus précis mais toujours compatible avec le DS1307, et comportant en plus une petite mémoire EEPROM :

Ce module n'utilise pas une pile CR2032 mais un accumulateur LIR2032

L'afficheur LCD couleur est connecté simplement avec quelques liaisons sur le bus SPI du processeur.
Le module Temps réel est connecté sur le bus I²C du processeur.
Le tout, en fils volants mais sans complexité.

Une fois ce montage réalisé, il suffit de rentrer les quelques lignes de code Basic suivantes :

OPTION EXPLICIT
CONST DBlue = RGB(0, 0, 128)  ' A dark blue colour
COLOUR RGB(GREEN), RGB(BLACK)
FONT 1, 3
BOX 0, 0, MM.HRes-1, MM.VRes/2, 3, RGB(RED), DBlue
DO
TEXT MM.HRes/2, MM.VRes/4, TIME$, CM, 1, 4, RGB(CYAN), DBlue
TEXT MM.HRes/2, MM.VRes*3/4, DATE$, CM
' IF TOUCH(X) <> -1 THEN END
LOOP

pour obtenir le résultat suivant :

Remarque, la ligne Basic contenant la lecture de l'interface tactile de l'écran a été mise en commentaire car l'afficheur ne possédant pas cette interface, l'instruction de calibrage n'a pas pu être utilisée. Le test de l'interface tactile génèrerait alors une erreur et stopperait l'exécution du programme.

Force est de constater que la réalisation de systèmes conviviaux devient de plus en plus aisée avec ce type de matériel. Pourquoi ne pas imaginer la réalisation d'une version simple de thermostat?

Micromite over the air!

Yes, I like the Micromite IC and especially the MKII version.

The main page of the Geoff's site.

It's about time to create a usefull aplication with.
So, why not to use this circuit with a wifi connection?

Ok, let's go : one wifi board ESP-01 available for a few dollards on the web; a micromite MKII dev board available here; and a tiny LCD display for autonomous use.

The WIFI module.

We need to change the firmware of the ESP-01 to provide a very easy to use serial like communication. You can find all the informations about this procedure at Jeelabs site. And, that's all.

I connected the ESP8266 board with the COM1 basic port of the Micromite, and a 2x16 LCD display as it's explained in the MKII Basic manual.

Some lines of BASIC :

SetPin 15, DOUT
Open "COM1:115200" As #1
Pin(15) = 1

LCD init 18,14,3,25,16,17
LCD 1, 1, "COMMAND AMOUNT :"
Cmd = 0

Do
  Line Input #1, dat$
  Select Case dat$
    Case "led_on"
      Pin(15) = 0
      Cmd = Cmd + 1
      Print #1, "Command nunber ", Str$(Cmd)
      Print #1, " ->Led ON"
      LCD 2, 1, "                "
      LCD 2, 1, Str$(Cmd)
    Case "led_off"
      Pin(15) = 1
      Cmd = Cmd + 1
      Print #1, "Command number ", Str$(Cmd)
      Print #1, " -> Led OFF"
      LCD 2, 1, "                "
      LCD 2, 1, Str$(cmd)
    Case Else
      Print#1, "Enter led_on or led_off"
  End Select
Rem  EndIf

It's not a very efficient basic program but I realized this in five minutes.

To test the system, simply connect with a telnet programm at www.electrodiy.com (not the week-end) and switch ON or OFF the led on board, and see the result in your telnet emulator. On my side, I can follow the number of operations directly to the display.

Funny and easy to realize!

I plan to create a more complexe board with a FCC ESP8266 module to take control of my house!

Carte de développement pour le système Micromite MKII.

En matière de programmation, il existe une multitude de langages disponibles. Suivant le matériel sur lequel devra s'effectuer le programmation, seuls certains d'entre eux seront disponibles. En effet, les ressources matérielles mais surtout systèmes, nécessaires à l'exécution d'un programme, peuvent être du tout au tout différentes.

Pour programmer un matériel simple, typiquement un petit processeur ou plus généralement un micro-contrôleur, il est possible de distinguer deux grands type de langages. Ceux nécessitant la présence d'un système d'exploitation, et les autres. Un langage interprété comme Phython par exemple ne fonctionne que sous environnement Linux (en général) et exploite largement les ressources fournies par ce système. Ce type de langage n'est donc pas imaginable sur un système simple.

Par contre, il existe d'autres langages dits évoluées qui permettent la programmation d'un tout petit système. Pascal, C/C++, Basic et autres du même type sont parfaitement adaptés à cet usage. Dans cette catégorie de langages, il est encore possible de différencier les langages compilés et les langages interprétés.

Un langage compilé sera en fait interprété une fois par un programme particulier, le compilateur, qui produira un fichier exécutable qui devra être écrit dans le petit système. Dans ce cas, le compilateur est exécuté sur une machine différente que celle sur laquelle devra s'exécuter le fichier exécutable.

Un langage interprété consiste en fait en un programme qui lit constamment des lignes de code et en exécute les instructions. C'est le cas du Basic, donc de l'interpréteur Basic. Ce type de solution peu paraître inefficace car même dans une boucle exécutant mille fois la même chose, l'interpréteur exécutera mille fois le décodage et l'exécution des mêmes instructions.

Le Basic Microsoft, omniprésent dans les années 80

Relativisons, même s'il semble évident qu'un programme écrit en Basic s'exécutera bien moins rapidement qu'un programme compilé, les ressources disponibles aujourd'hui permettent de ne pas trop avoir à se soucier de cet aspect des choses. D'une part on ne demandera jamais à un petit système à processeur de gérer des fichiers ou d'effectuer du traitement de signal comme peuvent le faire les 'gros' processeurs et les PC.

De plus, certains 'artifices' permettent d'augmenter artificiellement la vitesse d'exécution d'un programme écrit en Basic. Le procédé est simple, il suffit d'écrire dans un langage compilé, donc plus rapide, des bouts de codes particuliers et de les exécuter en les appelant depuis un programme écrit en Basic.

C'est exactement ce qu'est capable de faire l'interpréteur Basic Micromite MKII écrit par Geoff Graham.

Encore mieux, cet interpréteur laisse la possibilité à l'utilisateur, s'il maitrise bien la programmation en langage 'C' par exemple, de créer ses propres bouts de programmes compilés, de les insérer et de les exécuter dans un programme Basic. Si l'on rajoute à cela que l'interpréteur Basic dont il est question fonctionne sur un processeur rapide fonctionnant à quelques 50Mhz, on se retrouve assez éloigné des faibles performances des machines programmables en Basic des années 80 dont certaines ne fonctionnaient même pas à 1Mhz. Et pourtant, de belles choses furent réalisées avec ces anciennes machines comme avec le Commodore 64 et son Basic intégré, équipé d'un processeur 8 bits fonctionnant à 1,023Mhz :

Un des ordinateur de l'époque les plus vendu au monde!

J'ai déjà eu l'occasion de comparer la vitesse d'exécution du Basic de Geoff Graham avec celle de l'interpréteur présent dans le fameux PC1500 de Sharp. J'arrive à un rapport de 200! Pour fixer les idées, Micromite MKII exécute en 1 seconde, ce qui demande un temps de plus de 3 minutes au PC1500!

Le vénérable PC1500A de sharp

De plus, Micromite MKII fournit une interface complète et bien pensée pour divers composants électroniques comme des horloges temps réél, des décodeurs de télécommande infra-rouge etc etc...
Il devient alors très facile avec ce système, d'écrire des applications sophistiquées et faciles à maintenir, sous réserve toutefois que le programme ait été bien écrit et facile à comprendre.

Que dire des capacités? 80 Koctets sont disponibles en flash pour l'écriture des programmes ainsi que 52 Koctets en RAM pour les variables basic, soit environ 130 Koctets au total!. Evidemment à côté des gigas octets de mémoire dont sont équipés aujourd'hui nos PC, cela semble bien ridicule. Ne pas perdre de vue que la finalité du système n'est pas du tout la même. Allumer une ampoule avec un bouton ne requiert que quelques octets sur Micromite MKII, mais requiert des mégas octets sur un PC!
Le prix n'est pas le même non plus. Quelques dizaines d'Euros pour un système confortable basé sur Micromite MKII, des centaines d'Euros pour un PC, voire des milliers pour un Mac!

Et tout cela, dans ceci, pour quelques Euros :

Pour beaucoup de programmeurs, Basic est largement dépassé. A mon sens, cela ne veut strictement rien dire. D'un point de vue technique tout d'abord, un petit système programmable dans ce langage permet de réaliser très rapidement des applications fiables. Null besoin de posséder de grosses compétences en C#, en framework, en OS, et de posséder une grosse équipe de programmeur pour réussir, après des mois d'efforts et des dizaines de milliers d'Euros dépensés, à programmer une application somme toute tout juste à peu près convenable! Ensuite d'un point de vue plus philosophique, avec un tel système Basic, une seule personne peut être en mesure de réaliser de petites applications performantes en un minimum de temps et pour un cout minimum tout en restant totalement autonome sur les ressources et donc affranchi des contraintes de droit, de redevance, d'obligation de quoi que ce soit envers qui que ce soit. Seules, la compétence, l'autonomie et l'inventivité du programmeur, de la programmeuse, deviennent importantes.

Il semblerait d'ailleurs que Microsoft, qui après s'être nourri, devrais-je dire gavé, dans les années 80 de l'essor de la micro-informatique avec son Basic, et aillant contribué dès les années 90 à exploser le milieu pour tenter d'en devenir le seul maitre à bord, ait commencé à comprendre la situation actuelle ou de nouvelles compétences se développent, de nouveaux réseaux se montent, de nouvelles applications naissent, totalement en dehors de son contrôle. D'ou la très grosse opération actuelle de racolage tout azimut dans le petit monde de l'embarqué envers ceux qui étaient considérés il n'y à encore pas longtemps, comme des amateurs sans intérêt.

Incroyable non? Est-il vraiment aussi abordable que les premiers Basics?

N'adoptez JAMAIS les produits Microsoft! Le seul but de Microsoft est aujourd'hui de tenter de reprendre le contrôle des nouveaux écosystèmes naissants. Ne vous laissez pas faire. Microsoft ré-itérera ce qui s'est passé dans les années 90. Dès que vous serez pieds et poings liés avec lui, il vous explosera!!! Il n'a jamais été question pour cette entreprise de considérer un contrat gagnant/gagnant. C'est vous qui travaillez, c'est eux qui encaissent! J'ai à plusieurs reprise fait état de cette attitude désastreuse de Microsoft dans mon Blog... Je devrais aussi ajouter qu'il est nécessaire de se méfier de l'Education National, qui, loin de générer de l'autonomie en interne sur le sujet de l'informatique, se contente souvent de suivre la mode et la facilité en adoptant les ressources fournies 'gracieusement' par différents type de sociétés comme Microsoft!

Si vous souhaitez faire de l'informatique, veillez scrupuleusement à votre autonomie, cultivez VOS compétences, et ajoutez-y VOTRE façon de voire la chose!

C'est dans cet esprit que Geoff Graham a créé son superbe Basic! Je considère qu'il était presque de mon devoir, d'une part de l'utiliser, d'autre part d'en faire ici la 'publicité'!

Bien que toutes les informations nécessaires soient disponibles sur le site de Geoff, le montage d'un système minimal peut s'avérer un peu compliqué quand on ne possède absolument aucune compétence ne serait-ce que minimum en montage électronique. Il n'était pas question cependant de proposer une machine du type de celles disponibles dans les années 80 comme le commodore 64 précédemment cité, mais plutôt une carte d'étude se prêtant bien à de multiples expérimentations, facile à utiliser et peu onéreuse. Voici donc la carte que j'ai développé spécialement pour ce système Basic :

Le système, prêt a fonctionner.

Le processeur possède déjà l'interpréteur Basic. Il m'a été possible d'écrire le fichier programme de cet interpréteur dans le processeur après l'avoir téléchargé du site de Geoff puis transféré à l'aide de l'outil Pickit 3 de Microchip :

J'ai en effet implémenté sur la carte de développement, le connecteur permettant d'y raccorder le programmateur d'une façon simple et efficace. De ce fait, il sera possible à tout moment de reprogrammer le processeur avec une nouvelle version de l'interpréteur Basic. Il peut en effet arriver qu'un bug apparaisse au fil du temps, qui mérite correction, ou que l'ajout éventuelle de nouvelles fonctionnalités rende intéressante la mise à jour du processeur.

Configuration pour la programmation du firmware Basic

L'utilisation du programmateur Pickit 3 est simplifiée grâce au logiciel disponible en téléchargement sur le site de Microchip, le fabriquant du processeur. Bien que l'opération de programmation du processeur ne soit pas très compliquée, elle impose tout de même l'installation du logiciel Microchip,  MplabX,  sur un PC qui devra être assez moderne et fonctionner sous Windows. A titre indicatif, voici les opérations à suivre pour reprogrammer le processeur avec le fichier Micromite :

1- Dans la page principale du logiciel MplabX, demander l'importation d'un fichier hexadécimal :

2 - Une fenêtre apparaît alors ou il est nécessaire de renseigner l'endroit ou le fichier hexadécimal a été sauvegardé, ainsi que le type de processeur et de programmateur utilisé :

Le processeur est un PIC32MX170F256B.
Le programmateur est le PICkit3

3- Après validation de la fenêtre précédente, le logiciel revient sur sa page principale en affichant certaines informations :

A gauche, le logiciel à bien accepté le fichier ainsi que le type de processeur configuré.
En haut, l'icône de programmation vers le processeur est devenue active.

4- C'est sur cette icône qu'il faut cliquer pour lancer le processus de programmation. Ce processus démarre alors en faisant apparaître les différentes 'sortie' d'affichage du programme. J'ai agrandi vers le haut cette partie pour rendre lisible un maximum d'informations sur le processus de programmation :

J'ai sélectionné la 'tab' PICkit 3 pour suivre le déroulement du processus avec le programmateur. Tout semble bien se passer...

Au bout d'un certain temps, la programmation s'est effectuée :

5 - Il ne reste plus qu'à tester le système. Pour cela il faut retirer le programmateur PICkit 3 et appuyer sur le bouton RESET après avoir démarré un émulateur de terminal sur le PC, configuré sur le bon port de COM à 38400 baud. Le message suivant apparaît alors :

Pas de doute, le système fonctionne!

6- Il ne reste plus qu'à tester l'interpréteur Basic en tapant exactement l'exemple fourni dans la documentation du système :

Et la LED que j'ai installé à cet effet sur la carte de développement se met à clignoter.

Simple? Effectivement. Et maintenant, les ressource de ce Basic et de ce processeur étant assez complète, il ne reste plus qu'à envisager des application et à les développer, tout simplement!

Des remarques ou des suggestions :

A quick review of the Micromite MK II

After a little more than six months, Geoff Graham have released the version of the Micromite that I have talked about in my previous post, by the new Micromite MK II. This new version add many new features "such as the ability to insert compiled C or assembler subroutines into a BASIC program", cool! But one of the more interesting news is that this MK II version is supposed to run nearly 50% faster than the original MK I. Let's go and see...

First, we have to program a new PIC32MX170F256 chip of Microchip Technology. With 256K of flash and 64K of RAM, it offer now 80KB of non volatile flash memory for the program and 52KB of RAM for the variables : very confortable.

As usual, for the programming we need a little piece of hardware and the right software. A contactless breadboard is sufficient to do the job and, in my case, the Pickit3 programmer. We also have to respect the different connections like that is described in the document provided by Geoff Graham :

I uses the 28 DIP package.

In my case,  here is what it looks like :

The new version (V4.6) of the Micromite Mk II Firmware is available here.
The most simplest way to program a PIC32 with the Pickit3 is to use the MPLAB^® Integrated Programming Environment (IPE) available here. This software is very friendly and do the job without risks :

The PIC32 is programmed!

Ok. Now let us try the first connection :

Easy!

And the best for the end of this little review, a quick test of performances!
To do this test, I wrote this 'terrific' program :

A = 0;
DO WHILE A < 100000
A = A + 1
LOOP

Edited with the MK II integrated editor.

It is what I used before with the MK I version to test the performance compared to my Tandy PC-2. The previous results was 23 secondes for the Micromite MK I and... 3 000 secondes for my PC-2!

And now, the same test gives us 11 secondes compared to the 23 secondes previously obtained with the MK I version. Very good, but this test is not 'really' representative of the reality because I just used a very common ressources of this Basic. Others complex instructions may be not as efficient like this. But as said Geoff Graham, the "40% faster" of the previous version must be obtained without doubt.

Conclusion : Micromite II is an even more powerfull system than the MK I version : fantastic!!!

Micromite Companion : modification/mise à jour du firmware.

Tentative de passage au clavier Français.

Update 27 octobre 2014 : 

Tout d'abord une petite remarque concernant un des auteurs de ce petit système, Jeff Ledger.
Je lui ai bien posté une question concernant la compilation de l'archive compatible BST. Il n'a pas répondu à ma question, pas plus qu'à celle lui demandant la procédure utilisée pour la création du fichier umitecompanion.eeprom.

Par contre Jeff Ledger, ayant parcouru mon blog, est 'tombé' sur l'indication du problème concernant une des broches du processeur laissée en l'air. Il m'a demandé la permission d'afficher la photo que j'ai prise de ma modification, ce à quoi j'ai répondu favorablement sous réserve qu'il en indique la provenance. Il a contourné cet 'accord' en affichant sur le blog concerné une sortie graphique du logiciel de circuit imprimé, complétée par la correction à effectuer! Le monsieur n'est pas très fairplay!

Rappel : pour mettre à jour le firmware du système je n'utilise pas la méthode préconisée, à savoir un programmateur de processeur Propeller, mais une simple copie du fichier binaire en EEPROM à l'aide d'un programmateur d'EEPROM. Or, jusqu'à ce que je découvre la bonne configuration de la compilation, le système plantait systématiquement avec l' appui sur la touche F8 devant permettre l'affichage du contenu de la SDcard. Or donc, voici la bonne configuration :

Le fichier .eeprom est correctement généré avec ces paramètres.

Il suffit dès lors de demander la compilation "Compile and save EEPROM" pour obtenir le fichier adéquat.
 
Par ailleurs, j'ai modifié les codes 'premiers' des touches alphabétiques du clavier pour avoir l'équivalent du clavier Français. Et cette fois, cela fonctionne très bien. Je me contenterai de stickers pour indiquer les signes des autres touches, en particulier ceux des touches alphanumériques.

Ce système est maintenant prêt pour diverses expérimentations intéressantes avec quand même bien plus de puissance que mon Tandy TRS-80 PC2 d'origine, et la même facilité d'utilisation puisqu'il suffit d'un écran pour avoir une machine autonome. Plus besoin de PC!

Fin d'update


Mise en situation : le système fourni est tout à fait satisfaisant, mis à part le petit problème que j'ai soulevé dans mon billet précédent. Il concerne la mise en buffer des caractères en provenance du processeur MicroMite lorsque le débit de ceux-ci est rapide. Le système est livré avec la prise en compte du clavier 'qwerty'. A la longue, cela s'avère assez ennuyeux. L'idée vient donc tout naturellement de tenter la 'francisation' du système.

Avant toute chose, j'ai téléchargé le logiciel de développement adapté à l'opération visée. J'ai opté pour la suite d'outils gratuite BST que l'on peut trouver à cet endroit. Le site de développement du 'Micromite Companion' propose les sources du système directement au format BST. Le logiciel est bien fait, pratique et très facile à prendre en main : 

BST ne réclame aucune installation. Il est disponible dès son téléchargement effectué.

Les sources du système doivent aussi être récupérés à cet endroit. Une fois ces opérations effectuées, il ne reste plus qu'à étudier le code source pour juger de la faisabilité du changement de 'layout' du clavier. A priori cela ne semble pas très compliqué puisque l'ensemble des sources du système contient un fichier nommé 'Keyboard.spin'. L'extension 'spin' représentant un source assembleur spécifique au processeur Propeller. 

Une simple recherche à l'intérieur de ce fichier révèle la table des codes utilisés pour la translation des 'scan code' du clavier en code ASCII utilisables par le système : 

1:  table       word  $0000  '00  
2:              word  $00D8  '01       F9  
3:              word  $0000  '02  
4:              word  $00D4  '03       F5  
5:              word  $00D2  '04       F3  
6:              word  $00D0  '05       F1  
7:              word  $00D1  '06       F2  
8:              word  $00DB  '07       F12  
9:              word  $0000  '08  
10:             word  $00D9  '09       F10  
11:             word  $00D7  '0A       F8  
12:             word  $00D5  '0B       F6  
13:             word  $00D3  '0C       F4  
14:             word  $0009  '0D       Tab  
15:             word  $0060  '0E       `  
16:             word  $0000  '0F  
17:             word  $0000  '10  
18:             word  $F5F4  '11   Alt-R  Alt-L  
19:             word  $00F0  '12       Shift-L  
20:             word  $0000  '13  
21:             word  $F3F2  '14   Ctrl-R Ctrl-L  
22:             word  $0071  '15       q  
23:             word  $0031  '16       1  
24:             word  $0000  '17  
25:             word  $0000  '18  
26:             word  $0000  '19  
27:             word  $007A  '1A       z  
28:             word  $0073  '1B       s  
29:             word  $0061  '1C       a  
30:             word  $0077  '1D       w  
31:             word  $0032  '1E       2  
32:             word  $F600  '1F   Win-L  
33:             word  $0000  '20  
34:             word  $0063  '21       c  
35:             word  $0078  '22       x  
36:             word  $0064  '23       d  
37:             word  $0065  '24       e  
38:             word  $0034  '25       4  
39:             word  $0033  '26       3  
40:             word  $F700  '27   Win-R  
41:             word  $0000  '28  
42:             word  $0020  '29       Space  
43:             word  $0076  '2A       v  
44:             word  $0066  '2B       f  
45:             word  $0074  '2C       t  
46:             word  $0072  '2D       r  
47:             word  $0035  '2E       5  
48:             word  $CC00  '2F   Apps  
49:             word  $0000  '30  
50:             word  $006E  '31       n  
51:             word  $0062  '32       b  
52:             word  $0068  '33       h  
53:             word  $0067  '34       g  
54:             word  $0079  '35       y  
55:             word  $0036  '36       6  
56:             word  $CD00  '37   Power  
57:             word  $0000  '38  
58:             word  $0000  '39  
59:             word  $006D  '3A       m  
60:             word  $006A  '3B       j  
61:             word  $0075  '3C       u  
62:             word  $0037  '3D       7  
63:             word  $0038  '3E       8  
64:             word  $CE00  '3F   Sleep  
65:             word  $0000  '40  
66:             word  $002C  '41       ,  
67:             word  $006B  '42       k  
68:             word  $0069  '43       i  
69:             word  $006F  '44       o  
70:             word  $0030  '45       0  
71:             word  $0039  '46       9  
72:             word  $0000  '47  
73:             word  $0000  '48  
74:             word  $002E  '49       .  
75:             word  $EF2F  '4A   (/)   /  
76:             word  $006C  '4B       l  
77:             word  $003B  '4C       ;  
78:             word  $0070  '4D       p  
79:             word  $002D  '4E       -  
80:             word  $0000  '4F  
81:             word  $0000  '50  
82:             word  $0000  '51  
83:             word  $0027  '52       '  
84:             word  $0000  '53  
85:             word  $005B  '54       [  
86:             word  $003D  '55       =  
87:             word  $0000  '56  
88:             word  $0000  '57  
89:             word  $00DE  '58       CapsLock  
90:             word  $00F1  '59       Shift-R  
91:             word  $EB0D  '5A   (Enter) Enter  
92:             word  $005D  '5B       ]  
93:             word  $0000  '5C  
94:             word  $005C  '5D       \  
95:             word  $CF00  '5E   WakeUp  
96:             word  $0000  '5F  
97:             word  $0000  '60  
98:             word  $0000  '61  
99:             word  $0000  '62  
100:            word  $0000  '63  
101:            word  $0000  '64  
102:            word  $0000  '65  
103:            word  $00C8  '66       BackSpace  
104:            word  $0000  '67  
105:            word  $0000  '68  
106:            word  $C5E1  '69   End   (1)  
107:            word  $0000  '6A  
108:            Word  $C0E4  '6B   Left  (4)  
109:            word  $C4E7  '6C   Home  (7)  
110:            word  $0000  '6D  
111:            word  $0000  '6E  
112:            word  $0000  '6F  
113:            word  $CAE0  '70   Insert (0)  
114:            word  $C9EA  '71   Delete (.)  
115:            word  $C3E2  '72   Down  (2)  
116:            word  $00E5  '73       (5)  
117:            word  $C1E6  '74   Right  (6)  
118:            word  $C2E8  '75   Up   (8)  
119:            word  $00CB  '76       Esc  
120:            word  $00DF  '77       NumLock  
121:            word  $00DA  '78       F11  
122:            word  $00EC  '79       (+)  
123:            word  $C7E3  '7A   PageDn (3)  
124:            word  $00ED  '7B       (-)  
125:            word  $DCEE  '7C   PrScr  (*)  
126:            word  $C6E9  '7D   PageUp (9)  
127:            word  $00DD  '7E       ScrLock  
128:            word  $0000  '7F  
129:            word  $0000  '80  
130:            word  $0000  '81  
131:            word  $0000  '82  
132:            word  $00D6  '83       F7  
133:    
134:  keypad1   byte  $CA, $C5, $C3, $C7, $C0, 0, $C1, $C4, $C2, $C6, $C9, $0D, "+-*/"  
135:    
136:  keypad2   byte  "0123456789.", $0D, "+-*/"  
137:    
138:  shift1    byte  "{|}", 0, 0, "~"  
139:    
140:  shift2    byte  $22, 0, 0, 0, 0, "<_>?)!@#$%^&*(", 0, ":", 0, "+"  
141:  

Rien de bien renversant. Les codes présents jusqu'aux lignes 132 représentent 'à peu près' la translation des scan codes du clavier en code ASCII lorsque aucune touche d'altération n'est utilisée (MAJ, SHIFT etc...).

Les lignes Keypadx fournissent les codes ASCII particuliers du pavé numérique en mode verrouillage numérique et en mode sans verrouillage numérique.

Les lignes Shiftx fournissent les codes de certaines touches lorsqu'une des touches Shift est utilisée.
Shift2 fournit le code 'second' des touches numériques de la partie non pavé numérique, Shift1 fournit le code de certaines autres touches ne faisant pas parti des lettre standards de l'alphabet ni de la partie numérique du clavier de base.

L'opération consistant à modifier l'affectation des touches de base est très simple. Il suffit de placer le code voulu la ou se situe le code d'origine à remplacer dans la table par exemple :

22:             word  $0071  '15       q 

à remplacer par :

22:             word  $0061  '15       a 

et ainsi de suite pour tous les code 'premiers' devant être modifiés.

Concernant le traitement des touches shift, la translation ne peut se faire sans toucher au code du programme. En effet, l'auteur s'est appuyé sur la disposition des touches numériques du clavier Américain pour modifier par ajout d'un offset, l'index pointant sur la table afin de pointer réellement sur une des deux lignes Shift1 ou Shift2. La chose est rendue possible parce que les chiffres de 0 à 9 sont présents directement sur la ligne du haut du clavier, sans avoir à utiliser la touche Shift, comme cela doit se faire sur un clavier Français. De ce fait, en considérant le mode de fonctionnement du clavier Français, il n'est plus possible de modifier l'index de code ASCII par simple ajout d'une valeur aux codes de base des chiffres, qui se suivent fort opportunément de 0x30 à 0x39 dans le cas du clavier américain. Il devient alors nécessaire de reprogrammer une partie du code traitant la translation SCAN code vers code ASCII.

Pour contourner simplement le problème, il est possible de considérer que la ligne du haut fournit les codes des chiffres sans avoir recours à la touche Shift, et que l'appui sur la touche 'seconde' fournira les autres codes comme '&~"'(-`_^@)' par exemple. Il suffit de remplacer la ligne suivante :

140:  shift2    byte  $22, 0, 0, 0, 0, "<_>?)!@#$%^&*(", 0, ":", 0, "+"  

par celle-ci :

140:  shift2    byte  $22, 0, 0, 0, 0, "<_>?)&~"'(-`_^@", 0, ":", 0, "+"  

Quelques ajustement et choix de dispositions de touches s'avère quand même nécessaire puisqu'il y aura un problème avec la séquence '()' étant donné que le caractère ')' se trouve sur la touche '°' et que cette dernière n'est pas traitée par la ligne Shift2.

Le principe de base est donc relativement simple, et moyennant quelques agencements, il est possible de 'déclarer' assez facilement un clavier 'Français' beaucoup plus facile à utiliser.

La compilation : une fois le fichier Keyboard.spin enregistré, il est nécessaire de sélectionner le fichier nommé umitecompanion.spin dans l'outil BST et d'en demander la compilation qui devrait s'effectuer sans problème après avoir sélectionné les options suivantes dans le menu 'Tools/Compiler Préférences' :

Personnellement, je compile en utilisant la fonction 'Compile and save binary'. Ce qui a pour effet de générer un fichier binaire nommé umitecompanion.binary.

Intégrer ce nouveau fichier sur le système est assez simple. Le processeur Propeller à ceci de caractéristique de charger dans sa RAM interne, le contenu de l'EEPROM présente sur le montage. En fait le processeur commence par tenter de charger sa RAM à partir de sa ROM interne mais si cette ROM interne ne contient pas de données, alors le processeur passe au chargement depuis l'EEPROM externe. Cette fonctionnalité de boot est très pratique puisqu'il suffit de modifier le contenu de l'EEPROM pour modifier le système.

Je possède depuis quelques années un programmateur spécifiquement dédié à la programmation des EEPROM diverses et variées, le EZP2010 :

Cet appareil est disponible pour quelques Euros à différents endroits, sur eBay notamment. L'appareil que je possède était livré avec les drivers pour Windows Vista, au mieux. La première tentative d'installation sous Windows 7 en version 64 bits s'est donc soldée par un échec.

J'ai donc récupéré sur le Net, le package logiciel dénommé EZP2010_V3.0 et ai installé l'appareil avec le nouveau driver. Cette installation s'est correctement déroulée mais le logiciel, aussi fourni dans le package, ne reconnaissait toujours pas le programmateur. Il m'a donc fallu effectuer la mise à jour du firmware du programmateur par la version elle aussi disponible dans le package logiciel, sur un ordinateur équipé de Windows XP.

Recommandation : avant de ne plus avoir sous la main de PC fonctionnant sous Windows XP ou Vista, mettez votre programmateur EZP2010 à jour, sinon vous le perdrez en même temps que vous vous débarrasserez de votre ancienne version de Windows! On flirte ici avec l'obsolescence programmée...

Une fois le programmateur opérationnel, et le fichier binaire disponible, la programmation de l'EEPROM s'avère triviale :

Il suffit alors de remplacer l'EEPROM nouvellement programmée sur le support équipant la carte électronique pour qu'à la mise sous tension, les modifications soient disponibles.

Note : en y regardant de plus près, vous remarquerez que j'ai programmé l'EEPROM avec le fichier umitecompanion.eeprom. J'ai récupéré ce fichier du dépôt sur le site proposant le MicroMite Companion cité plus haut.

Parce que la compilation à partir des sources génère un binaire qui ne correspond pas au binaire directement récupéré. Un possible manque de mise à jour des sources peut expliquer ce phénomène. Ceci se traduit par un plantage du système lors de l'appui sur la touche F8, sensée lister le contenu de la SD card. Ce problème est fort ennuyeux car avec les quelques modifications simples effectuées précédemment sur le positionnement des touches du clavier, l'utilisation d'un système 'presque' Français était devenu bien plus agréable.

Bilan :  mon idée initiale ne fonctionne pas vraiment, ou pas encore, du fait de l'impossibilité de compiler un système stable avec les sources disponibles. Peut-être vais-je contacter les initiateurs de ce projet pour leur faire part de ce problème, ainsi que celui de la patte du processeur restée 'en l'air'. L'idée de ce projet est tout à fait intéressante, mais elle manque peut-être d'un peu plus de finalisation.

Ceci dit, de base, le système fonctionne très bien, et si le besoin s'en fait sentir, un environnement de développement simple et efficace est disponible pour compiler du code SPIN, la mise à jour du firmware est très facile en passant par un programmateur d'EEPROM. La rapidité d'exécution du code Basic par le processeur MicroMite est tout à fait impressionnante. Le tout pour un coût de quelques Euros.