introduction aux MCU ATtiny, partie 2

Maintenant que Atmel studio est installé ainsi que le programmmeur Pololu USB AVR, on peut commencer. tous les documents concernant cette série de chroniques seront enregistrés ici. Mais avant de programmer un MCU il faut évidemment étudier sa strcuture interne. Le core AVR 8 est très différent de celui des PIC mais il ressemble à celui de la majorité des microcontrolleur moderne, que ce soit les MSP430, ARM, MIPS en ce sens qu'il utilise un bloc de registres appellé en anglais general purpose register file alors que les PIC n'ont que le registre W. Toutes les opérations arithmétiques et logiques utilisent le contenu d'au moins 1 de ces registres comme argument et le résultat est retourné dans l'un de ces registres. Cependant comme les PIC l'ARV core est basé sur une architecture Harvard, c'est à dire que la mémoire programme est séparée de la mémoire des données. Le register file du AVR8 contient 32 registres de 8 bits pour la majorité des ATtiny sauf pour les petits ATtiny4,5,9 10 qui n'ont que 16 registres. Voici une représentation interne du AVR core 8.

À gauche c'est la structure général et à droite c'est la représentation du register file avec ces 32 registres. Notez que les 6 registres R26 à R31 ont une fonction spéciale. Utilisés par paire ils forment 3 registres d'indexation de 16 bits, X, Y et Z. C'est l'équivalent des registres FSR des PIC mais en plus puissant. D'abord parce qu'ils ont 16 bits il peuvent pointés jusqu'à 64K de RAM et deuxièmement parce qu'ils permmettent des modes d'adressage indexé, indexé relatif et incrémentation automatique. Chez les MCU PIC on ne retrouve ce genre de fonctionnalité que dans les familles enhanced mid-range (PIC12F1xxxx/PIC16F1xxxx) et extended (PIC18Fxxxx).

Ces registres peuvent aussi être utilisés comme registres d'usage général mais ce n'est pas recommendé à moins que vous n'ayez pas besoin de 3 registres d'indexation.

Autre différence avec les PIC la pile des retours est en RAM et non un mémoire dédiée comme c'est le cas avec les PIC. La dimension de la pile est donc limité seulement par la mémoire RAM disponible et de plus le pointeur de pile peut-être manipulé et on dispose d'instructions push et pop. Cette architecture facilite grandement la création d'un compilateur pour les languages de haut niveau comme le 'C' et permet donc un compilation plus facilement optimisée.

En ce qui concerne l'accès au périphérique c'est le même principe que sur tous les MCU que je connais, c'est à dire que dans l'espace d'adressage RAM il y a des registres spéciaux qui contrôlent la configuration des périphériques. Rien pour être dépaysé. Comme on va programmer en 'C' l'accès aux registres spéciaux se fera par affectation à des variables. C'est à dire que chaque SFR (Special Function Register) a un nom symbolique et que lorsqu'on veut écrire dans un registre on utilise simplement une affectation du genre:
CLKPR = 0 ; // désactivation du diviseur
et pour lire un SFR on fait comme si c'était une variable:
if (PORTB & 1<<4 == 1<<4)... // est-ce que le bit 4 du PORT B est à 1?

Modification au circuit

J'ai légèrement modifié le circuit présenté en partie 1:

Création d'un nouveau projet

J'ai préparé un document au format OpenOffice 3 expliquant les étapes pour la création d'un nouveau projet dans Atmel studio.

Lorsque vous branchez le programmeur Pololu au port USB si le pilote est installé correctement, dans le gestionnaire de périphérique de Windows vous verrez 2 nouveaux ports COM. Celui qui nous intéresse s'appelle Pololu USB AVR programmer Programming Port (COMx). Notez le nom du port COM. Il faut configuré Atmel studio pour l'utilisation de ce PORT.

Dans la barre de menu d'Atmel studio vous verrez l'item tools et dans le menu déroulant de celui-ci il y a add STK500.... Cliquez dessus, sélectionnez le port de votre programmeur Pololu et faite apply.

Maintenant si vous suivez les instructions du document pour créer un nouveau projet GCC vous devriez vous retrouver face à la fenêtre de l'éditeur avec le squelette de l'application en place. On peut maintenant écrire le code.

