Pour mettre en pratique ce que j'ai appris sur le LPC810 j'ai réalisé un jeux PONG sur le LPC810. Le montage est si simple qu'il tiens sur une carde perma-proto 1/4.

Montage

schématique

Liste du matériel

• 1 MCU LPC810M021FN28, U1
• 1 carte perma-proto 1/4.Un produit de bonne qualité. Peut-être soudé sur les 2 faces, pratique pour les SMD 0805 (voir photo du prototype ci-haut).
• 2 jack RCA phono, J1 jaune (vidéo), J2 blanc (audio)
• 1 LED rouge 3mm, D2
• 2 résistances 120 ohm 1/8 watt, R3,R8.
• 1 résistance 620 ohm 1/8 watt, R1.
• 1 résistance 680 ohm 1/8 watt, R2.
• 2 résistances 1Kohm 1/8 watt, R6, R7.
• 2 résistance 10Kohm 1/8 watt, R4, R5.
• 2 potentiomètre 10Kohm linéaire, P1, P2.
• 1 condensateur céramique 2,2nF, C1
• 4 condensateurs céramique 100nF, C2,C3,C4,C5. J'ai utilisé un format SMD 0805 car c'est juste de la bonne dimension pour être souder entre deux rangés adjacentes.
• 1 diode schottkey 1N6263, D1
• 2 boutons momentanés SW1, SW3.
• 1 porte pile avec commutateur pour 2 piles AA ou AAA
• 1 barrette de pin header 100mil.

Démo

Description du programme

L'ensemble du projet LPCXpresso est sur github sous licence GPLv3. Vous pouvez télécharger le fichier zip et l'importer dans l'IDE LPCXpresso. Le projet doit être compilé avec l'option -O2 sinon il n'y a pas suffisamment d'espace flash.

Le jeux est contrôlé par des potentiomètres de 10Kohm. Chaque joueur en a un. Le pointage apparait en haut de l'écran. Le gagnant est celui qui atteint 21 points le premier. La balle est collée sur la raquette du joueur qui a le service. Le joueur doit déplacer sa raquette pour lancer la balle. La direction que prend la balle est tirée au hasard. ATTENTION! au démarrage le potentiomètre que est branché sur la broche 5 doit-être en position Vdd. S'il est en position Vss le bootloader va entrer en mode programmation au lieu de démarrer le jeux.

Le fichier hardware.c Initialise les périphériques utilisés. Le PLL permet de monter la fréquence à 30Mhz. Le SCT génère le signal vidéo et le signal audio. Le MRT est utilisé pour les délais. Le comparateur analogique est utilisé pour lire les potentiomètres. Il y a deux gestionnaires d'interruption d'utilisé, l'un pour la génération audio MRT_IRQHandler() situé dans hardware.c, l'autre pour la génération des signaux vidéo SCT_IRQHandler() situé dans tvout.c.

Le fichier tvout.c génère un signal NTSC composite monochrome. La résolution est de 64x56 pixels et le video_buffer occupe 448 octets RAM des 1024 disponible. Comme toujours j'utilise un PWM pour la synchronisation et un périphérique SPI pour sérialiser les pixels vidéo.

Les potentiomètres qui contrôle les raquettes des joueurs sont branchés sur les 2 entrées du comparateur analogique ACMP_I1 et ACMP_I2. Ce comparateur contient une référence de voltage programmable sur 32 niveaux. J'ai donc décidé d'utiliser cette référence en conjonction avec le comparateur pour créer un convertisseur A/N à 5 bits. Le convertisseur est de type SAR (Successive Approximation Register). Pour son fonctionnement voir la routine read_pot() dans le fichier hardware.c. La routine fait une division binaire de L'intervalle pour obtenir un résultat en 5 comparaisons.

Tout le code est écris en 'C' et peut-être adapter facilement à un autre MCU LPC. Le fichier tvout.c est particulièrement utile pour l'utilisation dans d'autres projets avec sortie vidéo NTSC. Il peut être adapté facilement au standard PAL en modifiant les constantes dans le fichier tvout.h

Dans cet article je discute du comparateur analogique. Celui-ci possède une référence de voltage programmable sur 32 niveaux. Dans le démo j'utilise cette référence programmable pour créer un convertisseur analogique/numérique avec un résolution de 5 bits. Un potentiomètre est lu et sert à contrôler l'intensité d'une LED par PWM.

Le LPC810 possède 2 entrées analogiques, ACMP0_1 et ACMP0_2. L'entrée ACMP0_1 peut-être reliée à la broche 8 et l'entrée ACMP0_2 peut-être reliée à la broche 5. Cette liaison se fait par le registre LPC_SWM->PINENABLE0. Chacune de ces 2 entrées peut-être connectée soit à l'entrée positive, soit la négative du comparateur. C'est le registre LPC_CMP->CTRL qui sert à effectuer les branchements sur les entrées du comparateur. Dans le démo ci-bas, l'entrée ACMP0_1 est branchée sur l'entrée positive du comparateur. L'entrée négative du comparateur est reliée à la sortie de la référence de voltage programmable (Voltage ladder).

Un comparateur analogique fonctionne de la façon suivante, Il y a 2 entrées, une positive et l'autre négative. Lorsque le voltage sur l'entrée positive est plus élevé que celui sur l'entrée négative la sortie du comparateur est à 1 sinon elle est à 0. Le symbole d'un comparateur est le suivant:

Mais si les 2 voltages sont égaux? Les entrées des comparateurs sont conçues pour avoir ce qu'on appelle de l’hystérésis. L'idée est la suivante, supposons que l'entrée négative est branchée sur une référence de voltage fixe et que la positive est branchée sur un signal variable. Sitôt que l'entrée positive dépasse l'entrée négative la sortie du comparateur passe à 1. Mais à cause du bruit s'il n'y avait pas d'hystérésis la sortie pourrait commuter rapidement entre 0 et 1. Mais l'hystéris fait que l'entrée positive doit redescendre d'une certaine valeur avant que la sortie ne repasse à zéro. Le comparateur du LPC810 a une hystérésis programmable avec 4 valeurs possibles, 0mV, 5mV, 10mV et 20mV. Ces valeurs représentent la variation minimale de voltage entre les 2 entrées pour que la sortie commute à nouveau. Donc si on programme 20mV et que le voltage sur l'entrée positive monte jusqu'à ce que la sortie passe à 1. Ce voltage doit redescendre d'au moins 20mV avant que la sortie ne repasse à zéro.

Si le signal d'entrée est bruyant on utilise une hystérésis forte, s'il est propre on utilise une hystérésis faible. Dans le démo j'ai programmé l'hystérésis à 20mV. Mon calcul est le suivant, le potentiomètre est alimenté à 3 volts, 3/32 donne 94mV donc on peut utiliser l'hystérésis maximale sans perdre de résolution sur le potentiomètre tout en maximisant l'immunité aux interférences.

Un convertisseur A/N improvisé

Le LPC810 n'a pas de convertisseur A/N mais on peut en improviser un en utilisant le comparateur et la référence de voltage programmable. Ce convertisseur n'a qu'un résolution de 5 bits étant limité par la résolution du voltage ladder.

Voici comment fonctionne le convertisseur à 5 bits. On commence par programmer le voltage ladderà sa valeur médiane. Si la sortie du comparateur est à 1 c'est que le voltage sur l'entrée positive est supérieur à 1,5volt, sinon il est inférieur à cette valeur. On change la valeur de référence en fonction de l'état de sortie du comparateur. Si la sortie est à 1, on programme le voltage ladderà la position médiane entre 1,5 volts et 3 volts. Si la sortie du comparateur est à 0 on programme le voltage ladderà la position médiane entre 0 volt et 1,5 volts. On vérifie encore la sortie du comparateur et chaque fois que c'est à 1 on augmente le voltage du voltage ladder de la moitié de l'intervalle restant. Par cette division binaire de l'intervalle restant on obtient un résultat avec 5 comparaisons. Cette technique de conversion A/N s'appelle convertisseur à approximations successives. C'est le type de convertisseur le plus souvent utilisé sur les MCU. Le nombre de comparaisons nécessaires est le nombre de bits de résolution du convertisseur, 8,10 ou 12. Ce type de conversion est plus rapide que le sigma-delta ou les convertisseurs à pente.

Schématique du montage

Code source du démo

utilisation des resssources

• La LED est branchée sur PIO0_2 (broche 4).
• Le bras mobile du potentiomètre est branché sur PIO0_0 (broche 8) qui est utilisé en mode analogique.
• Le canal 1 du MRT (Multi Rate Timer) est utilisé pour générer une interruption 50 fois par seconde.
• Le module SCT est utilisé pour générer un signal PWM dont le rapport cyclique est contrôlé par le potentiomètre. La sortie COUT0 du SCT est reliée à PIO0_2 et contrôle l'intensité de la LED.
• Le comparateur analogique avec la référence programmable est utilisé comme convertisseur A/N à 5 bits pour lire le potentiomètre.

/* * hardware.h * * Created on: 2014-06-18 * Author: Jacques */ #ifndef LPC810_H_ #define LPC810_H_ #include <lpc8xx.h> #define LED (2u) // sortie LED PIO0_2 #define POT (0u) // entrée potentiomètre PIO0_0 #define delay_us(n) {int i; for(i=(n*USEC)>>3;i;i--)asm("nop\n nop\n nop\n nop");} #define m_set_output_pin(bit) LPC_GPIO_PORT->DIR0|=(bit) #define SYS_CLOCK (12000000UL) // fréquence SYS_CLOCK 30Mhz #define MSEC (SYS_CLOCK/1000) // Tcy/milliseconde #define USEC (SYS_CLOCK/1000000) // Tcy/µsec // bits dans PINENABLE0 #define DIS_ACMP_I1 (1<<0) // analog compare input 1 on PIO0_0 #define DIS_ACMP_I2 (1<<1) // analog compare input 2 on PIO0_1 #define DIS_SWCLK (1<<2) // single wire debug clock on PIO0_3 #define DIS_SWDIO (1<<3) // single wire debug data i/o on PIO0_2 #define DIS_XTALIN (1<<4) // disable crystal in on PIO0_8 #define DIS_XTALOUT (1<<5) // disable crystal out on PIO0_9 #define DIS_RESET (1<<6) // disable reset on PIO0_5 #define DIS_CLKIN (1<<7) // disable clkin on PIO0_1 #define DIS_VDDCMP (1<<8) // disable Vdd compare on PIO0_6 #define m_disable_pin(pins) LPC_SWM->PINENABLE0 |= (pins) // bits dans SYSAHBCLKCTRL #define CLK_SYS (1<<0) #define CLK_ROM (1<<1) #define CLK_RAM (1<<2) #define CLCK_FLASHREG (1<<3) #define CLK_FLASH (1<<4) #define CLCK_I2C (1<<5) #define CLK_GPIO (1<<6) // bit activation signal clock sur GPIO L #define CLK_SWM (1<<7) #define CLK_SCT (1<<8) // bit activation signal clocks ur SCT #define CLK_WKT (1<<9) #define CLK_MRT (1<<10) // bit activation MRT #define CLK_SPI0 (1<<11) #define CLK_SPI1 (1<<12) #define CLK_CRC (1<<13) #define CLK_UART0 (1<<14) #define CLK_UART1 (1<<15) #define CLK_UART2 (1<<16) #define CLK_WWDT (1<<17) #define CLK_IOCON (1<<18) #define CLK_ACMP (1<<19) // activation AHBCLK sur SWM #define m_swmclk_enable() LPC_SYSCON->SYSAHBCLKCTRL |= (CLK_SWM) // désactivation AHBCLK sur SWM #define m_swmclk_disable() LPC_SYSCON->SYSAHBCLKCTRL &= (~CLK_SWM) // activation du signal clock pour les périphériques utilisés #define m_periph_clock_enable(peripherals) LPC_SYSCON->SYSAHBCLKCTRL |= (peripherals) // désactivation du signal clock pour sur les périphériques sélectionnés #define m_periph_clock_disable(peripherals) LPC_SYSCON->SYSAHBCLKCTRL &= ~(peripherals) // bits dans PRESETCTRL #define RESET_SPI0 (1<<0) #define RESET_SPI1 (1<<1) #define RESET_UARTFRG (1<<2) #define RESET_UART0 (1<<3) #define RESET_UART1 (1<<4) #define RESET_UART2 (1<<5) #define RESET_I2C (1<<6) #define RESET_MRT (1<<7) #define RESET_SCT (1<<8) #define RESET_WKT (1<<9) #define RESET_GPIO (1<<10) #define RESET_FLASH (1<<11) #define RESET_ACMP (1<<12) // réinitialise les périphériques #define m_periph_reset(peripheral) {LPC_SYSCON->PRESETCTRL &=~(peripheral);LPC_SYSCON->PRESETCTRL |= (peripheral);} #endif /* LPC810_H_ */ </lpc8xx.h>

/* =============================================================================== Name : main.c Author : $(author) Version : Copyright : $(copyright) Description : démonstration de l'utilisation du comparateur analogique la référence de voltage à 32 niveaux est utilisée en conjonction avec le comparateur analogique pour créé un convertisseur A/N de 5 bits Le potientiomètre est branché sur ACMP0_I1 La lecture du potentiomètre sert à contrôler l'intensité de la LED branchée sur PIO0_2. Le périphérique SCT est utilisé pour générer un signal PWM pour contrôler l'intensité de la LED. le MCU est en mode sleep et s'éveille 50 fois par secondes pour faire la lecture du potentiomètre. =============================================================================== */ #ifdef __USE_CMSIS #include "LPC8xx.h" #endif #include <cr_section_macros.h> #include "hardware.h" /* * utilisation du comparateur analogique avec la référence de * voltage à 32 niveaux pour créer un convertisseur A/N à 5 bits * la lecture se fait par approximation successive en divisant * l'intervalle en 2 à chaque test. Cette division binaire * permet d'obtenir un résultat en 5 comparaisons. */ int read_pot(){ int min,max,test,count,last,current; min=0; max=31; test=15; while ((test<max>min)){ LPC_CMP->LAD&=~(1|(31<<1u)); LPC_CMP->LAD|=1|(test<<1u); // délais pour laisser le temps à la nouvelle valeur de se stabiliser. delay_us(5); count=0; last=1; while (count<5){ current=LPC_CMP->CTRL&(1u<<21u); if (current==last){ count++; }else{ last=current; count=0; } delay_us(1); } if (last){ min=test; test=test+((max-test)>>1); }else{ max=test; test=test-((test-min)>>1); } } return test; }//f() // lecture du potentiomètre // recharge du registre MATCHREL // avec la valeur lue. // le facteur 1875 correspond au // compte du registre MATCH[0]/32 void MRT_IRQHandler(){ if (LPC_MRT->Channel[1].STAT&1){ LPC_SCT->MATCHREL[1].L=read_pot()*1875; LPC_MRT->Channel[1].STAT=1; } }//SCT_IRQHandler // configuration du SCT pour produire le PWM 16 bits qui contrôle la LED void config_pwm(){ LPC_SCT->CONFIG = (1u<<17); // compteur 16 autolimit sur MATH[0].L LPC_SCT->STATE_L=0; // état machine reste à zéro LPC_SCT->REGMODE_L=0; // mode match. LPC_SCT->MATCH[0].L = (SYS_CLOCK/200); // fréquence 200Hz LPC_SCT->MATCHREL[0].L=(SYS_CLOCK/200); LPC_SCT->MATCH[1].L = (SYS_CLOCK/200>>1); // rapport cyclique 50% LPC_SCT->MATCHREL[1].L=(SYS_CLOCK/200>>1); // événement 0 allume la LED LPC_SCT->EVENT[0].CTRL=(1u<<5)|(1u<<12); //contrôle CTOUT_0, condition CTR_L==MATCH[0].L LPC_SCT->EVENT[0].STATE=(1u<<0); // événement actif lorsque STATE_L==0 LPC_SCT->OUT[0].SET=(1u<<0); // contrôlé par événement 0 // événement 1 éteint la LED LPC_SCT->EVENT[1].CTRL=1u|(1u<<5)|(1u<<12); // contrôle CTOUT_0, condition CTR_L==MATCH[1].L LPC_SCT->EVENT[1].STATE=(1u<<0); // événement actif lorsque STATE_L==0 LPC_SCT->OUT[0].CLR=(1u<<1); // contrôlé par événement 1 //démarre le PWM LPC_SCT->CTRL_L = (LPC_SCT->CTRL_L & ~(3u << 1))|(1u<<3); }//f() // Le ou les bits qui contrôle la fonction dans le registre sont indiqué // entre parenthèse dans le commentaire après le nom de la fonction. int main(void) { // activation du AHBCLK pour les périphériques SWM(7), ACMP(19), MRT(10) et SCT(8) m_periph_clock_enable(CLK_SWM|CLK_ACMP|CLK_MRT|CLK_SCT); // désactivation des fonctons SWCLK(2), SWDIO(3), CLKIN(7) LPC_SWM->PINENABLE0 |=(1u<<2)|(1u<<3)|(1u<<7); // réinitialise les périphériques MRT(7), SCT(8), ACMP(12) de l'état "RESET" m_periph_reset(RESET_MRT|RESET_SCT|RESET_ACMP); // branchement de l'entrée du comparateur ACMP0_I1(0) sur PIO0_0 LPC_SWM->PINENABLE0 &= ~(1u<<0); // COUT_0(31:24) sur PIO0_LED LPC_SWM->PINASSIGN6 = 0x00ffffff|(LED<<24); // désactivaton du AHBLCK sur SWM(7) m_swmclk_disable(); // activation activation du comparateur analogique (15) LPC_SYSCON->PDRUNCFG &= ~(1u<<15); // branchement de ACMP0_I1(10:8) sur l'entrée positive du comparateur //hystérésie du comparateur 20mV (26:25). LPC_CMP->CTRL=(1u<<8)|(3u<<25); // activation de la référence de voltage programmable 32 niveaux, LADEN(0) LPC_CMP->LAD |=1u; // contrôle de l'intensité de la LED par PWM config_pwm(); // délais pour laisser le temps à la référence de voltage de se stabiliser. delay_us(200); // programmation du canal 1 du MRT pour delais lecture pot. LPC_MRT->Channel[1].CTRL=1u|(0u<<1); // mode "repeat interrupt" LPC_MRT->Channel[1].INTVAL=(SYS_CLOCK/50); // interruption 50 fois par seconde // configuration de l'interrption MRT // niveau de priorité 3 NVIC_SetPriority(MRT_IRQn,3); // plus basse priorité //activation de l'interrption MRT NVIC_EnableIRQ(MRT_IRQn); // au lieu d'utiliser une boucle while on met le MCU en mode SLEEP SCB->SCR |= (1u<<1); // retourne au mode SLEEP à la sortie de l'interruption __WFI(); // entre en mode sleep et attend pour une interruption. // si tout fonctionne comme prévu le programme ne devrait pas arrivé ici. return 0 ; } </max></cr_section_macros.h>

C'est la fonction read_pot() qui implémente le convertisseur A/N. La fonction main() ne fait qu'initialiser les périphériques.

Une fois que le module SCT est configuré pour généner un signal PWM à une fréquence 200 hertz le MCU est mis en mode sleep. En mode sleep le PWM continu à fonctionner mais le core M0+ est arrêté. Le module MRT est utilisé pour générer une interruption 50 fois par seconde. Le gestionnaire d'interruption MRT_IRQHandler() fait une lecture du potientiomètre et ajuste le rapport cyclique du PWM en fonction de cette lecture. A la sortie du gestionnaire d'interruption le MCU retourne en mode sleep. l'instruction __WFI() est une macro pour l'instruction en assembleur wfiWait For Interrupt. Cette instruction suspend le core jusqu'à ce qu'il y est une interruption.

Liens vers les articles précédents:

1. Introduction au LPC810 (ARM M0+)
2. LPC810, partie 2, anatomie
3. LPC810, création d'un projet
4. LPC810, partie 4, programmation
5. LPC810, partie 5, module SCT et PWM
6. LPC810, partie 8, pong

Cet article concerne l'histoire de l'informatique, j'y parle du premier système d'exploitation pour micro-ordinateur, CP/M l'ancêtre du DOS.

Les premiers ordinateurs n'avaient pas de système d'exploitation et n'était pas interactif. Un programme était écris pour être ensuite chargé dans la machine pour exécution. Il y avait alors sur ces machines ce qui s’appelait un programme de contrôle. Ce programme présentait à l'opérateur une interface de commande simple lui permettant de charger et d'exécuter les programmes et autres tâches nécessaire à l'utilisation de la machine. Les programmes étaient souvent exécutés en lot (batch). Les programmes étaient fournis à la machine sous forme de ruban ou de carte perforées. Lors de mon premier cours d’informatique je programmais sur des cartes perforées dans un langage appelé FORTRAN IV. On écrivait notre programme à la main sur papier pour ensuite transcrire ce code source sur des cartes en utilisant la machine appelée justement perforatrice¹. Nous déposions nos cartes sur une étagère à l'entrée d'un local et le lendemain nous allions chercher le résultat sur la même étagère. Tous les programmes étaient exécutés en lot pendant la nuit. Ce n'était pas vraiment excitant l'informatique à cette époque. C'était au début des années 70.

Control Program for Micro-computer

Donc au milieu des années 70 une compagnie du Nouveau Mexique appelée Micro Instrumentation and Telemetry Systems, MITS a mis sur le marché le premier micro-ordinateur digne de ce nom, l'Altair 8800 qui utilisait le microprocesseur 8080 d'Intel. C'est alors que Gary Kildall a décidé de créer un programme de contrôle pour cet ordinateur en s'inspirant de ce qui se faisait à l'époque sur les Mainframe. Sa femme et lui on créé une compagnie qui s’appelait Digital Research Inc dans le but de vendre ce programme baptisé CP/M, signifiant Control Programm for Micro-computer.

BIOS

C'est alors que de nombreuses compagnies sont entrées dans le marché des micro-ordinateurs en utilisant l'Intel 8080 ou sa version amélioré le Z80 fabriqué par Zilog². Gary Kildall devait donc porté son CP/M pour ces différentes machines. C'est alors qu'il eu l'idée de séparer les fonctions de bases qui contrôle directement le matériel des fonctions de plus haut niveau. De cette façon pour modifier CP/M pour qu'il fonctionne sur une autre machine il n'avait qu'à modifier ces fonctions de bases sans avoir à modifier le reste du système. Il baptisa cette couche d'abstraction matérielle le Basic Input Output System, BIOS.

Évolution

MS-DOS de Microsoft a été directement inspiré par CP/M. Lorsque les PC sont sortie sur le marché avec leur processeur 16 bits Intel 8088 et 8086. Microsoft a créé MS-DOS en s'inspirant de CP/M. Les fabriquants de PC fournissaient la couche d'abstraction matérielle qui avait été standardisé en conservant le nom que lui avait donné Kildall, BIOS. Le BIOS interfaçait avec le DOS via les fonctions de l'interruption 13_hex. Les applications interfaçaient DOS via les fonctions de l'interruption 21_hex.

Système d'exploitation

Les interfaces utilisateurs graphiques apparues avec Apple MacIntosh et Microsoft Windows ont mis fin à l'évolution de CP/M et MS-DOS, DR-DOS³ et IBM-DOS⁴, quoiqu'il existe encore une version libre appelée FREEDOS ainsi que l'émulateur DOSBOX qui tournent sur les systèmes d'exploitation modernes tel que Linux,OSX et Windows.

Aujourd’hui tous les systèmes d'exploitations utilisent cette structure en multi-couches appelée en anglais software stack. Au plus bas niveau il y a la couche d'abstraction matérielle Hardware Abstraction LayerHAL. Au dessus de celle-ci il y a les pilotes de périphériques. Ensuite viens le noyaux du système d'exploitation qui dans un système moderne est le seul qui est autorisé à parler au pilotes de périphériques. Finalement il y a les applications dans la couche utilisateur. Chaque couche présente une interface standardisée à la couche supérieur ce qui a 2 avantages. Premièrement ça rends le système plus facilement transportable sur une autre machine ou architecture car les couches supérieures ne sont pas affectées par les détails de l'implémentation des couches inférieures et n'ont donc pas besoin d'être modifiées chaque fois qu'une couche inférieure l'est. Deuxièment ça facilite la création de programmes ou pilotes, le programmeur n'ayant qu'à connaître les fonctions de l'interface sans se soucier des détails sous-jacents.

1) Il existait aussi des trieuses de cartes pour venir au secours de ceux qui avaient le maleur de laissé tomber leur boite à chaussure remplie de cartes perforées. C'est peut-être pour ça qu'à l'époque il y avait une instruction par carte et que chaque carte débutait avec un numéro de ligne.
2) Zilog existe encore et est maintenant un fabriquant de Microcontroleurs. Ils vendent encore une version CMOS du Z80. L'original était en technologie NMOS. Le Z80 avec le 6502 est un des rares micro-processeur de cette époque qui est encore fabriqué.
3) Pour répondre à la concurrence de Microsoft, Digital Reseach inc. avait développé son propre système DR-DOS avant que la compagnie soit rachetée par Novell.
4) IBM-DOS était développé par Microsoft et c'est d'ailleurs ce contrat avec IBM qui a fait la fortune initiale de Microsoft.

Cet article fait suite à mon article précédent sur CP/M. J'y explique brièvement le pourquoi et le comment des systèmes d'exploitations.

Qu'est-ce qu'un système d'exploitation?

Un système d'exploitation a pour but de faciliter l'utilisation de l'ordinateur et d'assurer la sécurité et l'intégrité des données. Disons qu'au départ l'objectif principal était le premier car au début les besoins en sécurité n'était pas aussi évidents. Donc CP/M et DOS n'offrait aucune sécurité mais offrait des services aux programmeurs d'applications en leur offrant des interfaces simplifiées et standardisées pour l'accès au matériel, c'est à dire clavier, disques, imprimantes, vidéo, etc. Malgré tout il était possible de contourner ces services pour accéder directement au matériel. Ainsi à l'époque de MS-DOS beaucoup de programmeurs de jeux manipulaient directement la mémoire vidéo pour améliorer la vitesse d'exécution. l'interface standard pour la vidéo passait par l'interruption 10_hex et son contournement provoquait souvent des problèmes de compatibilité mais les fabricants de jeux considéraient que c'était le prix à payer pour obtenir des jeux plus dynamiques.

Plus tard est apparu la nécessité de limiter les accès aux informations mais aussi au matériel. Les nouveaux microprocesseurs ont des gestionnaires de mémoires qui permettent de diviser celle-ci en segments et de contrôler l'accès à ces segments. Ainsi les PIC32MX de Microchip permettent de fragmenter aussi bien la mémoire flash que la mémoire des données en segment noyau et utilisateur. Mais les processeurs d'usage général comme on retrouvent dans nos ordinateurs ont des gestionnaires encore plus sophistiqués qui permettent d'attribuer des segments mémoire pour chaque application.

Structure d'un système moderne

Comme on le voie sur ce diagramme l'espace mémoire est divisé en espace noyau et en espace utilisateur. Les applications elle-même sont isolées les unes des autres dans leur propre segments de mémoire les protégeant les unes des autres. De cette façon une application défectueuse ou malicieuse ne peut pas affecter le noyau ou une autre application.

La question alors est comment les applications font-elles pour accéder aux périphériques? Elle doivent obligatoirement passer par une interface spéciale basée sur une interruption et qu'on appelle syscall. En fait les programmeurs d'applications n'ont pas la plupart du temps à se soucier de cette interface car les systèmes modernes offrent des couches d'abstractions supplémentaire sous formes de librairies. Sous windows 32bits ces librairies s'appellent user32.dll, kernel32.dll, gdi32.dll, mmedia32.dll, etc (les versions 64 bits existent aussi). Les interfaces (liste de fonctions) pour ces librairies sont documentées et utilisées par les programmeurs, simplifiant grandement la vie de ceux-ci. Chaque application charge dans son espace mémoire une copie des DLL qu'elle utilise.

Le niveau d'abstraction augmente continuellement, alors que dans les années 90 les programmeurs utilisaient directement l'API32 (Application Programming Interface) de Windows, c'est de plus en plus rare aujourd'hui avec les framework comme .NET¹, METRO, QT, etc. Ces framework ne sont rien d'autre que des librairies logicielles construites par dessus les API de bases mais qui simplifient encore plus le travail des programmeurs d'applications. Le nombre de couches logicielles augmente sans cesse, mais la complexité des systèmes modernes exigent de plus en plus d'abstraction pour réduire le temps de développement et donc le coût des logiciels.

1) En ce qui concerne .NET il s'agit plus que d'un ensemble de librairies. Les applications sont compilées pour une machine virtuelle qui exécute du bytecode. Mais cette machine doit-elle utiliser l'API32 ou l'API64 pour s'interfacer avec le système d'exploitation.

Je viens de découvrir que Microchip offre maintenant de nouveaux PIC32MX1xx/2xx. Lorsque j'ai créé mon projet VPC-32 il y a de ça un peut plus d'un an, le plus gros PIC32MX disponible en format PDIP-28 était le PIC32MX150F128B qui dispose de 128Ko de flash et 32Ko de RAM. Le PIC32MX170F256B qui est aussi en format PDIP-28 double les quantités de mémoire, soit 256Ko de flash et 64Ko de RAM. Pour le reste les 2 MCU sont identiques donc je n'ai qu'à remplacé le PIC32MX150F128B dans le VPC-32 par le nouveau PIC32MX170F256B pour doubler les quantités de mémoire.

Je travaille présentement sur un projet utilisant un atMega328 avec Atmel studio 6. Dans cet article je discute des différents niveaux d'optimisation utilisés par GCC (GNU C Compiler) ainsi que des problèmes de portabilité causé par la taille variable du type de donnée int.

Optimisation

Atmel studio comme MPLABX utilise GCC comme compilateur et par défaut lorsqu'on cré un projet le niveau d'optimisation est -Os. À ce niveau GCC tente de créer le code le plus compacte possible. Comme les microcontrôleurs sont en général limités en mémoire, c'est logique d'utiliser cette optimisation. Donc lors de la première compilation de mon projet j'ai obtenu un code très compact. Malheureusement ça ne fonctionnais pas. Le projet utilise une routine de service d'interruption qui doit avoir un délais de réponse rapide (low latency), mais le résultat n'était pas à la hauteur des besoins. Après avoir examiner le code assembleur (fichier *.lss dans output files du projet), j'ai été sidéré de voir la quantité de code utilisé en préambule par la routine. C'est là que j'ai décidé de changer le niveau d'optimisation pour -O3 dans les propriétés du projet. Là ça fonctionnais mais la taille du code avait grossis plus que je ne l'aurais cru!

Voici la taille du code généré pour mon projet (non complété) selon les différents niveaux d'optimisation:

• -O0 Ne compile pas! affiche l'avertissement suivant:
  Warning 8 #warning "Compiler optimizations disabled; functions from <util/delay.h> won't work as designed"
• -O1
  Program Memory Usage : 4652 bytes 14,2 % Full
  Data Memory Usage : 1604 bytes 78,3 % Full
• -O2
  Program Memory Usage : 4728 bytes 14,4 % Full
  Data Memory Usage : 1604 bytes 78,3 % Full
• -O3
  Program Memory Usage : 5514 bytes 16,8 % Full
  Data Memory Usage : 1604 bytes 78,3 % Full
• -Os
  Program Memory Usage : 4434 bytes 13,5 % Full
  Data Memory Usage : 1604 bytes 78,3 % Full

Donc lorsqu'on veut optimiser pour la taille on utilise -Os. Mais si on veut optimiser pour la vitesse on utilise -O1,-O2 ou -O3. Chacun prenant plus d'espace de code. Cette augmentation du code est du au fait que pour augmenter la vitesse le compilateur transforme certaines sous-routines en inline même si on ne l'a pas spécifié et aussi il peut dérouler certaines boucles simple avec petit nombre de répétitions.

Au final j'ai décidé de compiler mon projet en -O2, à ce niveau le délais de l'ISR étant suffisamment cours.

Portabilité du code

Comme je ne veut pas avoir à réécrire le même code chaque fois que je change de microcontrôleur je réutilise des fichiers d'autres projets. C'était le cas pour ce projet. Mais lorsque j'ai adapter le code j'ai eu quelques problèmes du au fait que le type de donnée int peut varié de taille d'une plateforme à l'autre. Ainsi sur PIC32MX un int est 32 bits mais sur un AVR il est de 16 bits.

Pour rendre un code source 'C' plus portable il est préférable de préciser la taille des entiers utilisés et dans ce but d'inclure #include <stdint.h> dans le projet. Ce fichier contient des définitions de différentes tailles d'entiers tel que:

• int8_t entier sur 8 bits et sa version non signé uint8_t.
• int16_t entier sur 16 bits et sa version non signé uint16_t.
• int32_t entier sur 32 bits et sa version non signé uint32_t.

Il était tard et j'avais travaillé toute la journée sur ce projet. Après avoir écris la routine ISR suivante et l'avoir compilée j'ai examiné immédiatement le code assembleur généré pour en estimer le temps d'exécution.

Je m'appraîtais à me mettre au lit lorsque j'ai compris mon erreur. Je vous laisse regarder le code source et trouver par vous même où est l'erreur.

Je suis toujours en train de travailler sur un projet utilisant un atMega328 et je regarde régulièrement le code assembleur généré par le compilateur. Aujourd'hui je suis tombé sur un morceau de code assembleur qui m'a laissé perplexe. A prime abord ça ne semblais rimé à rien! En le relisant avec attention j'ai fini par comprendre, voici le code assembleur en question tel que je l'ai commenté. 1520: 85 81 ldd r24, Z+5 ; r24=vms.var[x] 1522: 88 1f adc r24, r24 ; r24*=2 1524: 88 27 eor r24, r24 ; r24=0 1526: 88 1f adc r24, r24 ; r24=Carry 1528: 80 93 91 07 sts 0x0791, r24 ; vms.var[15]=r24 Une variable de 8 bits est chargée dans le registre R24. R24 est additionnée à lui-même, puis mis à zéro par l'instruction eor r24, r24. Ensuite on additionne encore R24 à lui-même, avant d'enregistrer le résultat dans une autre variable. Si on ne porte très attention à ce qui ce passe c'est plutôt étonnant, mais en fait c'est une belle astuce pour faire ceci:

// code C original
  vms.var[15]=(vms.var[x]&128)>>7;

Beaucoup de travail d'optimisation a été fait sur ce compilateur. Bravo! à ces créateurs.

CHIPcon est une console de jeux peut coûteuse et facile à assembler soi-même, pour les jeux écris en super CHIP. Dans cette première partie je fais un rappel historique du langage CHIP pour ensuite présenter le schéma électronique de la console. Le circuit est basé sur un atMega328P-PU avec une sortie NTSC monochrome.

Présentation historique

• En 1970 l'ingénieur Joseph Weisbecker (1932-1990) conçoit un processeur 8 bits à architecture Von Neumann RISC.
• Au début de 1976 la compagnie RCA met sur le marché un microprocesseur nommé CDP-1802. Ce microprocesseur est en technologie CMOS. Son architecture est basé sur le processseur défini par Joseph Weisbecker. Il contient 16 registres de 16 bits d'usage général et 4 registres de 4 bits P,N,I,X. Et un registre de 8 bits T. Les registres de 16 bits peuvent-être divisés en 2 registres de 8 bits, on a donc 32 registres de 8 bits. Il n'y a pas de compteur ordinal dédié, n'importe quel des 16 registres de 16 bits peut-être sélectionné pour cette fonction. C'est la valeur de P qui détermine lequel est le compteur ordinal. Un appel de sous-routine se fait en initialisant un registre avec l'adresse de la sous-routine pour ensuite modifier le registre P pour définir ce registre comme compteur ordinal. Lorsque la sous-routine a terminée son travail elle réinitialise P avec la valeur originale pour revenir au programme appelant. Ce microprocesseur a été utilisé dans plusieurs sondes spatiales dont la sonde Galileo. Ce microprocesseur a un surnom COSMAC (Co mplementary S ymmetry M onolithic A rray C omputer)
• Dans l'édition de août 1976 de Popular electronics, Joseph Weisbecker présente le COSMAC ELF. Petit ordinateur disponible en kit à faible coût. Ces kits étaient vendu par Netronics et Quest Electronics.
  • Processeur CDP-1802
  • RAM statique de 256 octets
  • 11 commutateurs à bascule et 1 à pression pour la saisie et l'exécution du code.
  • 1 affichage 7 segments à 2 digits
  • 1 LED contrôlé par la sortie Q.
  • fréquence maximale du cristal 3.2Mhz
• Juillet 1977, Weisbecker ajoute un générateur graphique CDP-1861 au ELF. Ce dernier génère un signal monochrome de 64x128pixels.
• En 1977 RCA entre sur le marché des micro-ordinateurs avec le COSMAC VIP (photo). Avec 2Ko de RAM en kit de base, celle-ci pouvait être augmenté à 4Ko sur la carte principale.
  • CDP-1861/CDP-1864 pour sortie NTSC monochrome.
  • 2Ko RAM en base, 4Ko possible sur carte mère.
  • Clavier hexadécimal
  • Ajout possible de 2 connecteurs pour cartes d'options.
  • Fréquence d'oscillateur 1,76Mhz.