Pour cette première version de notre application ce sera très simple, on va utiliser le bouton pour allumer et éteindre le LED. A chaque pression du bouton l'état du LED va basculer.

code source /* * Intro_AtTiny.c * * Created: 2013-01-05 22:13:50 * Author: Jacques * Description: introduction aux MCU ATtiny * étape 1: allumer/éteindre un LED avec un bouton momentané. */ #define F_CPU 9600000 // CPU à la fréquence maximale de l'oscillateur interne soit 9.6Mhz #include <avr/io.h> #include <util/delay.h> // tout ne peut pas être fait en C alors on utilise des macros avec directive asm #define disable_interrupt asm("cli") #define enable_interrupt asm("sei") #define watchdog_reset asm("wdr") // définition est E/S #define BOUTON PORTB3 // bit 3 du PORTB #define LED PORTB0 // bit 0 du PORTB void WDT_off(void) // emprunté tel quel au datasheet de l'ATtiny13A, j'ai juste remplacé les macros { disable_interrupt; watchdog_reset; /* Clear WDRF in MCUSR */ MCUSR &= ~(1<<WDRF); /* Write logical one to WDCE and WDE */ /* Keep old prescaler setting to prevent unintentional time-out */ WDTCR |= (1<<WDCE) | (1<<WDE); /* Turn off WDT */ WDTCR = 0x00; enable_interrupt; } void attend_pression_bouton(){ // lecture du bouton avec anti-rebond. Attend que le bouton soit relâché avant de sortir. int8_t count; count=0; while (count<20){ // attend que le bouton soit enfoncé if ((PINB & (1<<BOUTON))==0){ count++; } else{ if (count>0) count--; } _delay_ms(1); } while (count>0){// attend que le bouton soit relâché if ((PINB & (1<<BOUTON))==(1<<BOUTON)){ count--; } else{ if (count<20) count++; } _delay_ms(1); } return; } int main(void) { WDT_off(); //désactivation du watch dog timer. CLKPR= (1<<CLKPCE); // permet la modification du pre-scale CLKPR = 0 ; // pre-scale mise à zéro. Le MCU fonctionne à la fréquence maximale. DDRB |= (1<<LED); // met PORTB0 en sortie DDRB &= (0xFF - (1<<BOUTON)); // met broche BOUTON en entrée PORTB |= 1<<BOUTON; //active le pullup PORTB &= (0xFF - (1<<LED)); // eteint le LED while(1) { attend_pression_bouton(); /* if ((PINB & (1<<BOUTON))==0) PORTB |= (1<<LED); else PORTB &= (0xFF - 1<<LED); */ PORTB ^= (1<<LED); //commute l'état de la sortie LED } }
J'ai commenté le code pour que chaque étape soit limpide.

compilation et programmation du MCU

Pour compiler le code pressez la touche F7 ou encore cliquez l'icône build solution ou encore allez dans le menu build et cliquer le premier item. Le résultat s'affiche dans le fenêtre output en bas de l'éditeur. Cliquer sur un message d'erreur nous ramène à la ligne en faute dans le texte.

Lorsqu'il n'y a plus d'erreur on programme l'ATtiny en utilisant l'icône device programming qui est représenté par un C.I. avec un éclair par dessus. On peut aussi aller dans le menu tools.

Dans la fenêtre device programming

1. Sélectionnez votre programmeur dans la liste déroulante sous tool
2. cliquez apply
3. cliquez read sous device signature
4. allez dans memories et sélectionnez le fichier .hex qui correspond à votre programme.
5. finalement cliquez sur program. L'état de l'avancement apparait plus bas dans la fenêtre. Si tout est ok il n'y a rien d'autre à faire.

ATTENTION!

Ne faites pas ça. Si vous programmez le fusible RSTDISBL le programmeur Pololu ne pourra plus utiliser ce chip. Seul un programmeur haute-tension peut reprogrammer un chip dont le RESET a été désactivé. C'est pour ça que j'ai modifié le circuuit et mis le bouton sur PORTB3 plutôt que PORTB5.