• Dans l'édition de décembre 1978 de BYTE, Joseph Weisbecker présente CHIP-8, un système pour simplifier la programmation de jeux sur le COSMAC VIP. Il s'agit d'un interpréteur qui exécute du bytecode. Les instructions sont encodées sur 16 bits. L'affichage est de 64x32 pixels.
• 1990 Erik Bryntse cré un descendant de CHIP-8 baptisé SCHIP (Super CHIP). L'interpréteur est conçu pour fonctionner sur une calculatrice HP-48 et l'affichage est de 128x64 pixels. SCHIP reconnait les programmes CHIP-8 sauf pour l'instruction 0xxx qui est un appel de sous-routine en code machine, non pertinent sur la HP-48.
• Plusieurs émulateurs CHIP-8/SCHIP/MégaCHIP ont été écris pour fonctionner sur PC. Il existe aussi un assembleur qui permet de programmer en mnémoniques plutôt qu'en code hexadécimal. Voir le site de David Winter chip.com

CHIPcon

CHIPcon est donc une console de jeux rétro qui implémente un interpréteur SCHIP sur un microcontrôleur atMega328P-PU. Cette console permet de charger et jouer tout fichier binaire en bytecode SCHIP. J'en ai trouvé plusieurs sur le site de David Winter, www.chip8.com

Caractéristique de la console

• microcontrôleur atMega328P-PU format DIP-28.
• expansion RAM SPI de 64Ko Microchhip 23LC512.
• Support carte SD (pilotes écris par Roland Riegel).
• Fréquence oscillateur 16Mhz.
• graphiques 128x64pixels, sortie vidéo NTSC monochrome.
• Sortie son monofréquence sur prise RCA PHONO, ou sur piezo speaker.
• Quelques jeux en mémoire programme du MCU lorsqu'il qu'il n'y a pas de carte SD dans le support.
• Interface Humain-machine par clavier hexadécimal comme le COSMAC VIP.
• Potientiomètre pour contrôler la vitesse d'exécution de l'interpréteur SCHIP.

Schématique

Liste matériel

• Z1    PIEZO speaker (option 2)
• C1    electrolytic 100µF/16V
• C2,C3    18pF ceramic NPO
• C6,C7,C8,C9,C10    100nF ceramic (CMS)
• C5,C10    1µF ceramic (CMS)
• C11    10µF/16V electrolytic
• CON1    2.1 mm BARREL_JACK
• D1    diode 1N4148
• D2    LED 5mm/20ma
• J1,J2    RCA phono jack
• k1    KEYPAD 16 touches, Grayhill 96BB2-056-R
• P1    réceptacle SD card
• P2    connecteur 2x3 100mil mâle
• R1    4k7
• R2    150R
• R3    620R
• R4    470R
• R5,R6,R7,R8    10K
• R9    10R
• R10    100R
• RV1    10K potentiomètre linéaire
• SW1    bouton momentanné N.O.
• SW2    commutateur alimentaion S.P.S.T
• U1    MCU ATMEGA328P-PU
• U2    SRAM 23LC512
• U3    LDO LT1117-3,3
• X1    cristal 16Mhz (TXC 9B-16.000MEEJ-B)
• 8015-1 Circbord    carte à points Vector pour montage final. 10cm x 10cm

Le modèle mémoire des programmes CHIP-8/SCHIP est de 4Ko et les 512 premiers octets étaient réservés pour le système sur le COSMAC VIP. Donc le binaire du jeux est chargée en mémoire à l'adresse 512 (0x200) et a une taille maximale de 3584 octets. Le 328P-PU n'a que 2Ko de RAM dont 1Ko est occupé par la mémoire vidéo. Ce n'est donc pas suffisant pour SCHIP. Microchip vend des mémoire RAM statique à interface SPI. Le 23LC512 contient 64Ko de RAM. Les jeux sont chargée dans cette SRAM à l'adresse 0x200 et exécutés à partir de cette mémoire externe. Le vidéo NTSC est généré par 2 périphériques. La minuterie TMR1 de 16 bits génère le signal de synchronisation par PWM et le USART configuré en mode SPI est utilisé pour sérialiser les pixels vidéo à partir du video_buffer situé dans la RAM du atMega328P-PU. Le périphérique SPI principal est utilisé pour communiquer avec la SRAM externe et la carte SD.

Au départ je me demandais si l'utilisation de la SRAM externe comme mémoire d'exécution pour l'interpréteur SCHIP serait suffisamment rapide, la vitesse du clock SPI maximale étant de Fosc/2 soit 8Mhz. Il s'est avéré à l'usage qu'en fait pour certains jeux l'interpréteur était trop rapide. Il ne faut pas oublier que le COSMAC VIP original fonctionnait à 1,76Mhz et que le CPU CDP-1802 utilise 16 cycles d'oscillateur par instruction, donc un maximum de 110000 instructions par seconde sur le COSMAC VIP. Comme CHIP-8 est un interpréteur exécutant plusieurs instructions 1802 par bytecode les programmes CHIP-8 étaient encore plus lent que ça. L'atMega328P lui fonctionne à 16Mhz et la majorité des instructions s'exécute en 1 seul clock. Donc même si l'interpréteur nécessite le transfert de 5 octets sur l'interface SPI pour lire une seule instruction on est encore à 8Mhz/8/5=200000 instructions lues par seconde. Bien sur le nombre d'instructions par secondes est beaucoup plus bas que ça car une bonne partie du temps CPU est utilisé par le générateur vidéo. Quoi qu'il en soit j'ai du ajouter un potentiomètre au circuit dont la lecture est faite par le périphérique ADC 10 bits sur le canal 1 (broche 24). La valeur lue sur le potentiomètre détermine le nombre d'instructions que l'interpréteur exécute par intervalle vertical sync (16,7 msec).

Pour la sortie audio il y a 2 options. La première option consiste à sortir le signal sur un connecteur RCA phono et utiliser le téléviseur comme amplificateur audio. La deuxième option est d'utiliser simplement un petit haut-parleur piézo monté sur la carte du circuit.

Le support pour carte SD est optionnel si on ne l'utilise pas l'utilisation de la mémoire flash de l'atMega328P-PU tombe à 50% environ ce qui libère plus d'espace pour y mettre des jeux.

Avec cette option installée au démarrage le firmware vérifie la présence d'une carte SD dans le support. s'il y a une carte il lit le répertoire racine et affiche à l'écran la liste des fichiers jeux disponibles. l'utilisateur sélectionne le jeux désiré et celui-ci est alors transféré de la carte vers la SRAM et exécuté.

S'il n'y pas de carte dans le support le firmware affiche la liste des jeux enregistrés dans la flash du MCU. Le jeux sélectionné est transféré de la flash du MCU à la SRAM pour exécution.

Dans le prochain article je vais commencer la présentation du firmware en commençant par l'interpréteur super CHIP. D'ici là j'aurai sans doute le temps de compléter le montage sur la carte à points et peut-être filmer un vidéo de démonstration.

liens

• Article CHIP-8 sur wikipedia anglais et français.
• Page de David Winter beaucoup d'information disponible sur cette page et des jeux à télécharger.
• Page consacré au COSMAC ELF, histoire, archives logicielles et photos.
• Page consacré à CHIP-8 sur revival studio.
• Vous pouvez télécharger à partir de cette page l'émulateur pour PC Fish'n chip. je l'ai testé et il est fonctionnel sur windows 7.

Dans ce deuxième article du projet CHIPcon j'explique ce qu'est une machine virtuelle et plus spécifiquement celle du projet.

Mais d'Abord

Avant de débuter le sujet principal voici un photo du montage du prototype de CHIPcon v1.0. et un vidéo de la console en action.

Émulateur, interpréteur et machine virtuelle

Quel est la différence entre ces 3 termes. On utilise le mot émulateur pour désigner un logiciel qui implémente le fonctionnement d'un circuit matériel, par exemple si on veut faire tourner un logiciel pour un MCU particulier mais qu'on a pas le MCU en main on peut le faire tourner à l'intérieur d'un émulateur logiciel qui fonctionne sur le PC. Ainsi l'environnement MPLABX offre des émulateurs pour chaque MCU PIC 8 bits vendu par Microchip. On peut donc tester un logiciel avant de le mettre en mémoire flash du MCU.

On utilise le terme interpréteur pour désigner le compilateur d'un langage de haut-niveau qui au lieu de générer du code binaire pour un CPU génère du code pour une machine virtuelle (bytecode) et exécute ce programme sur cette machine virtuelle. Par exemple Java et Python compile pour une machine virtuelle et non du binaire pour un microprocesseur.

Une machine virtuelle est un logiciel qui exécute du bytecode pour un modèle d'exécution particulier. Cette machine est semblable à un microprocesseur sauf qu'elle n'est pas gravé dans le silicium, d'où le qualificatif de virtuelle.

Par modèle d'exécution on entend l'ensemble des registres, de l'espace mémoire et des instructions que peut exécuter cette machine.

CHIP-8 et SCHIP sont des machines virtuelles qui partagent le modèle d'exécution suivant.

• Une banque de 16 registres de 8 bits notés V0-VF. Le registre VF est utilisé pour sauvegarder l'indicateur de débordement (carry flag).
• Un compteur ordinal pouvant adresser 4096 octets (12 bits)
• Un pointeur de donnée pouvant adresser 4096 octets (12 bits)
• Une minuterie de délais de 8 bits cadencé à 60Hertz.
• Une générateur de tonalité avec compteur de duré de 8 bits cadencé à 60Hertz.
• L'espace d'adressage mémoire est de 4096 octets, mais les programmes à exécuter doivent-être chargés à l'adresse 512 (0x200). Leur taille est donc limité à 3584 octets.
• Le jeux d'instructions de la machine virtuelle est codé sur 16 bits
• Le système possède une police de caractère hexadécimal 3x5 pixels.
• Le système possède une police de caractère décimal de 8x10 pixels.
• CHIP-8 a une capacité graphique de 64x32 pixels (mémoire vidéo 256 octets).
• SCHIP a une capacité graphique de 128x64 pixels (mémoire vidéo de 1024 octets).
• SCHIP a une compatilibilité ascendante avec CHIP-8 sauf pour l'instruction 0NNN (syscall).
• SCHIP ajoute 10 instructions au jeux d'instructions de CHIP-8 qui a 35 instructions.
• SCHIP possède une deuxième banque de 16 registres appellée RPL. Un transfert de données peut-être fait entre les 2 banques.

Jeux d'instructions de SCHIP

Dans la table ci-bas NNN représente un nombre de 12 bits en hexadécimal (000-FFF).
KK représente une constante de 8 bits en hexadécimal (00-FF).
X et Y représentent un registre V en hexadécimal (0-F).
Les instructions suivies d'un * sont spécifiques à SCHIP.

Implémentation de la VM SCHIP sur CHIPcon.

Pour suivre cette description référez-vous au dépôt github du projet CHIPcon. tout les fichiers y sont.

Cette machine virtuelle n'ayant que 43 codes opérationnels est simple à implémenter. Les états du modèle d'exécution sauf pour la mémoire RAM sont rassemblés dans une seule variable appellée vms. Le type de donnée qui définie cette structure est déclaré dans le fichier d'entête chip8.h et le code 'C' de la machine est dans le fichier chip8.c.

// structure de donnée définissant le modèle d'exécution de la VM
typedef struct vm_state{
 uint16_t pc;  // compteur ordinal
 uint16_t ix;  // pointeur de données
 uint8_t  sp;  // pointeur de la pile
 uint8_t  var[16]; // banque de registres
 uint8_t  rpl[16]; // banque de registres SCHIP
 union {
  uint16_t opcode; // dernier code machine exécuté 
 struct{ 
  uint8_t b1;  // octet fort du code
  uint8_t b2;  // octet faible du code
  };
 };
 uint16_t stack[32];  // pile des retours
 uint8_t  src_mem:1 ; // indicateur de source du sprite
 uint8_t  debug:1;    // pour support déboguage
 uint8_t  trace:1;    // pour support déboguage
 }vm_state_t;

La fonction uint8_t schip(uint8_t flags) exécute le code qui est enregistré dans la SRAM à partir de l'adresse 0x200. Deux octets de code sont lues pour chaque instruction. Comme le code opérationnel est répartie dans 2 champs séparés, il y a d'abord une phase appelée décodeur d'instruction qui rassemble les 2 champs dans la variable uint16_t code. code est ensuite utilisé par le switch de la phase exécution. Il s'agit d'une organisation classique pour une machine virtuelle. Il n'y a pas de difficulté particulière, une simple lecture du fichier chip8.c devrait permettre de comprendre le fonctionnement de la machine virtuelle.

La VM transige avec l'affichage par les interfaces des modules tvout et text, avec l'unité son par l'interface de celui de tone, avec le clavier via l'interface de keypad et avec la mémoire sram par l'interface du module sram.

liens

Dans cet article je discute de l'utilisation de la mémoire RAM à interface SPI Microchip 23LC512

Cette mémoire RAM à interface SPI est vraiment pratique puisqu'elle ne requiert que 4 GPIO, SCK, MISO, MOSI et SELECT. Et comme l'atMega328P possède un périphérique SPI l'utilisation en est très simple. C'est le même périphérique SPI qui est utilisé pour la carte SD chacun ayant un SELECT différent.

Le 23LC512-IP possède 64Ko de RAM, j'aurais pu utiliser un 23K640-IP (8Ko) pour un coût moindre, mais j'ai utilisé ce que j'avais en main. Le 23LC512 a 3 modes de fonctionnement, BYTE, PAGE et SEQUENTIAL. Pour cette application il est configuré en mode séquentiel. Ce mode permet de lire ou d'écrire un bloc de mémoire de n'importe quel dimension avec une seule commande, alors qu'en mode BYTE on ne peut lire ou écrire qu'un octet par commande. En mode PAGE, 32 octets peuvent-être lus ou écris et ces pages sont alignées modulo 32. Donc si on envoie la commande READ 0x0003 et qu'on lit 32 octets, les octets lus seront aux adresses 3-31 et 0-2 et non 3-34. Pas de problème de cette sorte avec le mode SEQUENTIAL.

Évidemment on ne peut stocker de code binaire dans cette SRAM sauf si on l'utilise avec des MCU à architecture Von Neumann comme les MSP430 par exemple. Dans ce cas on pourrait charger des routines de la SRAM vers la RAM du MCU pour les exécuter. Quoi que pour une telle application une mémoire EEPROM ou flash SPI serait plus utile. Dans le cas d'un atMega328P on ne peut utiliser cette méthode mais c'est néanmoins utile comme espace de stockage de données temporaire. Dans l'application CHIPcon la SRAM est utiliser de 3 façons.

1. stockage de la liste des noms de fichiers jeux pour utilisation par la routine display_page() du fichier chipcon.c
2. tvout utilise la SRAM pour sauvegarder un écran temporairement afin d'afficher les informations de débogage pendant le mode TRACE. Voir les routines screen_save() et screen_restore() dans tvout.c ainsi que la routine print_vms() dans chip8.c.
3. La mémoire SRAM contient le programme SCHIP à exécuter. Le programme est chargé à l'adresse 512 (0x200).

Pour le détail de l'implémentation voir les fichiers sram.h et sram.c.

liens

Dans cet article je décris le fonctionnement du module tvout du projet CHIPcon.

tvout

Le module tvout est constitué des fichiers tvout.h et tvout.c. Ce module est responsable de la génération du signal NTSC et comprends les fonctions d'interface suivantes:

• void tvout_init()
  Initialisation du module.
• void plot(int8_t x, int8_t y, optype op)
  Desssine un point à la position x,y. optype peut prendre une des valeurs suivantes: WHITE, BLACK, INVERT.
• int8_t put_sprite(uint8_t x, uint8_t y, uint8_t n, const uint8_t *sprite, int8_t memory)
  Desssine un sprite. x,y sont les coordonnées du coin supérieur gauche. Le sprite a 8 pixels de large par n pixels en hauteur. memory indique si le sprite est en mémoire flash (FLASH_MEM) ou en RAM (RAM_MEM).
• int8_t put_big_sprite(uint8_t x, uint8_t y,const uint8_t *sprite)
  Dessine un sprite de 16x16 pixels. Les coordonnées sont le coin supérieur gauche.
• void cls()
  Efface l'écran.
• void scroll_down(uint8_t lines)
  Défile l'écran vers le bas d'un nombre de lignes entre 0 et 31.
• void scroll_up(uint8_t lines)
  Défine l'écran vers le bas d'un nombre de lignes entre 0 et 31.
• void scroll_right(uint8_t pixels)
  Défile l'écran vers la droite d'un nombre de pixels entre 0 et 8.
• void chip_scroll_right()
  Défile l'écran vers la droite de 4 pixels. Optimisé pour l'engin schip()
• void scroll_left(uint8_t pixels)
  Défile l'écran vers la gauche d'un nombre de pixels entre 0 et 8.
• void chip_scroll_left()
  Défile l'écran vers la gauche de 4 pixels. Optimisé pour l'engin shcip().
• void screen_save()
  Sauvegarde l'écran dans la SRAM.
• void screen_restore()
  Restaurate l'écran à partir de la SRAM.

Génération du signal NTSC

La façon la plus efface de générer un signal NTSC sur un MCU en utilisant le moins de cycles CPU possible est d'utiliser une minuterie avec un output compare en mode PWM pour le signal de synchroniation. Pour sérialiser les pixels contenu dans le video_buffer un périphérique SPI fait l'affaire. l'atMega328P permet de configuré le module USART en mode SPI c'est donc de cette façon que j'ai procédé car le module SPI lui-même est utiliser pour interfacer la carte SD et la SRAM.

Il n'y a qu'une seule interruption qui se produit lorsque le compteur du TIMER1 atteint la valeur du registre OCR1B. Ce qui se produit à la fin de l'impulsion de synchronisation. Il y a donc une interruption à chaque ligne horizontale soit à toute les 63,5µsec.

Cette interruption fait fonction de céduleur de tâche. La tâche à exécuter est déterminée par le numéro ligne. volatile uint8_t frame_delay=0; volatile uint8_t tone_length=0; volatile uint8_t speed_delay=0; static volatile uint16_t line_count=0; static volatile uint8_t video=0; // interruption à la fin de // chaque pulse de synchronisation ISR(TIMER1_COMPB_vect){ register unsigned i; register unsigned char *buff; line_count++; switch(line_count){ case 1: if (frame_delay) frame_delay--; break; case 2: if (tone_length){ tone_length--; if (!tone_length) tone_off(); } break; case 3: NTSC_SYNC_OCRB=HPULSE; break; case 4: if (speed_delay) speed_delay--; break; case 5: ADCSRA |= (1<<adsc break case first_visible: video="1;" last_visible: line_count="0;" ntsc_sync_ocrb="VPULSE;" default: if buff="video_buffer+(((line_count-FIRST_VISIBLE)">>1)*HBYTES); NTSC_VIDEO_UBRR=0; NTSC_VIDEO_UCSRB=(1<<txen0 ntsc_video_ubrr="2;" ntsc_video_udr="0x0;" for while ucsr0a ntsc_video_ucsrb break></txen0></adsc>

liens

Cette partie documente le module keypad constitué des 2 fichiers keypad.h et keypad.h.

Agencement du clavier

La mojorité des jeux CHIP-8/SCHIP que j'ai trouvé dans l'internet ont été écris pour fonctionner dans des émulateurs tournant sous Windows. Donc la disposition du clavier est différente. Certains émulateurs sont configurés en pensant à l'utilisation du pavé numérique d'autres utilisent certaines lettres du pavé alphanumérique. Par exemple l'émulateur Fish'n chip utilise les touches à gauche du clavier alphanumérique. La correspondance avec le clavier COSMAC VIP est représenté en caractères gras.

CHIPcon utilise un clavier Grayhill 96BB2-056-R représenté ici à côté du clavier COSCMAC VIP. On voie donc que la disposition est différente. Pour CHIPcon [*] correspond à [E] et [#] correspond à [F]. Donc lorsqu'on télécharge un jeux pour l'utiliser avec CHIPcon on doit tenir compte de ces différences.

interface keypad

• void keypad_init()
  Initialisation matérielle du clavier.
• uint8_t keypad_read()
  Lecture d'une touche avec anti-rebond.
• uint8_t wait_key()
  Attend qu'une touche soit enfoncée et retourne sa valeur. Lecture avec anti-rebond.
• void prompt_key()
  Affiche le message "any key..." et attend une touche.
• uint8_t keypad_break()
  Vérifie si les touches [*] et [#] sont enfoncées en même temps. Retourne vrai si c'est le cas. Utilisé pour sortir de la fonction schip() lorsqu'un programme est bloqué dans une bouche infinie.
• uint8_t key_down(uint8_t key)
  Vérifie si la touche key est enfoncée. Il n'y a pas d'anti-rebond, le programme SCHIP doit gérer lui-même l'anti-rebond.

Outils de développement

Dans le répertoire tools du projets il y a 2 utilitaires.

cvt-chip est utilisé pour convertir un fichier binaire SCHIP en fichiers source *.c et *.h dans le but d'intégrer un jeux dans la mémoire flash de CHIPcon. Voici un exemple pour sokoban.sc.

commande pour convertir le fichier binaire.

cvt-chip.exe sokoban.sc

#ifndef SOKOBAN_H_ #define SOKOBAN_H_ #include <avr>#include <stdint.h> #define SOKOBAN_SIZE (3584) extern const uint8_t sokoban[SOKOBAN_SIZE]; extern const uint8_t sokoban_info[]; #endif /* SOKOBAN_H_ */ </stdint.h></avr>

sokoban.c#include "sokoban.h" PROGMEM const uint8_t sokoban_info[]= "Sokoban by Hap\n""keys:\n""5 up\n""8 down\n""7 left\n""9 right\n""A select\n"""; PROGMEM const uint8_t sokoban[SOKOBAN_SIZE]={ 0x00, 0xff, 0x22, 0x1b, 0x6e, 0x05, 0x22, 0x2f, 0xec, 0xa1, 0x12, 0x37, 0xed, 0xa1, 0x12, 0x7f, 0x4a, 0x32, 0x12, 0x04, 0xeb, 0xa1, 0x22, 0x3f, 0x12, 0x04, 0x80, 0x00, 0xe0, 0xa4, 0x88, 0xfe, 0x65, 0xa4, 0x64, 0x4a, 0x00, 0x14, 0x58, 0x22, 0x69, 0xf6, 0x29, 0xd9, 0x95, 0x00, 0xee, 0xf1, 0x07, 0x31, 0x00, 0x12, 0x2f, 0x00, 0xee, 0x4a, 0x01, 0x12, 0x04, 0x6e, 0x08, 0x12, 0x16, 0xf7, 0x15, 0x60, 0x01, 0xf0, 0x18, 0xaf, 0xc8, 0xfa, 0x1e, 0xf5, 0x65, 0xa2, 0xf3, 0xf1, 0x65, 0x4e, 0x05, 0x12, 0x5f, 0x81, 0x35, 0x4f, 0x00, 0x70, 0xff, 0x7a, 0xff, 0x85, 0x30, 0x12, 0x65, 0x81, 0x44, 0x80, 0xf4, 0x7a, 0x01, 0xf1, 0x55, 0x22, 0x6d, 0xa4, 0x4c, 0xfa, 0x33, 0xa4, 0x4c, 0xf2, 0x65, 0xf1, 0x29, 0xdd, 0x95, 0xf2, 0x29, 0xd6, 0x95, 0xa4, 0x88, 0xfa, 0x55, 0x00, 0xee, 0x22, 0x1b, 0x6d, 0x00, 0x6c, 0x00, 0x62, 0x02, 0xf2, 0x18, 0x61, 0x40, 0x22, 0xd5, 0x87, 0x60, 0x61, 0x80, 0x22, 0xd5, 0x84, 0xe0, 0x81, 0xe0, 0x81, 0x64, 0x22, 0xa7, 0x4c, 0x00, 0x13, 0x2d, 0x43, 0x18, 0x12, 0xbb, 0x23, 0x0f, 0x12, 0x99, 0x6e, 0x00, 0x23, 0x01, 0x4e, 0x01, 0x23, 0x01, 0x23, 0x01, 0x83, 0xe0, 0x83, 0x23, 0x83, 0x0e, 0x83, 0x0e, 0x00, 0xee, 0x22, 0xa7, 0x43, 0x18, 0x12, 0xcf, 0x22, 0xe5, 0x7e, 0x04, 0x23, 0x0f, 0x7e, 0xff, 0x3e, 0x00, 0x12, 0xc5, 0x12, 0x99, 0xa4, 0x85, 0xf7, 0x55, 0x12, 0xa3, 0x22, 0xe5, 0x7e, 0x05, 0x8e, 0x0e, 0x8e, 0x0e, 0x86, 0xe0, 0x86, 0x17, 0x86, 0x06, 0x00, 0xee, 0x6e, 0x00, 0x23, 0x01, 0x23, 0x01, 0x23, 0x01, 0x23, 0x01, 0x00, 0xee, 0x6d, 0x08, 0xa4, 0xb4, 0xfc, 0x1e, 0xf0, 0x65, 0x8b, 0x00, 0x9c, 0x50, 0x6c, 0xff, 0x7c, 0x01, 0x4d, 0x00, 0x12, 0xf1, 0x7d, 0xff, 0x8e, 0x0e, 0x8b, 0x0e, 0x8e, 0xf1, 0x00, 0xee, 0x43, 0x10, 0x13, 0x19, 0x33, 0x14, 0x13, 0x1b, 0x78, 0x01, 0x79, 0x01, 0xa4, 0x94, 0xf3, 0x1e, 0xd6, 0x74, 0x76, 0x04, 0x56, 0x10, 0x00, 0xee, 0x86, 0x45, 0x77, 0x04, 0x00, 0xee, 0xa4, 0x85, 0xf7, 0x65, 0x6a, 0x00, 0x22, 0x2f, 0x6b, 0x01, 0xa4, 0x93, 0xf5, 0x65, 0x98, 0x90, 0x14, 0x17, 0xe1, 0xa1, 0x14, 0x3c, 0xe0, 0xa1, 0x14, 0x40, 0xe3, 0xa1, 0x14, 0x44, 0xe4, 0xa1, 0x14, 0x48, 0xe5, 0xa1, 0x14, 0x29, 0xe2, 0x9e, 0x13, 0x35, 0x4c, 0x00, 0x13, 0x35, 0x6b, 0x00, 0x7c, 0xff, 0xa4, 0xac, 0xd6, 0x74, 0x7d, 0xff, 0x4d, 0xff, 0x6d, 0x38, 0xa4, 0x4c, 0xfd, 0x1e, 0xf0, 0x65, 0x8a, 0x00, 0xf4, 0x15, 0x81, 0xa2, 0xa4, 0x93, 0xf1, 0x1e, 0xf5, 0x65, 0x4b, 0x00, 0x23, 0xf3, 0x80, 0x60, 0x81, 0x70, 0x80, 0x44, 0x81, 0x54, 0x4b, 0x00, 0x13, 0x93, 0xa4, 0x3a, 0x24, 0x07, 0x4e, 0x01, 0x13, 0x33, 0xa2, 0x1a, 0x24, 0x07, 0x4e, 0x00, 0x13, 0xc3, 0x82, 0x00, 0x83, 0x10, 0x82, 0x44, 0x83, 0x54, 0x4b, 0x00, 0x13, 0xe5, 0xa2, 0x1a, 0x24, 0x0f, 0x4e, 0x01, 0x13, 0x33, 0x7a, 0x80, 0xa4, 0xa4, 0x24, 0x07, 0x88, 0xe5, 0x24, 0x0f, 0x88, 0xe4, 0xa4, 0xb0, 0xd0, 0x14, 0xfb, 0x18, 0xd2, 0x34, 0x4b, 0x00, 0x13, 0xeb, 0x3c, 0x39, 0x7c, 0x01, 0x80, 0xa0, 0xa4, 0x4c, 0xfd, 0x1e, 0x7d, 0x01, 0x4d, 0x39, 0x6d, 0x00, 0xf0, 0x55, 0xa4, 0xac, 0xd6, 0x74, 0x86, 0x44, 0x87, 0x54, 0xd6, 0x74, 0x13, 0x33, 0x8a, 0x0e, 0x4f, 0x01, 0x13, 0xb1, 0xa4, 0x85, 0xf7, 0x65, 0xa4, 0xac, 0x13, 0xdd, 0xa4, 0x85, 0xf7, 0x55, 0x86, 0x44, 0x87, 0x54, 0x86, 0x44, 0x87, 0x54, 0x85, 0xb7, 0x84, 0xb7, 0xf5, 0x55, 0x00, 0xee, 0xd0, 0x12, 0x8e, 0xf0, 0xd0, 0x12, 0x00, 0xee, 0xd2, 0x32, 0x8e, 0xf0, 0xd2, 0x32, 0x00, 0xee, 0xf3, 0x18, 0x60, 0x32, 0xf0, 0x15, 0x22, 0x2f, 0x22, 0x1b, 0x4a, 0x32, 0x12, 0x02, 0x22, 0x3f, 0x12, 0x81, 0xf1, 0x18, 0x60, 0x1e, 0xf0, 0x15, 0x22, 0x2f, 0xe5, 0x9e, 0x13, 0x35, 0x3a, 0x00, 0x12, 0x7f, 0x12, 0x00, 0x20, 0x6a, 0x02, 0x13, 0x71, 0x6a, 0x04, 0x13, 0x71, 0x6a, 0x01, 0x13, 0x71, 0x6a, 0x03, 0x13, 0x71, 0x00, 0xc1, 0xd5, 0x61, 0xf1, 0x1e, 0x75, 0x08, 0x35, 0x58, 0x14, 0x4e, 0x65, 0x28, 0x83, 0x15, 0x33, 0xfe, 0x14, 0x4c, 0x6a, 0x01, 0x12, 0x27, 0xfe, 0x79, 0x99, 0xe7, 0xc7, 0xdb, 0x0e, 0xcd, 0xf3, 0x36, 0x6c, 0xdb, 0x1c, 0xcd, 0xe3, 0x36, 0x6c, 0xdb, 0x38, 0xcd, 0xb3, 0x36, 0x67, 0xdb, 0x70, 0xcd, 0x9b, 0x37, 0xc0, 0xdb, 0xe0, 0x79, 0x81, 0xe6, 0x07, 0x9e, 0xfe, 0x01, 0x80, 0x06, 0x00, 0x00, 0x0f, 0x07, 0x02, 0x02, 0x00, 0x09, 0x07, 0x0a, 0x05, 0x08, 0x00, 0xfc, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x40, 0x20, 0x00, 0xf0, 0xd0, 0xb0, 0xf0, 0x60, 0xf0, 0xf0, 0x60, 0xf0, 0x90, 0x90, 0xf0, 0x6e, 0x00, 0x88, 0xc2, 0x90, 0x18, 0x53, 0x41, 0x84, 0x2a, 0x15, 0x60, 0xe8, 0x52, 0x8c, 0x15, 0x51, 0x14, 0x40, 0x89, 0x80, 0x8a, 0x44, 0x43, 0x65, 0x28, 0x58, 0x36, 0xd1, 0x21, 0x51, 0x91, 0x43, 0x64, 0x01, 0x80, 0xc5, 0x40, 0x22, 0x60, 0x59, 0x8c, 0x03, 0xb0, 0x30, 0x15, 0x5d, 0x81, 0x28, 0x50, 0x5d, 0x81, 0xaa, 0xa0, 0xbb, 0x00, 0x48, 0x28, 0x2e, 0xc0, 0x88, 0x52, 0x28, 0x2d, 0x28, 0x82, 0x50, 0xa5, 0x28, 0x82, 0x00, 0xc0, 0x50, 0x8c, 0x00, 0x5c, 0x82, 0x45, 0x20, 0xac, 0x06, 0x46, 0x0a, 0x95, 0xa2, 0xc1, 0x52, 0x85, 0x60, 0xcb, 0x4a, 0x21, 0x15, 0x28, 0x8a, 0xb3, 0x00, 0x29, 0x42, 0x82, 0xbb, 0x60, 0x0a, 0x14, 0x05, 0x98, 0x02, 0x3c, 0x9e, 0x83, 0xc5, 0x20, 0xe8, 0x4c, 0x11, 0x90, 0x98, 0x14, 0x01, 0x0a, 0x50, 0x26, 0x05, 0x2d, 0xad, 0x0a, 0x21, 0x30, 0x28, 0x58, 0x0d, 0x10, 0x98, 0x14, 0xb4, 0x69, 0x4b, 0x15, 0x0a, 0x30, 0x16, 0x06, 0xa4, 0x56, 0x06, 0x80, 0x20, 0x0b, 0x03, 0x60, 0x34, 0x05, 0x81, 0xa1, 0x6b, 0x68, 0x48, 0xc0, 0xd0, 0x04, 0x01, 0x60, 0x71, 0x70, 0x8c, 0x82, 0x44, 0x61, 0x08, 0x11, 0x18, 0x22, 0x35, 0x41, 0x82, 0x30, 0x1a, 0x45, 0x85, 0x40, 0x59, 0x80, 0x14, 0xa1, 0x55, 0x66, 0x00, 0x0a, 0x5a, 0x28, 0xcc, 0x00, 0xb4, 0x29, 0x22, 0x45, 0x42, 0x82, 0xc1, 0x52, 0x94, 0x18, 0x2a, 0xa2, 0x8c, 0x1d, 0x00, 0x60, 0xf1, 0x20, 0x67, 0x89, 0x02, 0xa3, 0xb0, 0x22, 0xc8, 0xae, 0xc0, 0xa8, 0x0b, 0xb4, 0x06, 0xd1, 0x76, 0x04, 0x4a, 0x2e, 0xca, 0x89, 0x48, 0x89, 0x46, 0x82, 0x02, 0x15, 0x28, 0x80, 0x94, 0x28, 0x20, 0x20, 0xa0, 0x20, 0x45, 0x40, 0x78, 0x81, 0xc4, 0x42, 0x26, 0x02, 0xa8, 0x92, 0x29, 0x68, 0xa0, 0x16, 0x04, 0xa1, 0x41, 0x50, 0x15, 0x48, 0x8d, 0x55, 0x28, 0x2a, 0x6c, 0x89, 0x4a, 0x53, 0x6c, 0x88, 0x02, 0xbb, 0x64, 0x4b, 0x44, 0x76, 0xc8, 0x82, 0xa4, 0x44, 0x55, 0x00, 0xbb, 0x05, 0x58, 0x42, 0x11, 0x70, 0x40, 0x28, 0x14, 0xa2, 0x09, 0x52, 0x88, 0x50, 0x41, 0x0a, 0x50, 0x40, 0x15, 0x4a, 0x88, 0x2a, 0x8b, 0x23, 0x4a, 0x50, 0x50, 0x14, 0x02, 0x8d, 0x40, 0x45, 0x02, 0x80, 0x52, 0x94, 0x89, 0x04, 0x54, 0x18, 0x13, 0x04, 0x60, 0x4c, 0x11, 0x98, 0x98, 0x23, 0x31, 0x30, 0x46, 0x62, 0x60, 0x91, 0x40, 0x9c, 0x83, 0x44, 0xe0, 0xc8, 0x6d, 0x98, 0x14, 0x44, 0x36, 0xcc, 0x09, 0x81, 0x63, 0x30, 0x24, 0x14, 0x36, 0xcc, 0x09, 0x45, 0x0d, 0xb3, 0x01, 0x54, 0x8a, 0x40, 0x52, 0xda, 0x2c, 0x06, 0x22, 0x14, 0xa4, 0x4c, 0x06, 0x94, 0x04, 0x05, 0x90, 0xa1, 0x40, 0x28, 0x52, 0x26, 0x5a, 0x52, 0x23, 0x01, 0x60, 0x4c, 0x16, 0x28, 0xbe, 0x15, 0x08, 0xdc, 0x8a, 0xb0, 0x34, 0x05, 0x2d, 0x02, 0xd0, 0xa5, 0x36, 0xca, 0x16, 0xd4, 0x02, 0x83, 0xb6, 0x52, 0x80, 0x96, 0x96, 0x8e, 0xd9, 0x54, 0x04, 0x28, 0x03, 0xb6, 0x58, 0x0a, 0x52, 0x94, 0x76, 0xca, 0x01, 0x12, 0x15, 0xdb, 0x2a, 0x20, 0x85, 0x28, 0x3b, 0x65, 0x05, 0x12, 0xd2, 0x95, 0x76, 0x53, 0x64, 0x42, 0xc0, 0x9c, 0xa6, 0xc8, 0x96, 0xd2, 0xda, 0x3a, 0x24, 0x30, 0x34, 0x72, 0x00, 0x91, 0x51, 0xc8, 0x03, 0x07, 0x72, 0x01, 0x1b, 0x00, 0xae, 0x83, 0x2a, 0xc1, 0x95, 0x44, 0x18, 0x22, 0xa0, 0xad, 0x18, 0x1a, 0x81, 0x20, 0x50, 0x60, 0x4a, 0x14, 0xb5, 0x45, 0x81, 0x20, 0xd5, 0x80, 0xb0, 0x24, 0x4a, 0x5a, 0x22, 0xb0, 0x14, 0x0a, 0x20, 0x94, 0x8a, 0x80, 0x21, 0x68, 0x81, 0x11, 0x14, 0xb0, 0x55, 0xc0, 0x0a, 0x84, 0x57, 0x63, 0x64, 0x55, 0x81, 0xbb, 0x67, 0x30, 0x86, 0x61, 0x61, 0x11, 0x30, 0x8c, 0x8e, 0x0c, 0x29, 0x11, 0x22, 0x50, 0x14, 0x44, 0x29, 0x4a, 0x54, 0x11, 0x10, 0x2c, 0x94, 0x05, 0x15, 0x11, 0xa5, 0x2a, 0xbb, 0x65, 0x10, 0x29, 0x41, 0x76, 0xca, 0x2b, 0x6d, 0x28, 0xbb, 0x65, 0x80, 0xa2, 0x8b, 0xb6, 0x89, 0x00, 0xa2, 0xed, 0x90, 0x08, 0x8c, 0x05, 0x58, 0x23, 0x01, 0x60, 0xd1, 0x30, 0x8e, 0x02, 0x2b, 0x05, 0x50, 0x14, 0x22, 0x40, 0xac, 0x05, 0x04, 0x01, 0x54, 0x28, 0xd1, 0x04, 0x36, 0xc2, 0x89, 0x59, 0x2a, 0x88, 0xe7, 0x0a, 0x08, 0xd0, 0x40, 0x31, 0x85, 0x28, 0x05, 0x11, 0x1c, 0xe1, 0x40, 0x50, 0x5a, 0x53, 0x18, 0x52, 0x88, 0x08, 0x35, 0xce, 0x15, 0x28, 0x50, 0x28, 0x5d, 0xb0, 0x8d, 0x22, 0x40, 0x0a, 0x08, 0x82, 0x01, 0x16, 0x15, 0x40, 0xbd, 0x81, 0xc4, 0xe0, 0x31, 0x38, 0x0b, 0x01, 0x60, 0x29, 0x64, 0xa3, 0x01, 0x6d, 0x10, 0x22, 0xa2, 0x2b, 0x31, 0x28, 0x08, 0x81, 0x66, 0x25, 0x11, 0x11, 0x59, 0x8a, 0x02, 0xa8, 0x0a, 0xa2, 0xa3, 0x55, 0x06, 0x80, 0x85, 0x04, 0x44, 0x29, 0x6d, 0x04, 0xaa, 0x22, 0x05, 0x28, 0xad, 0xa2, 0x24, 0x46, 0x03, 0x40, 0x46, 0x02, 0xa8, 0xa8, 0x08, 0xc0, 0xd8, 0x0a, 0x03, 0x03, 0x8a, 0x03, 0x0a, 0x55, 0x00, 0xbc, 0x02, 0x29, 0x05, 0x40, 0x41, 0x82, 0xa1, 0x40, 0x60, 0x6a, 0x8d, 0x01, 0x54, 0x01, 0x0a, 0x0b, 0x40, 0x40, 0x10, 0x49, 0x0a, 0x25, 0x40, 0x10, 0x60, 0x54, 0x55, 0x14, 0x55, 0xab, 0x01, 0x44, 0xac, 0xc2, 0x88, 0x08, 0x85, 0xdb, 0xfc, 0x54, 0x88, 0x83, 0x30, 0xa0, 0x20, 0x80, 0xa9, 0x13, 0x04, 0xb4, 0x10, 0x60, 0x68, 0x30, 0x16, 0x07, 0x12, 0x01, 0x84, 0x44, 0x40, 0xa9, 0x88, 0xc1, 0x50, 0x16, 0x08, 0x80, 0x20, 0xaa, 0x09, 0x41, 0x54, 0x10, 0x42, 0xd2, 0x81, 0x50, 0x56, 0x41, 0xa0, 0x0a, 0x08, 0x28, 0x52, 0x8a, 0x25, 0x05, 0x14, 0xc8, 0x83, 0x56, 0x83, 0x91, 0x50, 0x2e, 0xcb, 0x90, 0x40, 0x1d, 0xf6, 0xc8, 0x25, 0xa3, 0x30, 0xa0, 0x84, 0x54, 0x10, 0x60, 0xca, 0xa0, 0x9b, 0x02, 0x2d, 0x02, 0x76, 0x04, 0x06, 0x04, 0xed, 0x02, 0x60, 0x4e, 0xc0, 0x82, 0xa8, 0x11, 0x30, 0x41, 0x41, 0x84, 0x20, 0x82, 0x0a, 0x08, 0x44, 0x45, 0x05, 0x51, 0x50, 0xa1, 0x11, 0x10, 0x51, 0x28, 0x50, 0x4a, 0x0a, 0x49, 0x42, 0x80, 0x81, 0x12, 0x14, 0x89, 0x80, 0x20, 0x0c, 0x1a, 0x24, 0x8e, 0x80, 0xc5, 0xe0, 0x88, 0x60, 0x40, 0x60, 0x88, 0xe0, 0x09, 0x04, 0x02, 0x22, 0x2e, 0xc8, 0xaa, 0x0a, 0x09, 0xb2, 0xb0, 0x15, 0x52, 0x8e, 0xd8, 0x0a, 0x21, 0x45, 0x00, 0xd8, 0x50, 0x51, 0x48, 0x8d, 0x5a, 0x94, 0x40, 0x44, 0x14, 0x40, 0x1a, 0x5a, 0x22, 0x08, 0x51, 0x10, 0x4a, 0xa2, 0x0c, 0x2d, 0x04, 0x22, 0xe0, 0x82, 0xac, 0x15, 0x54, 0xbe, 0x08, 0x94, 0x25, 0x02, 0x45, 0x58, 0x24, 0x44, 0xa0, 0x30, 0x44, 0x05, 0x00, 0x55, 0x80, 0xa5, 0x10, 0x50, 0x06, 0x02, 0x94, 0x42, 0x22, 0x30, 0x15, 0x28, 0x50, 0x04, 0x60, 0x2a, 0x52, 0x8a, 0x88, 0xc0, 0x54, 0x42, 0x82, 0x23, 0x01, 0x51, 0x1a, 0x80, 0x8c, 0x05, 0x45, 0x40, 0x44, 0x89, 0x85, 0x05, 0x51, 0x19, 0x81, 0x40, 0x28, 0x05, 0x03, 0x67, 0x44, 0x68, 0x54, 0xa0, 0x4c, 0x0b, 0x03, 0x41, 0x49, 0x81, 0x8f, 0x80, 0xbe, 0x00, 0x8b, 0x40, 0x62, 0x30, 0x45, 0x50, 0x60, 0x28, 0x14, 0x19, 0x04, 0x12, 0x27, 0x55, 0x41, 0x54, 0x40, 0x14, 0x41, 0xa6, 0xca, 0x25, 0x0a, 0x08, 0x20, 0xe5, 0x12, 0x83, 0x01, 0x69, 0xb2, 0x88, 0x2a, 0x2c, 0x05, 0xca, 0x2a, 0x08, 0x20, 0xd3, 0x65, 0x10, 0x04, 0xaa, 0xa0, 0xe5, 0x1a, 0x05, 0x0a, 0x0f, 0x36, 0x50, 0x0a, 0x25, 0x28, 0x83, 0xa2, 0x25, 0x54, 0x01, 0xe6, 0xc8, 0x08, 0x05, 0xa2, 0xb3, 0x02, 0x03, 0x02, 0x52, 0x24, 0x04, 0x50, 0xaa, 0x8a, 0xc0, 0x98, 0x1b, 0x02, 0x60, 0x6a, 0xa0, 0x28, 0xaa, 0x20, 0x80, 0xa3, 0x22, 0x80, 0x20, 0x25, 0xb4, 0xa1, 0x6a, 0x02, 0x08, 0xa5, 0x04, 0x04, 0x11, 0x42, 0x91, 0x40, 0xb6, 0x95, 0x04, 0x40, 0x50, 0x26, 0x04, 0x44, 0x04, 0x76, 0x32, 0x20, 0x22, 0x2e, 0xd9, 0x22, 0x25, 0x07, 0x6c, 0xc0, 0x54, 0x08, 0x8c, 0x0a, 0x22, 0xbe, 0x89, 0x40, 0x55, 0x40, 0x10, 0x08, 0x98, 0x44, 0x80, 0xa8, 0x21, 0x41, 0x01, 0x42, 0x85, 0x0a, 0x25, 0x28, 0x2b, 0x4a, 0x02, 0x48, 0x94, 0x01, 0x42, 0x91, 0x71, 0x51, 0x01, 0x98, 0xd2, 0xa2, 0x28, 0x24, 0xc4, 0x82, 0x22, 0x05, 0x99, 0x28, 0x88, 0x94, 0x66, 0x03, 0x64, 0x11, 0x0a, 0x55, 0x5a, 0xaa, 0x54, 0x4a, 0x02, 0xa5, 0x02, 0x82, 0xa5, 0x80, 0xd2, 0x85, 0x00, 0x54, 0x89, 0x14, 0x88, 0x8b, 0x05, 0x60, 0x6c, 0x7c, 0x9e, 0x00, 0x89, 0xc2, 0x10, 0x41, 0x56, 0x03, 0x11, 0x2b, 0x44, 0x14, 0x01, 0xd8, 0x41, 0x04, 0x04, 0x01, 0xd8, 0x4a, 0xd1, 0x0a, 0xaa, 0x38, 0x18, 0x0b, 0x41, 0x04, 0x76, 0x02, 0xa0, 0x94, 0x01, 0x1d, 0xa4, 0x41, 0xa3, 0x41, 0x04, 0x76, 0x12, 0xb0, 0x1a, 0x82, 0x3b, 0x08, 0x36, 0xb4, 0x10, 0x57, 0x61, 0x2a, 0x08, 0x56, 0x82, 0xec, 0x20, 0x82, 0x02, 0x02, 0xb8, 0x55, 0x08, 0x88, 0x08, 0xaa, 0x0a, 0xa0, 0x44, 0x40, 0xbe, 0x8d, 0x80, 0x33, 0x30, 0x65, 0x51, 0x99, 0xad, 0xc8, 0x24, 0x5e, 0x88, 0x0a, 0xc0, 0xa8, 0x58, 0x0d, 0x15, 0x15, 0x40, 0x42, 0x88, 0x2c, 0x09, 0x01, 0x41, 0x15, 0x0a, 0x82, 0x28, 0x2a, 0x2a, 0x51, 0xaa, 0x80, 0x2a, 0x44, 0x42, 0x88, 0x20, 0xa9, 0x11, 0x00, 0xa2, 0x88, 0x22, 0x89, 0x41, 0x0a, 0x14, 0xa0, 0x22, 0x14, 0x2b, 0x6d, 0x04, 0x04, 0x41, 0x0b, 0x02, 0x88, 0x89, 0x22, 0x82, 0x08, 0x30, 0x18, 0xd0, 0xbe, 0x55, 0x85, 0xa1, 0x1a, 0x04, 0x10, 0x36, 0x66, 0x24, 0x10, 0x44, 0x88, 0x9b, 0x64, 0x16, 0xa0, 0x13, 0x22, 0x08, 0x0b, 0x62, 0x41, 0x11, 0x28, 0xc0, 0x62, 0x52, 0x0a, 0xd1, 0x28, 0x11, 0x20, 0x50, 0xa3, 0x6d, 0x58, 0x1a, 0xc0, 0x90, 0x06, 0xb5, 0x54, 0x55, 0x19, 0x44, 0x01, 0x11, 0x00, 0xb0, 0x14, 0x04, 0x44, 0x05, 0x16, 0x02, 0xaa, 0x44, 0xac, 0x48, 0xa2, 0xc1, 0x10, 0x04, 0x08, 0xb8, 0x04, 0x44, 0x7a, 0x22, 0x70, 0x44, 0x10, 0x88, 0x80, 0xa0, 0x83, 0xb6, 0x54, 0x42, 0xa0, 0xed, 0x81, 0x12, 0x8d, 0xa6, 0xd8, 0x11, 0x0a, 0x83, 0xb6, 0x32, 0x20, 0x25, 0x8b, 0x58, 0x1d, 0x28, 0xa8, 0x21, 0x68, 0x80, 0x91, 0x20, 0x5b, 0x64, 0x60, 0x4c, 0x09, 0x60, 0x51, 0x40, 0x8e, 0x23, 0xa0, 0xed, 0x80, 0x40, 0x10, 0x15, 0x66, 0x10, 0xaa, 0x23, 0x45, 0x98, 0x90, 0xa0, 0x80, 0x2c, 0xc4, 0x82, 0x08, 0x84, 0x58, 0xa1, 0x4a, 0x08, 0x30, 0x16, 0xad, 0x16, 0xa8, 0xa0, 0x50, 0x04, 0xa0, 0x08, 0x82, 0x8a, 0x88, 0x2d, 0x11, 0x29, 0x6c, 0x06, 0x85, 0x04, 0x4a, 0x01, 0x56, 0x91, 0x22, 0x26, 0x12, 0x0b, 0x08, 0x89, 0x00, 0xac, 0x82, 0xc4, 0x60, 0x91, 0x10, 0x18, 0x1a, 0x94, 0x28, 0x45, 0x4a, 0x14, 0xa2, 0xe5, 0x81, 0xda, 0x0b, 0xb2, 0x84, 0x48, 0x57, 0x61, 0x51, 0x04, 0x01, 0xdb, 0x0a, 0x50, 0x10, 0x07, 0x6c, 0x2c, 0x83, 0x45, 0x15, 0x76, 0xd1, 0x10, 0xa5, 0xa0, 0xbb, 0x20, 0x28, 0x52, 0x85, 0xdb, 0x20, 0x09, 0x68, 0x51, 0x0c, 0x80, 0x20, 0x52, 0x82, 0xa8, 0x04, 0x48, 0x06, 0x11, 0x11, 0x00, 0x8e, 0x88, 0xc2, 0x90, 0x16, 0x12, 0x94, 0x22, 0xb0, 0x15, 0x11, 0x81, 0xc5, 0x04, 0x0a, 0xd6, 0x40, 0x40, 0x50, 0x60, 0x54, 0x40, 0xa2, 0x82, 0xa4, 0x54, 0x54, 0x14, 0xdb, 0xcc, 0x22, 0x2a, 0x8a, 0x7d, 0xf6, 0xfb, 0x88, 0xa9, 0x62, 0xc2, 0xd1, 0x42, 0x81, 0x42, 0x80, 0x50, 0x50, 0x40, 0x40, 0x40, 0x41, 0x8f, 0x80, 0x9e, 0x81, 0xc5, 0xe0, 0x88, 0x0c, 0x05, 0x22, 0x20, 0xc0, 0x69, 0x44, 0x40, 0x88, 0x95, 0x44, 0x51, 0x28, 0xa0, 0x22, 0x94, 0x11, 0x28, 0x49, 0x68, 0x8b, 0x6d, 0x11, 0x45, 0x40, 0x45, 0x00, 0x45, 0x10, 0x15, 0x22, 0x35, 0x14, 0x60, 0x34, 0x19, 0x81, 0x10, 0x54, 0x52, 0x8c, 0xc0, 0xa9, 0x40, 0xa2, 0x03, 0xb5, 0xc2, 0x82, 0x94, 0x41, 0x66, 0x02, 0x24, 0x04, 0x4b, 0x6c, 0xa0, 0x11, 0x10, 0x08, 0x88, 0xbd, 0x05, 0x58, 0x52, 0x11, 0x58, 0x0a, 0x82, 0x82, 0x03, 0x01, 0x42, 0xa5, 0x92, 0x80, 0xaa, 0x0d, 0x0a, 0x09, 0x4a, 0x82, 0xa8, 0x55, 0x1a, 0x58, 0x0a, 0x82, 0x08, 0x81, 0x6d, 0x05, 0x28, 0x05, 0x0a, 0xa4, 0x44, 0xa5, 0x1a, 0x82, 0x08, 0x0a, 0x0a, 0x82, 0xb4, 0x40, 0x10, 0x66, 0x08, 0x0a, 0x00, 0xab, 0x31, 0x2a, 0xc0, 0x99, 0x81, 0x56, 0x0a, 0xed, 0x96, 0x10, 0xed, 0x98, 0x4c, 0x44, 0xa8, 0x81, 0x2a, 0xc0, 0x62, 0x20, 0x80, 0x2c, 0x06, 0xa0, 0x29, 0x41, 0x45, 0x46, 0x4a, 0x51, 0x28, 0x22, 0xa8, 0xa0, 0x54, 0x19, 0x81, 0xa5, 0x10, 0x66, 0x04, 0x0a, 0x83, 0x30, 0x05, 0xa2, 0x8e, 0xd8, 0x4a, 0x02, 0x44, 0xa9, 0x41, 0x81, 0x20, 0x2b, 0x02, 0x68, 0xac, 0x0d, 0x06, 0x0a, 0xaa, 0xa7, 0x8d, 0x40, 0x54, 0x15, 0x02, 0x81, 0x48, 0x88, 0xa5, 0xa2, 0x81, 0x44, 0x01, 0x4b, 0x68, 0x91, 0x10, 0x11, 0x28, 0xa8, 0x20, 0x85, 0x14, 0xa9, 0x50, 0x05, 0x03, 0x64, 0x8a, 0x6c, 0x51, 0x91, 0x66, 0x14, 0xa8, 0xac, 0xc0, 0x85, 0x15, 0x76, 0x50, 0x08, 0xc8, 0xa9, 0x22, 0xb0, 0x16, 0x60, 0x01, 0x40, 0x1c, 0xe4, 0x28, 0xa0, 0xb3, 0x02, 0x24, 0x8a, 0x24, 0xc0, 0x82, 0x0a, 0xc0, 0x5a, 0x2d, 0x15, 0x15, 0x0a, 0x00, 0x8d, 0x0a, 0x52, 0xa0, 0x88, 0x85, 0x28, 0xa2, 0x20, 0xa8, 0x28, 0x22, 0x00, 0xa2, 0x8a, 0x21, 0x44, 0x28, 0x20, 0xad, 0x28, 0x0a, 0x80, 0x21, 0x11, 0x81, 0x2a, 0x80, 0xbe, 0x8c, 0x11, 0x30, 0x10, 0x04, 0x56, 0x60, 0x50, 0x2d, 0x40, 0x90, 0x26, 0x15, 0x01, 0x15, 0x01, 0x26, 0x05, 0x45, 0x15, 0x04, 0x26, 0x04, 0x4a, 0x58, 0x0a, 0x22, 0xa8, 0x85, 0x2a, 0x83, 0x02, 0x88, 0x88, 0x2a, 0x88, 0xa2, 0x82, 0x34, 0x05, 0x10, 0x05, 0x28, 0x50, 0x45, 0x10, 0x15, 0x12, 0x94, 0x01, 0x10, 0x11, 0x0a, 0x28, 0xa2, 0x44, 0x44, 0xb6, 0x03, 0x68, 0x30, 0x15, 0x14, 0x54, 0xa0, 0xc0, 0x90, 0x04, 0x40, 0x18, 0x14, 0x48, 0x89, 0x00, 0xbe, 0x84, 0x44, 0x42, 0x22, 0x11, 0x20, 0x10, 0x40, 0x55, 0x0a, 0x52, 0x88, 0x25, 0x01, 0x45, 0x14, 0x14, 0x40, 0xa5, 0x80, 0xd0, 0xa2, 0x2a, 0x50, 0x51, 0x60, 0x2a, 0x09, 0x11, 0x22, 0x36, 0x88, 0xb6, 0x22, 0x48, 0xb0, 0x14, 0x4a, 0x0a, 0xd5, 0x4a, 0x0a, 0x25, 0x04, 0x05, 0x41, 0x50, 0x4b, 0x4a, 0x20, 0x5a, 0x20, 0x0c, 0x05, 0x01, 0x41, 0x00, 0x89, 0xec, 0x65, 0x58, 0x1b, 0x32, 0xb0, 0x46, 0x65, 0x60, 0x91, 0x70, 0xae, 0x8b, 0xc1, 0x19, 0x88, 0x08, 0xb4, 0xc4, 0x02, 0x0a, 0x02, 0xec, 0xa9, 0x40, 0x2c, 0x05, 0x76, 0xc5, 0x28, 0x80, 0xa0, 0x2e, 0xd9, 0xb1, 0x10, 0x04, 0x15, 0x40, 0x10, 0x1a, 0x0d, 0x10, 0x42, 0xd2, 0x94, 0x2a, 0x82, 0x08, 0x50, 0x1a, 0xd1, 0x68, 0x82, 0xa2, 0x88, 0x02, 0x82, 0x02, 0x14, 0xa2, 0x91, 0x20, 0x10, 0x0a, 0x14, 0x18, 0x1a, 0x80, 0x88, 0x0c, 0x12, 0x23, 0x24, 0x46, 0x10, 0xa8, 0x66, 0x81, 0x2a, 0x91, 0x32, 0x44, 0x60, 0x34, 0x11, 0x02, 0xa9, 0x51, 0x6b, 0xb6, 0x44, 0x12, 0xed, 0x81, 0x04, 0x71, 0x91, 0x44, 0x04, 0x68, 0x8d, 0x0a, 0x00, 0x88, 0x44, 0xc5, 0x50, 0xbe, 0x84, 0xc4, 0x88, 0xcc, 0xc0, 0xa8, 0x0b, 0x01, 0x59, 0x81, 0x42, 0xd5, 0x0a, 0x48, 0xb3, 0x02, 0xc0, 0xad, 0x2a, 0x13, 0x02, 0x85, 0x14, 0xb4, 0x44, 0xdb, 0x28, 0x51, 0x4a, 0x08, 0x4c, 0x0a, 0x91, 0x11, 0x51, 0x74, 0x44, 0x0a, 0x14, 0x50, 0x30, 0x29, 0x55, 0x04, 0x88, 0x8a, 0xa0, 0x50, 0x18, 0x1a, 0x08, 0x51, 0xa5, 0x2a, 0xa0, 0x82, 0x5b, 0x52, 0x80, 0x8a, 0xa0, 0x80, 0x21, 0x68, 0xc0, 0xe2, 0x40, 0x2b, 0x08, 0x88, 0x80, 0xbc, 0x00, 0x8c, 0x40, 0x58, 0x32, 0x80, 0x20, 0x8d, 0xa5, 0x04, 0x01, 0xa3, 0x50, 0x52, 0x44, 0x05, 0x14, 0x4a, 0x22, 0x80, 0x81, 0x46, 0x82, 0x20, 0x08, 0x09, 0x40, 0x44, 0x01, 0x4a, 0x50, 0x14, 0x40, 0x10, 0x41, 0x42, 0x88, 0x02, 0x00, 0xa5, 0xa8, 0x91, 0x2b, 0x40, 0x40, 0x46, 0x60, 0x42, 0x28, 0x39, 0xdb, 0x0b, 0x04, 0x66, 0x00, 0x18, 0x23, 0x30, 0x00, 0xc1, 0x22, 0xa0, 0xae, 0x83, 0xc4, 0x61, 0x2a, 0x02, 0xc1, 0xd6, 0x02, 0xc1, 0x94, 0x2d, 0x06, 0x0a, 0xa5, 0xa1, 0x46, 0x0a, 0x94, 0x02, 0x88, 0x2a, 0x80, 0x81, 0x69, 0x12, 0x08, 0xa0, 0xa0, 0x0b, 0xa1, 0x16, 0xd9, 0x17, 0x24, 0x4c, 0x50, 0x15, 0xc9, 0x13, 0xc3, 0x4a, 0xac, 0xce, 0x20, 0x11, 0xb0, 0xa3, 0x09, 0x50, 0x58, 0x52, 0xa8, 0x8d, 0x80, 0xc5, 0x20, 0x6a, 0xb0, 0x28, 0x90, 0x20, 0x0a, 0x52, 0x81, 0x22, 0x08, 0xa2, 0xd6, 0x94, 0xb1, 0x12, 0x62, 0x42, 0xd1, 0x50, 0x26, 0x24, 0x10, 0x14, 0x49, 0x89, 0xa1, 0x41, 0x46, 0xcc, 0x45, 0xa9, 0x45, 0x01, 0x51, 0x5a, 0x14, 0x88, 0x85, 0x0a, 0x14, 0x28, 0x80, 0x85, 0x0a, 0x14, 0x28, 0x81, 0x12, 0x02, 0x25, 0x04, 0x88, 0x80, 0x6e, 0x82, 0x44, 0xe0, 0x91, 0x10, 0x41, 0x56, 0x02, 0x80, 0x81, 0x40, 0x10, 0x55, 0x1b, 0x45, 0x14, 0x11, 0x60, 0x48, 0x82, 0x8a, 0xa0, 0xa9, 0x5a, 0x14, 0x28, 0x2e, 0xd8, 0x01, 0x14, 0x10, 0x17, 0x6c, 0x80, 0x48, 0x22, 0xa2, 0xbb, 0x64, 0x15, 0x0a, 0x14, 0x22, 0xa2, 0x80, 0x80, 0xc1, 0xa2, 0xa0, 0xae, 0x22, 0x30, 0xa4, 0x06, 0x14, 0x89, 0x13, 0x82, 0x30, 0x2b, 0x24, 0x48, 0x01, 0x28, 0xb4, 0x54, 0x04, 0x01, 0x15, 0x4a, 0x01, 0x44, 0x01, 0x22, 0x22, 0x0d, 0x22, 0x40, 0xaa, 0x2d, 0x81, 0x28, 0x54, 0x28, 0x22, 0x8a, 0x2c, 0x15, 0x1d, 0xb2, 0x44, 0xc1, 0x50, 0xdb, 0x03, 0x01, 0x55, 0x11, 0xdb, 0x23, 0x06, 0x45, 0x44, 0x60, 0xcc, 0x0d, 0x83, 0x45, 0x40, 0x9b, 0x88, 0x8a, 0xb0, 0x27, 0x6c, 0x88, 0x2a, 0x80, 0xed, 0x95, 0x0a, 0x08, 0x0c, 0xc0, 0xa5, 0x0a, 0xa8, 0xb3, 0x02, 0x81, 0x41, 0x15, 0xdb, 0x0a, 0x52, 0x88, 0x8a, 0x00, 0x85, 0x04, 0x41, 0x44, 0x54, 0x88, 0x94, 0x46, 0x85, 0x00, 0x50, 0xa4, 0x85, 0x00, 0xa0, 0xa0, 0x25, 0x2d, 0x28, 0xaa, 0x11, 0x20, 0x54, 0x11, 0x40, 0x15, 0x40, 0x15, 0x00, 0xb9, 0x8b, 0x00, 0x30, 0x45, 0x51, 0x22, 0x42, 0x0a, 0x89, 0x4a, 0x50, 0xa2, 0xc0, 0xda, 0x02, 0xad, 0x0b, 0x50, 0x54, 0x10, 0x51, 0x2a, 0x80, 0xb5, 0x02, 0x92, 0x20, 0x08, 0x52, 0x8a, 0x80, 0x22, 0x05, 0x04, 0x01, 0x14, 0x04, 0x40, 0x50, 0x88, 0x88, 0x0c, 0x15, 0x01, 0x98, 0xd5, 0x01, 0x98, 0xd8, 0x0c, 0x54, 0x6d, 0x82, 0xaa, 0xc0, 0xa2, 0xa0, 0xa0, 0x0a, 0x16, 0x05, 0x48, 0x90, 0x0a, 0x28, 0x0b, 0xb6, 0x51, 0xb4, 0xa5, 0xad, 0x5d, 0xb2, 0x88, 0x04, 0x80, 0x81, 0xb6, 0x50, 0xa8, 0xad, 0xa0, 0x6d, 0x94, 0xa1, 0x68, 0x51, 0x66, 0x05, 0x5b, 0x03, 0x89, 0x82, 0x11, 0x38, 0x22, 0xa8, 0xb8, 0x08, 0xa8, 0x03, 0xf7, 0x7e, 0xe8, 0x03, 0xbe, 0xfb, 0xe4, 0x01, 0xfb, 0xef, 0xba, 0x00, 0xef, 0xbe, 0xf9, 0x00, 0x7e, 0xfb, 0xee, 0x80, 0x2a, 0x02, 0xb0, 0x24, 0x04, 0x02, 0x24, 0x44, 0xe0, 0xea, 0x52, 0x94, 0xa5, 0x15, 0x29, 0x4a, 0x51, 0x46, 0x94, 0xa5, 0x2a, 0x08, 0x16, 0x4a, 0x02, 0x08, 0x44, 0x41, 0x05, 0x50, 0x15, 0x40, 0xab, 0x81, 0xaa, 0xc2, 0x10, 0x58, 0x3a, 0x02, 0xc1, 0x92, 0xd1, 0x60, 0x6a, 0xd0, 0xa2, 0x80, 0xaa, 0x01, 0x40, 0x45, 0x41, 0x22, 0x20, 0x88, 0x02, 0x33, 0x05, 0x11, 0x10, 0x29, 0x30, 0x22, 0x21, 0x44, 0x77, 0xd9, 0x11, 0x50, 0x55, 0x15, 0x10, 0x15, 0x49, 0x28, 0x2d, 0x58, 0x0a, 0xa5, 0x80, 0xb0, 0x34, 0x14, 0x06, 0x07, 0x15, 0x00, 0xbe, 0x81, 0x46, 0x20, 0x4b, 0xb0, 0x02, 0x03, 0x01, 0x5d, 0xb9, 0x40, 0x28, 0x80, 0x2e, 0xdf, 0x22, 0x34, 0x50, 0x07, 0x6f, 0x91, 0x12, 0x82, 0x2a, 0xed, 0x90, 0x40, 0x11, 0x10, 0x51, 0x83, 0x22, 0x49, 0x4a, 0x2a, 0x08, 0x8a, 0x25, 0x02, 0x80, 0x88, 0x08, 0x2b, 0x68, 0x08, 0x88, 0x88, 0x02, 0x05, 0x01, 0x12, 0x22, 0x09, 0x52, 0x23, 0x02, 0x41, 0xa0, 0x20, 0x20, 0x20, 0x82, 0x0a, 0x80, 0xb0, 0x14, 0x10, 0x60, 0x48, 0x02, 0x82, 0xac, 0x0a, 0x24, 0x28, 0x23, 0x21, 0x38, 0x2e, 0x24, 0x28, 0x37, 0x35, 0x4c, 0x3b, 0x33, 0x3c, 0x43, 0x3e, 0x33, 0x31, 0x39, 0x47, 0x4b, 0x37, 0x47, 0x46, 0x45, 0x44, 0x2c, 0x39, 0x3f, 0x35, 0x43, 0x41, 0x31, 0x2c, 0x36, 0x4b, 0x46, 0x42, 0x1f, 0x48, 0x3f, 0x35, 0x39, 0x32, 0x3c, 0x3a, 0x34, 0x2e, 0x38, 0x38, 0x4b, 0xff, };

Le texte

"Sokoban by Hap\n"
"keys:\n"
"5 up\n"
"8 down\n"
"7 left\n"
"9 right\n"
"A select\n"

Un autre utilitaire est chip-dasm qui est un dé-assembleur. A partir d'un fichier binaire SCHIP il génère un fichier lisible par l'humain ou chaque instruction est représenté par un mnémonique. Voici ce que ça donne avec le fichier field.ch8

0x200 0x00FF HIGH ;--- JP target --- 0x202 0x612A LD V1, 42 0x204 0x6201 LD V2, 1 0x206 0xA4BC LD I, 0x4BC 0x208 0xD120 DRAW V1, V2, 0 0x20A 0x613A LD V1, 58 0x20C 0xA4DC LD I, 0x4DC 0x20E 0xD120 DRAW V1, V2, 0 0x210 0x614A LD V1, 74 0x212 0xA4FC LD I, 0x4FC 0x214 0xD120 DRAW V1, V2, 0 0x216 0x6140 LD V1, 64 0x218 0x6230 LD V2, 48 0x21A 0xA47C LD I, 0x47C 0x21C 0xD120 DRAW V1, V2, 0 0x21E 0x6130 LD V1, 48 0x220 0xA45C LD I, 0x45C 0x222 0xD120 DRAW V1, V2, 0 0x224 0x6220 LD V2, 32 0x226 0x6330 LD V3, 48 0x228 0x6420 LD V4, 32 0x22A 0x6E01 LD VE, 1 0x22C 0x6D03 LD VD, 3 0x22E 0xA39C LD I, 0x39C 0x230 0xD120 DRAW V1, V2, 0 0x232 0xA3BC LD I, 0x3BC 0x234 0x6140 LD V1, 64 0x236 0xD120 DRAW V1, V2, 0 0x238 0x65FF LD V5, 255 ;--- JP target --- 0x23A 0x85E5 SUB V5, VE 0x23C 0x3500 SE V5==0 0x23E 0x123A JP 0x23A 0x240 0x65FF LD V5, 255 ;--- JP target --- 0x242 0x85E5 SUB V5, VE 0x244 0x3500 SE V5==0 0x246 0x1242 JP 0x242 0x248 0x6130 LD V1, 48 0x24A 0xA39C LD I, 0x39C 0x24C 0xD120 DRAW V1, V2, 0 0x24E 0xA3DC LD I, 0x3DC 0x250 0xD120 DRAW V1, V2, 0 0x252 0x65F0 LD V5, 240 ;--- JP target --- 0x254 0x85E5 SUB V5, VE 0x256 0x3500 SE V5==0 0x258 0x1254 JP 0x254 0x25A 0xD120 DRAW V1, V2, 0 0x25C 0xA3FC LD I, 0x3FC 0x25E 0xD120 DRAW V1, V2, 0 0x260 0x83D5 SUB V3, VD 0x262 0x84D5 SUB V4, VD 0x264 0xA43C LD I, 0x43C 0x266 0xD340 DRAW V3, V4, 0 0x268 0x65F0 LD V5, 240 ;--- JP target --- 0x26A 0x85E5 SUB V5, VE 0x26C 0x3500 SE V5==0 0x26E 0x126A JP 0x26A 0x270 0xD340 DRAW V3, V4, 0 ;--- JP target --- 0x272 0x83D5 SUB V3, VD 0x274 0x84D5 SUB V4, VD 0x276 0xA41C LD I, 0x41C 0x278 0xD340 DRAW V3, V4, 0 0x27A 0x65F0 LD V5, 240 ;--- JP target --- 0x27C 0x85E5 SUB V5, VE 0x27E 0x3500 SE V5==0 0x280 0x127C JP 0x27C 0x282 0xD340 DRAW V3, V4, 0 0x284 0x83D5 SUB V3, VD 0x286 0x84D5 SUB V4, VD 0x288 0xA43C LD I, 0x43C 0x28A 0xD340 DRAW V3, V4, 0 0x28C 0x65F0 LD V5, 240 ;--- JP target --- 0x28E 0x85E5 SUB V5, VE 0x290 0x3500 SE V5==0 0x292 0x128E JP 0x28E 0x294 0xD340 DRAW V3, V4, 0 0x296 0x6200 LD V2, 0 0x298 0xE29E SKP V2 0x29A 0x1272 JP 0x272 0x29C 0x00E0 CLS 0x29E 0x6301 LD V3, 1 0x2A0 0x6101 LD V1, 1 0x2A2 0x6207 LD V2, 7 0x2A4 0x6920 LD V9, 32 0x2A6 0x6A0F LD VA, 15 0x2A8 0x6501 LD V5, 1 0x2AA 0x6B7A LD VB, 122 0x2AC 0x6E01 LD VE, 1 0x2AE 0x6D00 LD VD, 0 0x2B0 0x6700 LD V7, 0 0x2B2 0xA398 LD I, 0x398 ;--- JP target --- 0x2B4 0x7701 ADD V7, 1 0x2B6 0x47C0 SNE V7==192 0x2B8 0x1320 JP 0x320 ;--- JP target --- 0x2BA 0x6201 LD V2, 1 0x2BC 0xE2A1 SKNP V2 0x2BE 0x1310 JP 0x310 0x2C0 0x6202 LD V2, 2 0x2C2 0xE2A1 SKNP V2 0x2C4 0x1314 JP 0x314 0x2C6 0x6204 LD V2, 4 0x2C8 0xE2A1 SKNP V2 0x2CA 0x1318 JP 0x318 0x2CC 0x6205 LD V2, 5 0x2CE 0xE2A1 SKNP V2 0x2D0 0x131C JP 0x31C 0x2D2 0x6207 LD V2, 7 0x2D4 0xE2A1 SKNP V2 0x2D6 0x1374 JP 0x374 0x2D8 0x6208 LD V2, 8 0x2DA 0xE2A1 SKNP V2 0x2DC 0x1382 JP 0x382 0x2DE 0x620C LD V2, 12 0x2E0 0xE2A1 SKNP V2 0x2E2 0x1326 JP 0x326 0x2E4 0x620D LD V2, 13 0x2E6 0xE2A1 SKNP V2 0x2E8 0x132C JP 0x32C ;--- JP target --- 0x2EA 0x4C01 SNE VC==1 0x2EC 0x1374 JP 0x374 0x2EE 0x4C02 SNE VC==2 0x2F0 0x1382 JP 0x382 ;--- JP target --- 0x2F2 0x6270 LD V2, 112 ;--- JP target --- 0x2F4 0x8235 SUB V2, V3 0x2F6 0x3200 SE V2==0 0x2F8 0x12F4 JP 0x2F4 0x2FA 0xA390 LD I, 0x390 0x2FC 0xC13A RND V1, 0x3A 0x2FE 0x6E40 LD VE, 64 0x300 0x8E15 SUB VE, V1 0x302 0xD5E4 DRAW V5, VE, 4 0x304 0xDBE4 DRAW VB, VE, 4 0x306 0x4C01 SNE VC==1 0x308 0x1332 JP 0x332 0x30A 0x4C02 SNE VC==2 0x30C 0x1338 JP 0x338 0x30E 0x12B4 JP 0x2B4 ;--- JP or CALL target --- 0x310 0x6301 LD V3, 1 0x312 0x12EA JP 0x2EA ;--- JP or CALL target --- 0x314 0x6302 LD V3, 2 0x316 0x12EA JP 0x2EA ;--- JP or CALL target --- 0x318 0x6304 LD V3, 4 0x31A 0x12EA JP 0x2EA ;--- JP or CALL target --- 0x31C 0x6308 LD V3, 8 0x31E 0x12EA JP 0x2EA ;--- JP or CALL target --- 0x320 0x7D01 ADD VD, 1 0x322 0x6700 LD V7, 0 0x324 0x12BA JP 0x2BA ;--- JP or CALL target --- 0x326 0x6E01 LD VE, 1 0x328 0x8AE5 SUB VA, VE 0x32A 0x12EA JP 0x2EA ;--- JP or CALL target --- 0x32C 0x6E01 LD VE, 1 0x32E 0x7A01 ADD VA, 1 0x330 0x12EA JP 0x2EA ;--- JP or CALL target --- 0x332 0xA394 LD I, 0x394 0x334 0xD9A3 DRAW V9, VA, 3 0x336 0x12B4 JP 0x2B4 ;--- JP or CALL target --- 0x338 0xA398 LD I, 0x398 0x33A 0xD9A3 DRAW V9, VA, 3 0x33C 0x12B4 JP 0x2B4 ;--- JP or CALL target --- 0x33E 0x6508 LD V5, 8 0x340 0x8955 SUB V9, V5 0x342 0x8A55 SUB VA, V5 0x344 0xA51C LD I, 0x51C 0x346 0xD9A0 DRAW V9, VA, 0 0x348 0x65F0 LD V5, 240 0x34A 0x6E01 LD VE, 1 ;--- JP target --- 0x34C 0x85E5 SUB V5, VE 0x34E 0x3500 SE V5==0 0x350 0x134C JP 0x34C 0x352 0xA53C LD I, 0x53C 0x354 0xD9A0 DRAW V9, VA, 0 0x356 0x65FF LD V5, 255 0x358 0x6E01 LD VE, 1 ;--- JP target --- 0x35A 0x85E5 SUB V5, VE 0x35C 0x3500 SE V5==0 0x35E 0x135A JP 0x35A 0x360 0x00E0 CLS 0x362 0x612C LD V1, 44 0x364 0x6210 LD V2, 16 0x366 0xA49C LD I, 0x49C 0x368 0xD120 DRAW V1, V2, 0 0x36A 0x6132 LD V1, 50 0x36C 0x6225 LD V2, 37 0x36E 0xFD29 LD F, VD 0x370 0xD125 DRAW V1, V2, 5 0x372 0x1202 JP 0x202 ;--- JP or CALL target --- 0x374 0x00FC SCRL 0x376 0xA394 LD I, 0x394 0x378 0xD9A3 DRAW V9, VA, 3 0x37A 0x4F01 SNE VF==1 0x37C 0x133E JP 0x33E 0x37E 0x6C01 LD VC, 1 0x380 0x12F2 JP 0x2F2 ;--- JP or CALL target --- 0x382 0x00FB SCR 0x384 0xA398 LD I, 0x398 0x386 0xD9A3 DRAW V9, VA, 3 0x388 0x4F01 SNE VF==1 0x38A 0x133E JP 0x33E 0x38C 0x6C02 LD VC, 2 0x38E 0x12F2 JP 0x2F2 ;------------------------- ;- LD I, NNN addresses - ;------------------------- 0x4BC .DW 0x0000 0x4BE .DW 0xFF7E 0x4C0 .DW 0xFF7E 0x4C2 .DW 0xE018 0x4C4 .DW 0xE018 0x4C6 .DW 0xE018 0x4C8 .DW 0xFC18 0x4CA .DW 0xFC18 0x4CC .DW 0xE018 0x4CE .DW 0xE018 0x4D0 .DW 0xE018 0x4D2 .DW 0xE018 0x4D4 .DW 0xE07E 0x4D6 .DW 0xE07E 0x4D8 .DW 0x0000 0x4DA .DW 0x0000 0x4DC .DW 0x0000 0x4DE .DW 0xFF70 0x4E0 .DW 0xFF70 0x4E2 .DW 0xE070 0x4E4 .DW 0xE070 0x4E6 .DW 0xE070 0x4E8 .DW 0xFC70 0x4EA .DW 0xFC70 0x4EC .DW 0xE070 0x4EE .DW 0xE070 0x4F0 .DW 0xE070 0x4F2 .DW 0xE070 0x4F4 .DW 0xFF7E 0x4F6 .DW 0xFF7E 0x4F8 .DW 0x0000 0x4FA .DW 0x0000 0x4FC .DW 0x0000 0x4FE .DW 0xF808 0x500 .DW 0xFE1C 0x502 .DW 0xE73E 0x504 .DW 0xE73E 0x506 .DW 0xE73E 0x508 .DW 0xE73E 0x50A .DW 0xE71C 0x50C .DW 0xE71C 0x50E .DW 0xE71C 0x510 .DW 0xE708 0x512 .DW 0xE700 0x514 .DW 0xFE1C 0x516 .DW 0xF81C 0x518 .DW 0x0000 0x51A .DW 0x0000 0x47C .DW 0x2002 0x47E .DW 0x2002 0x480 .DW 0x2002 0x482 .DW 0x26C6 0x484 .DW 0xAAAA 0x486 .DW 0x26A6 0x488 .DW 0x0000 0x48A .DW 0x7060 0x48C .DW 0x20A0 0x48E .DW 0x2484 0x490 .DW 0x2AAA 0x492 .DW 0x2AAA 0x494 .DW 0x2464 0x496 .DW 0x0000 0x498 .DW 0x0000 0x49A .DW 0x0000 0x45C .DW 0x2430 0x45E .DW 0x5428 0x460 .DW 0x5430 0x462 .DW 0x7429 0x464 .DW 0x542A 0x466 .DW 0x5429 0x468 .DW 0x0000 0x46A .DW 0x5000 0x46C .DW 0x5480 0x46E .DW 0x71E0 0x470 .DW 0x5480 0x472 .DW 0x5483 0x474 .DW 0x5443 0x476 .DW 0x0000 0x478 .DW 0x0000 0x47A .DW 0x0000 0x39C .DW 0x0000 0x39E .DW 0x2083 0x3A0 .DW 0x3186 0x3A2 .DW 0x7FC7 0x3A4 .DW 0x4A46 0x3A6 .DW 0x7BC6 0x3A8 .DW 0x3F80 0x3AA .DW 0x5F43 0x3AC .DW 0xFFE4 0x3AE .DW 0xDF63 0x3B0 .DW 0xFFE0 0x3B2 .DW 0xDB60 0x3B4 .DW 0xAAA3 0x3B6 .DW 0x6AC0 0x3B8 .DW 0xEAFF 0x3BA .DW 0xD57F 0x3BC .DW 0x0000 0x3BE .DW 0xC600 0x3C0 .DW 0x6600 0x3C2 .DW 0xE600 0x3C4 .DW 0x6600 0x3C6 .DW 0x67C0 0x3C8 .DW 0x0000 0x3CA .DW 0xC060 0x3CC .DW 0x0084 0x3CE .DW 0x8C8E 0x3D0 .DW 0x52C4 0x3D2 .DW 0x5284 0x3D4 .DW 0x8C83 0x3D6 .DW 0x0000 0x3D8 .DW 0xFFFF 0x3DA .DW 0xFFFF 0x3DC .DW 0x0400 0x3DE .DW 0x1E03 0x3E0 .DW 0x3786 0x3E2 .DW 0x7F87 0x3E4 .DW 0x0FC6 0x3E6 .DW 0x0776 0x3E8 .DW 0x0FF8 0x3EA .DW 0x0FDB 0x3EC .DW 0x07FC 0x3EE .DW 0x03EF 0x3F0 .DW 0x01DF 0x3F2 .DW 0x009F 0x3F4 .DW 0x000F 0x3F6 .DW 0x0107 0x3F8 .DW 0xFFFF 0x3FA .DW 0xFF7F 0x3FC .DW 0x0000 0x3FE .DW 0x0003 0x400 .DW 0x0006 0x402 .DW 0x0007 0x404 .DW 0x0006 0x406 .DW 0x0006 0x408 .DW 0x0000 0x40A .DW 0x0003 0x40C .DW 0x0004 0x40E .DW 0x0003 0x410 .DW 0x0000 0x412 .DW 0x0000 0x414 .DW 0x0003 0x416 .DW 0x0000 0x418 .DW 0xFFFF 0x41A .DW 0xFF7F 0x43C .DW 0x1000 0x43E .DW 0x3C0E 0x440 .DW 0x5EBF 0x442 .DW 0xFFFF 0x444 .DW 0x3FFF 0x446 .DW 0x0FF7 0x448 .DW 0x07FB 0x44A .DW 0x07F9 0x44C .DW 0x03F8 0x44E .DW 0x01FC 0x450 .DW 0x00DE 0x452 .DW 0x009E 0x454 .DW 0x005F 0x456 .DW 0x000F 0x458 .DW 0x000F 0x45A .DW 0x0000 0x41C .DW 0x0400 0x41E .DW 0x1E00 0x420 .DW 0x3780 0x422 .DW 0x7F80 0x424 .DW 0x0FC0 0x426 .DW 0x0770 0x428 .DW 0x0FF8 0x42A .DW 0x0FD8 0x42C .DW 0x07F8 0x42E .DW 0x03EE 0x430 .DW 0x01DF 0x432 .DW 0x009F 0x434 .DW 0x004F 0x436 .DW 0x0067 0x438 .DW 0x0003 0x43A .DW 0x0000 0x398 .DB 0x07 0x399 .DB 0xFE 0x39A .DB 0x07 0x390 .DW 0x6EFF 0x392 .DW 0x7E33 0x394 .DW 0xE07F 0x396 .DW 0xE000 0x51C .DW 0x0002 0x51E .DW 0x100C 0x520 .DW 0x0814 0x522 .DW 0x0EC0 0x524 .DW 0x05A0 0x526 .DW 0x061C 0x528 .DW 0x1A24 0x52A .DW 0x7A90 0x52C .DW 0xC1E8 0x52E .DW 0x0218 0x530 .DW 0x0508 0x532 .DW 0x0C10 0x534 .DW 0x1000 0x536 .DW 0x0000 0x538 .DW 0x0000 0x53A .DW 0x0000 0x53C .DW 0xC302 0x53E .DW 0x318C 0x540 .DW 0x0954 0x542 .DW 0x0EC4 0x544 .DW 0x75B9 0x546 .DW 0x1E1C 0x548 .DW 0x1A3E 0x54A .DW 0x7A93 0x54C .DW 0xE1E9 0x54E .DW 0x2219 0x550 .DW 0x0508 0x552 .DW 0x4C14 0x554 .DW 0x300A 0x556 .DW 0x1B32 0x558 .DW 0x1432 0x55A .DW 0x2001 0x49C .DW 0x1400 0x49E .DW 0x1400 0x4A0 .DW 0x0894 0x4A2 .DW 0x0954 0x4A4 .DW 0x0888 0x4A6 .DW 0x0000 0x4A8 .DW 0xC4EE 0x4AA .DW 0xAA48 0x4AC .DW 0xCE4E 0x4AE .DW 0xAA48 0x4B0 .DW 0xAA48 0x4B2 .DW 0xAA4E 0x4B4 .DW 0x0000 0x4B6 .DW 0x07E0 0x4B8 .DW 0x03C0 0x4BA .DW 0x0180 ;------------------------- ;- NOT DECODED - ;------------------------- 0x39B .DB 0x99 0x55C .DB 0xFF

D'autres utilitaires sont disponibles en téléchargement sur http://www.chip.com. En autre MegaCHIP devkit 1.0. Ainsi que l'émulateur fish'n chip

liens

Dans cette partie je documente l'interface avec la carte SD. Pour l'accès à la carte SD j'ai utilisé la librairie créé par Roland Riegel.

Il y a plusieurs librairie SD/SDHC/MMC disponible pour les atMega, j'ai choisie celle de Roland Riegel pour sa facilité d'utilisation. Pour l'intégrer à mon projet j'ai eu très peut de travail à faire. S'il avait fallu que je cré ma propre librairie le temps travail aurait plus que doublé. Chaque module de la librairie a un fichier *_config.h qu'il suffit d'adapter à ses besoins.

Pour commencer dans le fichier hardware.h de mon projet j'ai ajouter la définition suivante:

#define __CHIP_COMP__ 1

• uint8_t fs_mount()
  Vérifie s'il y a une carte dans le support et si c'est le cas monte le système de fichier. Retourne 1 en cas de succès et 0 autrement. Un seul système de fichier peut-être ouvert à la fois.
• void fs_umount()
  Ferme le système de fichier.
• uint8_t fs_open_dir(char *dir_name)
  Ouvre un répertoire. Un seul répertoire peut-être ouvert à la fois. Retourne 1 en cas de succès et 0 autrement.
• void fs_close_dir()
  Ferme un répertoire.
• uint8_t fs_open_file(char *file_name)
  Ouvre un fichier. Un seul fichier peut-être ouvert à la fois. Retourne 1 en cas de succès et 0 en cas d'échec.
• void fs_close_file()
  Ferme le fichier ouvert.
• uint8_t fs_load_file(uint16_t file_no)
  Charge le contenu du fichier dans la mémoire SRAM. Retourne le nombre d'octets chargés.
• uint8_t fs_read_dir(struct fat_dir_entry_struct *dir_entry)
  Retourne l'entrée suivante du répertoire. Retourne 0 à la fin de la liste.

CHIPcon n'affiche que la liste des fichiers qui se trouve dans le répertoire racine. Notez qu'il affiche le nom de tous les fichiers. Donc si l'utilisateur sélectionne un fichier qui n'est pas un binaire SCHIP la machine virtuelle schip() va plantée à l'exéctuion d'un tel fichier laissant une message CRASH! BAD OPCODEà l'écran.

La librairie de Roland Riegel est configurée pour utilisation en lecture seule afin de sauver de l'espace code. Tel quel elle consomme environ 5Ko de flash.

liens

J'ai complété la fabrication du boitier pour CHIPcon. Entièrement fabriqué à partir d'une feuille de plastique noir récupérée d'une horloge pendule et de colle.

Voici un deuxième vidéo pour démontrer l'effet du bouton game speed sur la vitesse d'exécution des jeux. Ici il s'agit du jeux blinky, clone de Packman créé par Hans Christian Egeberg.

liens

C'est bien beau d'avoir une console de jeux mais il faut aussi pouvoir écrire des programmes pour cette console. Comme CHIPcon ajoute 4 instructions à celles de SCHIP il a bien fallu que je cré un assembleur spécifique à CHIPcon. J'ai baptisé cet assembleur ccasm (CHIPcon assembler). Le code source et le binaire compilé pour Windows avec minGW gcc 4.8.1 se trouve dans le répertoire tools. Son utilisation est des plus simple:

ccasm test.chp  test.bin [-p test.ppf]

ccasm

Pour connaître les instructions supportées par la machine virtuelle de CHIPcon il faut se référer à la table présentée dans la partie 2 de cette série.

En plus des instructions machines l'assembleur supporte les directives suivantes:

EQU identifier expression

DB BYTE [,BYTE]

DW WORD [,WORD]

ASCII "text..."

Expressions

Partout où une constante numérique est applicable une expression arithmétique peut-être utilisée. Les opérateurs reconnus sont '+' addition, '-' soustraction, '*' multiplication, '/' division et '%' modulo ainsi que les parenthèses '(',')'.
exemple:

;programme hello world

equ SCREEN_WIDTH 128
equ SCREEN_HEIGH 64
equ CHAR_HEIGH 8
equ CHAR_WIDTH 6
equ CHAR_PER_LINE  SCREEN_WIDTH/CHAR_WIDTH
equ TEXT_LEN 12

defn XPOS V3
defn YPOS V4

high
cls
ld I, REG_INIT 
ld V4,[i] ; initialisation registres V0..V4
ld I, MSG
prt XPOS,YPOS ; imprime message à  l'écran
exit
REG_INIT:
db 0, 0, CHAR_HEIGH*4, CHAR_WIDTH*(CHAR_PER_LINE-TEXT_LEN)/2
MSG:
ascii "hello world!"

Assemblé avec l'option -p le fichier pré-processé contiendrais:

13  HIGH 
14  CLS 
15  LD I , REG_INIT 
16  LD V4 , [ I ] 
17  LD I , MSG 
18  PRT V3 , V4 
19  EXIT 
20 REG_INIT: 
21  DB 0 , 0 , 8 * 4 , 6 * ( 21 - 12 ) / 2 
22 MSG: 
23  ASCII "hello world!"

Commentaires

Les commentaires commence par ';' et se termine à la fin de la ligne.

Identificateur

Les identificateurs commence par une lettre ou le caractère '_'. Ce premier caractère peut-être suivi de lettres,chiffres et '_'. Les identificateurs sont utilisées pour les étiquettes et les symboles définis par EQU et DEFN.

Étiquettes

Les étiquettes sont placées en début de ligne et immédiatement suivie du caractère ':'. Les étiquettes sont des repères pour les instructions JP étiquette, les appels de sous-routines CALL étiquette ainsi que pour le chargement du registre pointeur de données LD I, étiquette. Le caractères ':' ne fait pas partie du nom de l'étiquette et ne doit donc être utilisé qu'à l'endroit où l'étiquette est définie. Une instruction peut suivre une étiquette sur la même ligne.

boucle: LD V1, 4 ; ceci est valide
MSG: ascii "hello world!"  ; ceci est  valide

Nombres et bases

ccasm reconnait les nombres entiers seulement dans les bases décimal, hexadécimal et binaire. Le caractère # indique un nombre hexadécimal et le caractère '$' indique un nombre binaire. Dans les nombres binaires le zéro peut-être remplacé par un point '.' dans le but d'accentuer la forme des sprites.
exemples:

546      ; nombre décimal
#f585    ; nombre hexadécimal
$101001  ; nombre binaire
$1.1..1  ; même nombre binaire 

; le point à la place du zéro permet
; de mieux visualiser la forme du sprite
sprite:
DB $..1111..
DB $.1....1.
DB $1......1
DB $1.1..1.1
DB $1......1
DB $1..11..1
DB $.1....1.
DB $..1111..

code source

Le code source du programme doit-être en ASCII ou ANSI (Windows). L'assembleur est insensible à la casse, les lettres étant converties automatiquement en majuscules. Il n'y a qu'une instruction par ligne. Le traitement se fait par ligne en 2 phases. En première phase si la ligne est une directive EQU ou DEFN le nouveau symbole est créé dans la liste. Si la ligne est une instruction assembleur ou une directive de donnée, le pré-processeur analyse chaque mot de la ligne et substitue les symboles définis par des EQU et DEFN. Il converti aussi les lettres minuscules en majuscules. Cette ligne pré-processée est ensuite assemblée en phase 2.
La description formelle de la syntaxe reconnue par ccasm est dans le fichier tools/ccasm_bnf.txt

Avec son assembleur et son dé-assembleur CHIPcon est prêt pour le développement de jeux. Mais ce serait mieux s'il y avait un émulateur sur le PC pour éviter d'avoir à copier le fichier binaire sur carte SD afin de le tester sur la console. Opération qui doit-être répétée de nombreuses fois lors du développement. La création de cet émulateur ccemul est donc la prochaine étape de ce projet.

liens

Dans ce neuvième article sur le projet CHIPcon je présente l'utilitaire ccemul. Il s'agit d'un simulateur de la console CHIPcon fonctionnant sous Windows. Ce simulateur ne permet pas seulement d'exécuter des jeux CHIPcon et SCHIP mais possède aussi des facilités de débogages. Avec les utilitaires ccasm et cc-dasm il complète le CHIPcon DEV KIT. Voici une capture d'écran de la fenêtre principale de l'émulateur.

Utilisation du clavier

Le simulateur est configuré pour le clavier Nord-Américain QWERTY et utilise les touches à gauche du clavier de la façon suivante. Le chiffre entre parenthèse représente la correspondance sur le keypad de la console CHIPcon.

Flux de travail

Le développement d'un jeux pour la console CHIPcon se fait selon le flux de travail suivant:

Après avoir écris le programme source dans son éditeur préféré en prenant soin d'utiliser un encodage ANSI pour le fichier, l'auteur utilise ccasm pour assembler ce code source en fichier binaire. Optionnellement il peut générer un fichier *.ppf en utilisant l'option -p pour voir de quoi a l'air le code pré-traité tel qu'il est transmis à l'assembleur proprement dit. Cette option est surtout utile lors du développement de l'assembleur lui-même. L'autre option -s sert à générer un fichier texte qui contient la liste des cibles (labels) qui sont dans le programme source. Ce fichier est utilisé pour le débogage du jeux dans le simulateur ccemul. Une fois le jeux complété et débogué le fichier binaire est copié sur une carte SD et utilisé sur la console CHIPcon.

Pour créer un fichier *.lbl il faut utiliser l'option -s symbol_file lors de l'assemblage du fichier source.

ccasm lem.chp lem.bin -slem.lbl

Vidéo de présentaion de ccemul

Le vidéo suivant présente le fonctionnement de ccemul.

Jeux LEM

J'ai créé une version du jeux des années 197x lunar landing pour CHIPcon. Je l'ai baptisé LEM du nom du module lunaire du projet Apollo. Il s'agit de faire alunir le LEM de façon sécuritaire. Sous l'effet de la gravité lunaire le LEM accélère continuellement alors qu'il se dirige vers le sol. Il faut le ralentir en utilisant la fusée principale touche 2. Il faut aussi le posé sur le seul endroit plat. Pour se déplacer horizontalement il y a 2 fusées latérales. touche 4 vers la gauche et touche 6 vers la droite. Pour un alunissage sécuritaire non seulement il faut se poser sur le plat mais il faut que les vitesses horizontales et verticales soient inférieures à 2 unités. Au départ le réservoir contient 100 unités de carburant. Le coin supérieur gauche indique le niveau de carburant.

Un alunissage réussi fait apparaitre le message congratulation! sinon c'est écris You crashed!. Le score (nombre de succès/nombre d'essais) s'affiche à la fin de chaque essais. Il faut enfoncer n'importe qu'elle touche pour le prochain essai.

Conclusion

Bien qu'un projet n'est jamais vraiment complété, ceci est le dernier article de cette série. Il y a peut-être encore un (des) bogue(s) moins évident qui se cache dans le firmware de la console ou de l'un des programmes du DEV KIT, mais tel qu'il est se projet est suffisamment stable pour être utilisable.

Ce projet m'a conduit beaucoup plus loin que ce que j'avais prévu au départ. Tout ça est open source donc si ça vous intéresse vous pouvez le prendre en main et le mener plus loin, ou simplement construire votre propre console CHIPcon pour y jouer les jeux disponible sur www.chip.com.

liens

NOTE: ccemul a été développé avec SharpDevelop version 5 et compilé pour le .NET version 3 et processeur Intel 32 bits. Le programme compilé devrait donc fonctionné sur tout PC avec un windows 32/64 bits avec les librairies runtime .NET version 3+ installées.

Ce matin je me réjouis car j'ai découvert que Lazare est ressuscité¹. Dans les années 80 je suivais des cours d'informatique à l'UQAR et le langage de programmation utilisé pour ces cours était le Borland Turbo Pascal qui était très populaire à cette époque. Puis MS-DOS a été remplacé par Windows et Turbo Pascal est devenu Borland Delphi maintenant vendu par Embarcadero. Professionnellement j'ai développé quelques applications en delphi 6 mais à titre personnel je n'ai jamais été intéressé à défrayer le coût de la version la moins coûteuse de cet environnement qui vaut 209US$ Je suis donc passé à d'autre IDE comme SharpDevelop. C# est un langage intéressant et l'IDE de SharpDevelop aussi mais comme c'est construit par dessus .NET c'est restrictif en terme de plateformes cibles.

Lazarus

Ce que j'ai découvert ce matin c'est l'existance d'un projet open source appellé Lazarus. C'est un IDE qui utilise le compilateur Free Pascal. Cet IDE est un clone libre et gratuit de Delphi. les projets Delphi peuvent même être importés dans cet environnement, le langage étant le même c'est à dire Pascal Objet.

Cet IDE est disponible sous Windows 32/64bits, GNU/Linux 32/64 bits, OSX Intel 32bits/PowerPC. Le compilateur Free Pascal compile du code natif. Il ne nécessite donc pas l'installation de machine virtuelle Java ou CLI (.NET) et tout les librairies associés à ces gros systèmes.

Formidable avec cet IDE je vais pouvoir développer des applications Desktop aussi bien pour Windows que pour Linux dans un environnement et un langage qui me sont familiers.

1) humour hautement dépendant de la culture d'origine de l'auteur.