Ce que j'ai appris

Voici ce que j'ai appris dans cette deuxième étape.

• Ne pas programmer RSTDISBL quand on utilise un programmeur basse tension comme le Pololu USB AVR. OOPS!
• Comment désactivé le Watchdog timer
• Un AVR ce n'est pas un PIC pour connaître l'état d'une entrée on ne lit pas le registre PORTx mais le registre PINx.
• #include <interrupt.h> ne fonctionne pas. Le compilateur ne trouve pas le fichier... C'est pourquoi j'ai réécris les macros, plutôt que de perdre mon temps à chercher la solution. A voir plus tard.
• Trop de clicks pour flasher le MCU. Dans MPLABX il suffit d'un seul.
• Même si on cré un nouveau projet, le fichier HEX qui est indiqué dans device programming, section memories est le dernier sélectionné dans un projet précédent. ARGH!!

prochaine étape

Contrôler l'intensité du LED en utilisant le périphérique PWM.

1. LED éteint on pèse sur le bouton, le LED allume à 100%
2. on repèse l'intensité baisse à 75%
3. A chaque pression l'intensité devra diminuner de 25% jusqu'à l'instinction.

Introduction aux MCU ATtiny, partie 1

Cette chronique est la première d'une série consacrée à un tutoriel d'introduction au microcontrôleurs ATtiny d'Atmel. Dans cette première partie je vais décrire les logiciels et le matériel nécessaire pour réaliser les expériences décrites dans cette série. En fait il va s'agir d'un seul projet auquel je vais ajouter des fonctionnalités à chaqe chronique. Toute la progammation va se faire en C.

Environnement de travail

L'environnement de travail sera le même que celui que j'ai utilisé pour ma chronique intitulée premiers pas avec MCU Atmel AVR.

Logiciels

• Environnement Windows XP/vista/7
• Atmel studio 6.0
• manuel de l'utilisateur et pilote pour le programmeur USB Pololu AVR

Bien sur vous pouvez utiliser un autre programmeur que celui de Pololu. Mais celui de Pololu a l'avantage de pouvoir être contrôlé directement à partir d'Atmel studio.

Liste de matériel requis

• 1 programmeur Pololu AVR
• Une platine de prototypage sans soudure
• 1 microcontrôleur ATtiny13A format PDIP8
• 1 résistance de 75 ohm 1/4 Watt.
• 1 résistance de 2K
• 1 résistance de 10K
• 1 LED blanche
• 1 transistor de commutation NPN,exemple: ZTX649
• 1 bouton à contact momentané.
• 1 condensateur céramique 100nF
• 1 porte pile 3xAA et 3 piles AA ou bien une alimentation régulé 5Volt.

Les liens vers les sites de Digikey et Robotshop ne sont que des suggestions.

Schéma électronique

Voici le montage qui sera utilisé pour toute la série.

installation d'Atmel Studio

Je n'ai rien trouvé en français sur l'installation d'Atmel studio 6.0 seulement ce vidéo en anglais produit par Atmel. En fait il y a plusieurs vidéo sur l'utilisation du studio. Je n'ai pas l'intention de faire une présentation sur la configuration et l'installation de l'environnement de travail. Vous devrez vous débrouiller par vos propre moyens pour ça.

Dans la prochaine crhonique je vais présenter le core AVR 8 et la première expérience que nous ferons avec l'ATtiny13A.

sonnette d'entrée

Je voulais remplacer la sonnette d'entrée que je trouve trop bruyante, j'ai donc décidé d'en fabriquer une électronique. Étonnant tout ce qu'on peut faire avec le PIC10F322 qui n'a que 3 entrée/sortie et 1 entrée, 512i de flash et 64 Octets de RAM. Malgré tout on peut lui faire jouer un fichier WAV à condition de lui donner de la mémoire supplémentaire. Microchip fabrique justement le type de mémoire eeprom dont j'avais besoin. Il s'agit des eeprom à interface I2C. Ce type de mémoire à interface sérielle ne nécessite que 2 E/S. Il me restait donc 1 sortie pour le son et 1 entrée pour le bouton de la sonnette.

Schéma électronique