Dans cet article j'explique le fonctionnement des oscillateurs électroniques.

Le pendule

Avant d'expliquer l'oscillateur électronique je vais débuter par une analogie mécanique, le pendule, une balançoire en fait. l'enfant assis dans la balançoire apprend rapidement comment la mettre en mouvement mais aussi comment la freiner. Pour la mettre en mouvement il se laisse tomber vers l'arrière en tirant sur les cordes puis reprends sa position initiale. En répétant de mouvement il augmente l'amplitude des oscillations. Il n'applique pas cette force à n'importe quel moment met lorsque la balançoire atteint le point mort haut arrière, juste au moment ou la descente s'entame. Ainsi l'énergie qu'il apporte au pendule est en phase est le mouvement de celui-ci. Par contre lorsqu'il veut diminuer l'amplitude il pousse sur les cordes vers l'avant lorsqu'il est en ascension frontale. A ce moment l'énergie qu'il applique est en anti-phase.

Si on accrochait un crayon sur le bord du siège de la balançoire et qu'on faisait défiler a vitesse régulière un large bande de papier le long de la balançoire de sorte que le crayon frotte sur celle-ci, on verrait apparaître sur la bande de papier une onde sinusoïdale.

Circuit accordé

L'inductance et le condensateur sont en quelque sortent des composants complémentaires en électronique. En effet l'inductance accumule de l'énergie dans un champ magnétique et le condensateur dans dans un champ électrique. Si on les combines comme sur cette illustration on obtient un circuit accordé qui possède une fréquence de résonance.

Supposons le montage suivant:

Oscillateur électronique

Pour obtenir un oscillateur électronique dont l'oscillation est entretenue il suffit de peser sur le bouton au bon rythme et en phase avec l'oscillation du circuit accordé. Évidemment on ne peut faire ça à la main mais il y a une façon simple d'y arrivé. En récoltant une partie de l'énergie fournie au circuit accordée et en la renvoyant à l'entrée du transistor Q1 de sorte que ce signal une fois amplifié soit en phase avec l'oscillation naturelle du circuit accordée. On appelle ça une rétro-action positive. Examinons le circuit.

Ce montage s'appelle base commune car du point de vue de l'analyse circuit A.C. (courant alternatif) la base du transistor est maintenue au commun de l'alimentation (négatif de la pile dans ce schéma) à travers le condensateur C3 dont l'impédance (résistance AC) est très faible à la fréquence de fonctionnement de l'oscillateur. L'entrée de l'amplificateur ici c'est l'émetteur et le signal de rétro-action est fournie à travers C2. C2 est choisi de sorte qu'il y a suffisamment de signal qui est retourné à l'entrée de l'amplificateur pour maintenir une oscillation stable. Si C2 fourni trop de rétro-action au lieu d'avoir une onde sinusoïdale à la sortie on va avoir de la distorsion, sa valeur ne doit donc être ni trop grande ni trop petite.