Ce schéma peut semblé un peut compliqué mais j'y ai dessiné 2 options pour la partie analogique (sortie audio). Si on ne garde que l'option B c'est plutôt simple. J'utilise le transformateur existant dont je branche la sortie 14VAC sur un pont redressseur. Les condensateurs C4 et C5 filtrent les ondulations et le régulateur de tension U4 donne 5VDC pour alimenter le circuit. Le PIC10F322 est interfacé avec l'eeprom par RA1 et RA2 et la sortie PWM1 sur RA0 est la sortie audio. L'entrée RA3 est utilisée pour le bouton de la sonnette. Le signal PWM est à 22Khz.

Si on regarde la partie analogique maintenant. Commençons par l'option B la plus simple. C'est l'option que j'ai utilisé pendant le développement car je n'avais pas en main tous les composants pour l'option A. Finalement ce circuit simple fonctionne si bien que je crois que je vais le garder au montage final. Le transistor Q1 est simplement monté en emetteur follower ou si vous préférez en collecteur commun. le condensateur C3 sert à atténuer la fréquence de la porteuse PWM et les autres bruits haute fréquence générés par le procédé de numérisation.

L'option A est un peut plus sophistiquée. J'utilise un amplicateur opérationnel double MCP6002 de Microchip comme filtre passe-bas avec un atténuation de 12DB/octave. L'opamp A est utilisé pour créer un virtual ground à mi-chemin entre Vdd et Vss et l'opamp B est configuré en filtre Butterworth.
La sortie audio est assurée par l'amplificateur LM386. tous les circuits intégrés de ce projet sont disponible en format PDIP8 et l'ensemble peut-être fabriqué à faible coût.

Firmware PIC10F322

Seulement 253 instructions et 9 octets de RAM. Le plus complexe étant l'interface I2C générée en bitbang puisqu'il n'y a pas de périphérique i2c intégré. Cette partie du logiciel est une copie presque conforme de celle que j'ai programmée dans le projet précédent. Ce sont les mêmes macros et les sous-routines ee_set_address, ee_send_byte, ee_rcv_byte n'ont étées que légèrement modifiées car il n'y pas pas d'utilisation d'une pile pour les arguments.

l'opération est la suivante:

1. Attendre que le bouton de la sonnette soit enfoncé.
2. appeller playsound` qui initialise le PWM et l'eeprom. Le PWM fonctionne à 22050Hz alors que le fichier WAV utilisé est à 11025. Donc on ne remplace la valeur dans les registres PWM1DCH, PWM1DCL qu'aux 2 cycles. Le timer 2 est configuré pour générer une interuption à la fin de chaque cycle. La routine d'interruption bascule l'indicateur F_RATE2 à chaque cycle et ne charge le PWM que le lorsque le bit est à 1. Ce faisant elle indique à la routine playsound qu'il est temps de lire l'échantillon suivant en mettant l'indicateur F_NEXT à 1. la routine playsound est responsable de lire les échantillons dans l'eeprom et de les compter. Lorsque tous les échantillons ont été lus l'interruption est désactivée ainsi que le PWM et on retourne à la procédure principale.
3. Pour éviter une lecture en boucle de l'enregistrement, la procédure principale attend que le bouton soit relâché avant de retourner à l'étape 1. Pas de désagrément au cas ou le bouton resterait collé.

code source ;NOM: sonnette.asm ;DESCRIPTION: Sonnette d'entrée jouant un fichier audio enregistré dans un eeprom i2c. ; les échantillons PCM sont au format monophonique 8 bits non signés 11025 ; échantillons par seconde. ; ;ALGORITHME: ; 1 - attend que le bouton de la sonnette soit enfoncé ; 2 - appelle anti-rebond, si pression confirmé va à 3 ; sinon retourne à 1 ; 3 - initialise l'eeprom à l'adresse 0 ; 4 - fait la lecture du nombre d'échantillons ; 5 - active le PWM ; 6 - fait la lecture d'un échantillon à tous les 90,7usec ; et envoie l'échantillon au PWM ; 7 - tant qu'il y a des échantillons à lire boucle à 6 ; 8 - attend que le bouton de la sonnette soit relâché avant de ; retourner à 1 ; ; ;AUTEUR: Jacques Deschênes ;DATE: 2013-01-03 include <P10F322.INC> include "..\include\pic10f322_m.inc" default_config ;;;;;;;;; constatntes ;;;;;;;;;;;;;;;;;;;;;;; BTN_P EQU RA3 ; bouton sonnette AUDIO_P EQU RA0 ; sortie PWM audio SDA_P EQU RA1 ; eeprom i2c data inp/output SCL_P EQU RA2 ; eeprom i2c clock ; octet de contrôle de l'eeprom (eeprom adresse=0) EE_CTL_WR EQU H'A0' ; contrôle écriture EE_CTL_RD EQU H'A1' ; contrôle lecture ;;; indicateurs booléens ;;;;;;;;;;;; F_RATE EQU 0 ; échantillons par secondes 0=11025, 1=22050 F_RATE2 EQU 1 ; indicateur cycle PWM divisé par 2. F_NEXT EQU 2 ; prépare le prochain échantillon F_BTNDN EQU 3 ; bouton sonnette enfoncé F_EERD EQU 4 ; lecture eeprom active F_PLAY EQU 5 ; indicateur sonnerie active PR2VAL EQU D'180' ; pour Fosc=16Mhz et pas de diviseur sur TIMER2 ceci donne 22 099hz ; pour la fréquence PWM. 0,22% au dessus de 22 050hz requis. TMR0DLY EQU D'75' ; délais pour TMR0 90,7usec ;;;;;;;;; macros pré-processeur ;;;;;;;;;;;;; #define BTN PORTA, BTN_P #define EE_SCL PORTA, SCL_P #define EE_SDA PORTA, SDA_P #define AUDIO PORTA, AUDIO_P ;;;;;;;;; macros mpasm ;;;;;;;;;;;;;;;;;;;;;; ;;;;; macros interface i2c eeprom ;;;;;;;;;;;;;;;;;;;;;;;;; ee_stop macro ; met l'interface i2c à l'état idle bcf EE_SDA bsf EE_SCL goto $+1 ;delais minimum 600nsec goto $+1 bsf EE_SDA goto $+1 ; délais minimum 1300nsec goto $+1 nop endm ee_start macro ; signale à l'eeprom le début d'une transaction bsf EE_SDA bsf EE_SCL goto $+1 bcf EE_SDA goto $+1 ; délais minimum 600nsec nop bcf EE_SCL endm ee_read_cmd macro ; prépare l'eeprom pour une lecture séquentielle ; appellée à la suite de: ; call ee_set_address ee_start movlw EE_CTL_RD movwf ee_byte call ee_send_byte endm ee_write_cmd macro ; envoie la commande écriture à l'eeprom ee_start movlw EE_CTL_WR movwf ee_byte call ee_send_byte endm ee_send_bit macro ; envoie un bit sur l'interface i2c de l'eeprom ; le bit à envoyé est dans le Carry du registre STATUS bcf EE_SDA skpnc bsf EE_SDA nop bsf EE_SCL goto $+1 ; délais hold minimum 600nsec. bcf EE_SCL endm ee_rcv_bit macro ; reçoit un bit de l'interface i2c ; en sortie le bit est dans le Carry ; ee_sda_dir SDA_INP bsf EE_SCL goto $+1 ; délais minimum 900nsec nop bcf STATUS, C btfsc EE_SDA bsf STATUS, C bcf EE_SCL goto $+1 ; ee_sda_dir SDA_OUT endm constant SDA_OUT=0 constant SDA_INP=1 ee_sda_dir macro dir if dir==SDA_OUT bcf TRISA, SDA_P else bsf TRISA, SDA_P endif endm ;;;;;;;;;; variables ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; udata MINRAM flags res 1 ; indicateurs booléens ee_byte res 1 ; contient octet à envoyer à l'eeprom ou lu de l'eeprom bit_cntr res 1 ; compteur de bit pour envoie et reception octet i2c sample_cntr res 2 ; compteur d'échantillons PCM w_save res 1 ; sauvegarde de W pendant les interruptions status_save res 1 ; sauvegarde STATUS pendant les interruptions temp res 2 ; registres temporaires ;;;;;;;;;; segment de code ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; code rst_vector org 0 goto init isr_vector org 4 btfss PIR1, TMR2IF retfie movwf w_save movfw STATUS movwf status_save btfsc flags, F_RATE goto load_sample movlw 1<<F_RATE2 xorwf flags, F ; toggle F_RATE2 btfss flags, F_RATE2 goto isr_exit load_sample clrf PWM1DCL movfw ee_byte movwf PWM1DCH bcf STATUS, C rrf PWM1DCH, F rrf PWM1DCL, F bsf flags, F_NEXT isr_exit movfw status_save movwf STATUS swapf w_save, F swapf w_save, W bcf PIR1, TMR2IF retfie ee_send_byte ; envoie un octet sur le bus i2c ; start condition préalablement activée. ; entrée: ee_byte=octet à envoyé ; sortie: Carry=0 ok, Carry=1 erreur movlw 8 movwf bit_cntr ee_send_byte02 rlf ee_byte, F ee_send_bit decf bit_cntr, F skpz goto ee_send_byte02 ee_rcv_bit ; receive ack return ee_rcv_byte ; reception d'un octet de l'eeprom ; start condition préalablement établie ; commande EE_CTL_RD préalablement envoyée ; entrée: aucun argument ; sortie: octet dans ee_byte ee_sda_dir SDA_INP movlw 8 movwf bit_cntr ee_rcv_byte02 bsf EE_SCL goto $+1 nop bcf STATUS, C btfsc EE_SDA bsf STATUS, C rlf ee_byte, F bcf EE_SCL decfsz bit_cntr, F goto ee_rcv_byte02 ee_sda_dir SDA_OUT bcf STATUS, C ee_send_bit ; send ACK return ; ee_rcv_byte ee_set_address ; initialise le registre d'adresse de l'eeprom ; entrée: temp=high_byte, temp+1=low_byte ; sortie: état opération dans Carry: 0=succès, 1=erreur ; s'il n'y a pas d'erreur l'eeprom est prêt à recevoir des données. ee_write_cmd skpc goto ee_send_high_byte goto ee_nack_error ; le ACK n'a pas été reçu ee_send_high_byte movfw temp ; octet fort de l'adresse movwf ee_byte call ee_send_byte skpc goto ee_send_low_byte goto ee_nack_error ; le ACK n'a pas été reçu ee_send_low_byte movfw temp+1 ; octet faible de l'adresse movwf ee_byte call ee_send_byte skpc return ; ack received ee_nack_error ee_stop return ; ee_set_address ee_end_read ; termine une série de lecture ; comme ee_rcv_byte termine toujours par un ACK ; il faut terminer la transaction en lisant un dernier octet ; suivit d'un stop movlw 8 movwf bit_cntr ee_end_read02 ee_rcv_bit decfsz bit_cntr, F goto ee_end_read02 ee_stop bcf flags, F_EERD return init_eeprom_read ; lit le nombre d'échantillons qu'il y a à jouer. ; les 2 premiers octets de l'eeprom contiennent ; le nombre d'échantillons en format litte indian ; le troisième octets indiques le sample rate, 0=11025, 1=22050 ; entrée: aucun paramètre ; sortie: aucune clrw movwf temp movwf temp+1 call ee_set_address ee_read_cmd call ee_rcv_byte movfw ee_byte movwf sample_cntr call ee_rcv_byte movfw ee_byte movwf sample_cntr+1 call ee_rcv_byte ; sample rate bcf flags, F_RATE movf ee_byte, F skpz bsf flags, F_RATE bcf flags, F_RATE2 return play_sound ; joue l'enregistrement audio qui est dans l'eeprom ; remplace le contenu de PWM1DC à tous les 2 cycles PWM ; car la fréquence d'échantillonage est la moitié de celle ; du PWM. set_pwm_duty_cycle PWM_CH1, H'7F' ; 50% enable_pwm_output PWM_CH1 call init_eeprom_read bsf flags, F_NEXT enable_timer2 enable_tmr2_int play_loop btfss flags, F_NEXT goto $-1 call ee_rcv_byte bcf flags, F_NEXT decfsz sample_cntr, F goto play_loop decfsz sample_cntr+1,F goto play_loop btfss flags, F_NEXT goto $-1 disable_pwm_output PWM_CH1 disable_tmr2_int disable_timer2 bcf flags, F_PLAY call ee_end_read return debounce ; routine anti-rebond pour le bouton de sonnette bcf flags, F_BTNDN movlw D'20' movwf temp dbc_loop movlw 5 ; délais 1 msec. movwf TMR0 movfw TMR0 skpz goto $-2 btfsc BTN return decfsz temp, F goto dbc_loop bsf flags, F_BTNDN return wait_btn_release ; attend que le bouton de la sonnette soit relâché movlw D'20' movwf temp wait_loop movlw 5 movwf TMR0 movfw TMR0 skpz goto $-2 btfsc BTN goto $+5 movlw D'20' subwf temp, W skpc incf temp, F decfsz temp, F goto wait_loop return ;;;;;;;;;;;; initialisation ;;;;;;;;;;;;;;;;;;;;;;;;;;;; init basic_setup set_clk_freq D'16' ; initialisation TIMER 0 set_timer0_prescale TMR0_DIV4 set_timer0_clock TMR0_FOSC4 ; initilisation TIMER 2 set_timer2_prescale TMR2_DIV1 movlw PR2VAL ; période PWM movwf PR2 ;initialisation interfacde i2c set_io_dir SCL_P, OUT set_io_dir SDA_P, OUT ;initialisation PWM set_io_dir AUDIO_P, OUT enable_pwm_channel PWM_CH1 enable_periph_int enable_interrupt call wait_btn_release ;;;;;;;;;;;;;;; procedure principale ;;;;;;;;;;;;;;;;;;; main btfsc BTN goto main call debounce btfss flags, F_BTNDN goto main call play_sound call wait_btn_release goto main end
L'ensemble des fichiers est disponible ici. Çi trouve une version modifiée du programme i2cprog.py. Si vous utilisez i2cprog.py pour programmer une eeprom dans le but de fabriquer cette sonnette seule cette version enregistre correctement le fichier .WAV dans l'eeprom.
Choisissez un fichier WAV monophonique non compressé encodé en 8 bits PCM non signé avec un taux d'échantillonnage de 11025. Le logiciel open source Audacity permet de transformer un fichier WAV d'un autre format en celui-là en l'exportant. Voici une procédure au format open office 3.

Mise à jour 2013-01-05
J'ai reçu ce qui me manquait pour faire le montage final. C'est maintenant fait et la sonnette est en fonction. J'ai modifié le circuit électronique.

matériel requis

• 1 MCU PIC10F322
• 1 eeprom 64k/i2c 24LC512
• 1 ampli audio LM386
• 1 haut-parleur 6cm/8ohm/0,5Watt
• 1 platine de montage seeed studio STR125C2B
• 4 diodes 1N4004
• 1 fusible picofuse 1A/fastblow
• 1 régulateur de tension 12Volt LM7812
• 1 régulateur de tension 5Volt LM7805
• 1 LED vert 3mm
• 1 résistance 10 ohm/0,25Watt
• 3 résistances 510 ohm/0,25Watt
• 2 résistances 2Kohm/0,25Watt
• 1 résistance 33Kohm/0,25Watt
• 1 potentiomètre PC mount 10Kohm
• 1 condensateur céramique 22nF
• 2 condensateurs céramique 47nF
• 3 condensateurs céramique 100nF
• 1 condensateur électrolytique 220mF/16Volt
• 1 condensateur électrolytique 1000uF/25Volt
• 1 bornier à vis 4 positions PC mount, espacement 100mil.
• 1 petit bouton momentané.
• 3 embases pour IC au format DIP 8

Mise à jour 2015-03-27

Je n'avais jamais penser à filmer un démo de ce projet en action mais à la demande d'un lecteur le voici. J'ai installé mon montage dans le boitier original d'un carillon à lame métallique préalablement retiré du boitier.

Le fichier que j'ai utilisé s'appelle theetone.wav