J'ai mentionné le terme base commune. Il y a 3 types de montages pour les transistors bi-jonctions, base-commune, émetteur-commun qui est le plus utilisé et finalement collecteur-commun. On peut fabriquer un oscillateur avec n'importe quel type de montage. Le critère pour obtenir une oscillation soutenue est que le gain en boucle fermée soit >= 1. Avec un gain 1 l'onde est sinusoïdale, supérieur à 1 on ajoute de la distorsion. Un gain de 1 signifie qu'on ajoute juste de qu'il faut d'énergie au circuit accordé pour compenser les pertes du aux résistances parasites. A cette valeur de gain on obtient une onde sinusoïdale d'amplitude constante.

Oscillateur à cristal

J'ai commencé cet article par une analogie mécanique, l'oscillateur à cristal est intéressant parce qu'il est à la fois mécanique et électronique. En effet il utilise l'effet piézo-électrique qui est un phénomène électro-mécanique. Un cristal est constitué d'une lamelle de quartz avec une électrode sur chaque face. Lorsqu'une tension électrique est appliquée sur ces électrodes il y a une déformation mécanique du cristal. Lorsque cette tension électrique est relâchée le cristal oscille à une fréquence précise. Comme pour un pendule cette oscillation va s'amortir si elle n'est pas entretenue. N'essayer pas de sortir un cristal de son boitier pour le voir osciller, cette oscillation est à l'échelle microscopique au niveau du réseau d'atomes.

Le schéma suivant illustre un oscillateur à cristal dans un montage collecteur-commun. On l'appelle ainsi car le collecteur est au commun de l'alimentation car en haute fréquence la résistance entre le collecteur et le commun est à toute fin pratique nulle. Ici l'entrée de l'amplificateur c'est la base et la sortie c'est l'émetteur.

Oscillateur avec porte logique

Habituellement dans les montages en circuits logiques ont utilise des portes logiques pour fabriquer l'oscillateur. En voici une illustration.

Pour conclure voici un vidéo qui montre comment fabriquer un mouchard qui transmet dans la bande FM. Une recherche dans Google permet de trouver de nombreux exemples de ce type de montage ainsi que plusieurs autres vidéo sur youtube.

Cet article est une présentation du projet open source Arduino ainsi que de la carte d'expérimentation pro trinket d'Adrafuit.

Arduino¹ est une série de carte microcontrôleurs pour le prototypage rapide et simplifié. Le projet a démarré en 2005 à l'institue de design Ivrea en Italie. Il avait pour but de fournir aux étudiants un remplacement aux BASIC stamp vendu par Parallax jugés trop coûteux. Le projet a rapidement gagné en popularité et est aujourd'hui le plus populaire auprès des amateurs et artistes dans le monde entier. Aujourd'hui il existe de nombreuses cartes clones tel que les trinkets d'Adafruit. Sur la première carte le processeur utilisé était un atMega8, mais maintenant il y a différent modèles avec des processeurs plus puissants dont le Due avec un processeur Atmel SAM3X8E ARM Cortex-M3.

Pour les démos de cet article j'utilise un pro trinket d'Adafruit comme mentionné ci-haut. Les cartes Arduino viennent avec un firmware pré-installé dans le MCU qui sert à télécharger les applications écrites dans l'IDE. L'intérêt ce ces cartes pour les amateurs est qu'il n'est pas nécessaire de potasser les spécifications du MCU car les périphériques sont pré-configurés et qu'il existe un API de programmation simplifié. C'est d'ailleurs ce qui a fait la popularité de ce projet.

Environnement de développement

Adruino possède son propre IDE disponible gratuitement en téléchargement. Pour l'utilisation des trinkets il est préférable de télécharger la version fournie par Adafruit qui est adaptée aux cartes vendues par cette compagnie. L'IDE comme les cartes est simplifié, il est donc facile à prendre en main, d'autant plus qu'il est multilingues. Les menus s'affichent dans la langue du système d'exploitation.

La première chose à faire une fois le logiciel installé est de sélectionner le type de carte utilisé en allant dans le menu outils - type de carte.

Ensuite on peut se débrouiller avec les 5 boutons de gauche sur la barre d'outils qui apparaît sous le menu. Le crochet sert à compiler le programme. s'il y a des erreurs elles sont affichées dans une fenêtre en bas de l'IDE.

Lorsqu'un programme compile correctement on peut le téléversé sur la carte en cliquant sur le 2ième bouton flèche vers la droite. En ce qui concerne le pro trinket il faut peser d'abord sur le bouton reset pour que le bootloader s'active. Le bootloader attend 10 secondes avant de retourner au programme utilisateur.

Le 3ième bouton feuille avec coin plié sert à créer un nouveau projet. Chaque projet apparaît dans une fenêtre séparée.

Le quatrième bouton flèche vers le haut sert à ouvrir un projet existant.

le cinquième bouton flèche vers la bas sert à sauvegarder le projet sur le disque dur.

Le langage de programmation utilise la même syntaxe que C/C++ au point ou nombreux sont ceux qui pensent que c'en est. Il s'agit en fait du langage Wiring, une version simplifié de C++. Il n'y a pas de fonction main()à la place il y a 2 fonctions obligatoires. void setup() qui est exécutée automatiquement au démarrage du processeur et sert à l'initialisation. void loop() qui une boucle dans laquelle le programme principal s'exécute indéfiniment jusqu'à la réinitialisation du MCU.

Donc lorsque vous avez créé un nouveau projet vous devriez inscrire le squelette de ces fonctions avant toute chose. La référence du langage est disponible ici. Si vous connaissez le C/C++ la prise en main sera simple et rapide. Cependant la fonction loop m'a réservée une petite surprise, j'en reparle plus bas.

cartes trinkets

Adafruit vends 4 cartes trinkets. En fait il y a 2 modèles mais une version 5 volt et 3 volt pour chaque modèle. Le trinket (6,95US$) utilise un MCU atTiny84 et a peut de I/O. Le pro trinket (9,95US$) utilise un MCU atMega328P et a plus de I/O. Les cartes on une largeur de 600mil avec espacement entre les broches de 100mil ce qui permet de les brancher sur une carte de prototypage sans soudure. Ces cartes peuvent-être commandées directement via le site d'Adafruit mais aussi chez Digikey.

Premier démo

Écrire un programme qui fait varier en intensité une LED de manière cyclique en utilisant une sortie PWM est si simple avec Arduino qu'on va sauter le traditionnel blinky pour y passer directement. Le montage est simple, il suffit de brancher une LED en série avec une résistance sur une sortie PWM. Sur les cartes trinket ces sorties sont identifiées avec une barre au dessus du numéro. J'ai choisi la sortie 3. /* variation cyclique de l'intensité d'une LED */ int pwmPin=3; // broche LED void setup(){ } static byte i=0; static char delta=1; void loop(){ i += delta; analogWrite(pwmPin,i); delay(5); if (i==255 || i==0) delta=-delta; } Simple n'est-ce pas? Notez que la fonction setup() doit-être présente même si elle est vide. La fonction analogWrite détermine la valeur du rapport cyclique sur les sortie PWM. Cette valeur varie de 0 à 255.

Surprise

La surprise dont je parlais plus haut concerne les variables i et delta. Normalement ces variables devraient-être locales à la fonction loop. Donc dans ma première version je les avaient définies et initialisées au début de loop().

void loop(){
  byte i=0;
  char delta=1;

Clap switch

J'ai vu ça dans un commercial à la télé cette semaine, un gadget qui allume ou éteint un lampe en claquant dans les mains. J'ai décidé d'essayer ça en utilisant le trinket. Mon démo utilise la LED rouge qui est sur le trinket et branchée sur la sortie digitale 13. J'ai aussi conservé la LED sur la sortie barre-3 comme indicateur d'intensité sonore. Voici le circuit.

J'ai testé 2 versions différentes du logiciel et elle se valent, en sensibilité et en taux de détection.

/* NOM: clap-switch2 Auteur: Jacques Deschênes Date: 2014-12-14 Description: Lorsque le clap-switch entends 2 bruits sec espacés de moins d'une seconde et d'au minimum 200 msec, il bascule l'état d'une sortie digitale. Le circuit est composé d'un microphone électret dont le signal est amplifié par un transistor 2N3904 et rectifié et filtrer par un filtre passe-bas. Seule l'enveloppe du son est conservée. Une entrée analogique est utilisée pour lire ce signal et l'analyser. Version: 2 */ int audioInput = A5; // entrée analogique microphone int ledPin = 13; // sortie qui bascule à chaque événement clap-clap. int pwmPin = 3; // sortie PWM indicateur intensité son. boolean ledState=false; // État actuel sortie digitale (LED) unsigned long waitClap(){ unsigned long tRise,tFall; boolean noClap,fastRise; int diff, current, last; noClap=true; fastRise=false; last=analogRead(audioInput); analogWrite(pwmPin,last>>2); while (noClap){ delay(1); current=analogRead(audioInput); analogWrite(pwmPin,current>>2); diff=current-last; last=current; if (!fastRise){ if (diff>30){ tRise=millis(); fastRise=true; } }else{ tFall=millis(); if ((tFall-tRise)>10){ fastRise=0; }else if (diff<-30){ noClap=false; } } }//while return tRise; } void toggleOutput(){ if (!ledState){ ledState=true; digitalWrite(ledPin,HIGH); }else{ ledState=false; digitalWrite(ledPin,LOW); } } void setup(){ pinMode(ledPin,OUTPUT); } void loop(){ unsigned long t0,t1; t0=waitClap(); delay(100); t1=waitClap(); if (t1-t0>200 && t1-t0<500){ toggleOutput(); } } La première version utilise un seuil de déclenchement et celle-ci utilise un taux de changement entre 2 lectures. Il doit y avoir 2 claquements de main avec un intervalle maximum de 500 millisecondes entre chaque. La switch répond aussi aux sifflements.

1) Article plus complet sur le wikipedia anglophone.