Ludiques

Même si tout est ludique.

Des projets ludiques divers et variés...

Horloge pour Escape Game

Objectif :Gros Chronomètre 40 minutes bluetooth.

Moyen:

Arduino Nano ATmega328P - 20mA - 1,98€
MAX7219 Affichage matrice LED 8x32 - 200mA max - 3,83€
Transformateur de tension DC-DC Buck Step-down Module D'alimentation
- taille: 22.3x17x4.2mm
- Tension d'entrée: 5.3 V-26 V
- Tension de sortie: 5 V
- Courant de sortie: 3A (Max)
- Température de fonctionnement:-40c-85c
- Fréquence de commutation: 1.5 MHz
- l'efficacité de conversion: 96% - Tarif 1,07€
ULN2803 - 0,25€
HC-06 module esclave Bluetooth - 40mA max - 3,43€
plaque d'essais double face - Dimensions 30x70mm - Pas 2.54mm - 2,25€
Un buzzer - 40mA -
Petit matériel - 1€
- 1k résistance 2.2kΩ
- condensateur électrolytique 1uF

Soit un total de 400 mA

Le principe

Un Organisateur prend son téléphone et active l'horloge dans une pièce sur 40:00 (40 minutes...on avait compris)
Lorsque les candidats sont prêt, il lance le compte à rebours à la fois sur son téléphone et bien entendu sur l'horloge. Ce qui lui permet à tout moment de savoir ou les candidats en son sans être présent. Le chrono chronomètre (Ca tombe bien) 40:00 → 39:59 → 39:58 ....
Arrivé à 00:30 il clignote et emet un "bip" par seconde et enfin à 00:00 reste sur cette position.
Ajouter sur V2.3: sur les ports PC0-PC3, pilotage de lumières LUM1-LUM4 et PD4-PD7, pilotage de lumières LUM5-LUM8

Plusieurs fonctions sur le "smartphone" :

Démarrage
Pause
Stop : Après confirmation, fin de la mission
Envoyer un message : Met un texte (sans accents, cédilles...caractères spéciaux) sur l'afficheur
Paramètre : Accès aux alarmes des différentes minutes:secondes et texte à afficher

Description des alarmes :

Commande		Exemple	Désignation	Test
Start		"S",0	Démarrage du Compte à rebours	OK
Halt		"H",0	Pause	OK
Reset		"R",0	Redémarrage	OK
Message		"MAttention!",0	Message instantané "Attention!"	OK
Saveparam		"W",0	Sauve l'ensemble des paramètres vers EEPROM	OK
Loadparam		"L",0	Lire l'ensemble des paramètres en ram	OK
EEPROM	Label	Exemple	Désignation	Test
0x00	Alarm0	"A04000",0	Alarm0 à 40:00 minutes	OK
0x02	Alarm1	"A13959",0	Alarm1 à 39:59 minutes	OK
0x04	Alarm2	"A20500",0	Alarm2 à 05:00 minutes	OK
0x06	Alarm3	"A30000",0	Alarm3 à 00:00 minutes	OK
0x08	Reserved	-	Reservé
0x0A	txtAL0	"P0DEBUT MISSION 4.0",0,0	Texte d'Alarm0 "DEBUT MISSION 4.0"	OK
0x2A	txtAL1	"P1ACCELERER! ACCELERER!",0,0	Texte d'Alarm1 "ACCELERER! ACCELERER!" Pour ne pas afficher de chaine "P1",0,0	OK
0x4A	txtAL2	"P2DANGER DANGER",0,0	Texte d'Alarm2 "DANGER DANGER"	OK
0x6A	txtAL3	"P3FIN DE MISSION",0,0	Texte d'Alarm3 "FIN DE MISSION"	OK
0x8A	txtACC	"P4ESCAPE GAME",0,0	Texte d'accueil "ESCAPE GAME"	OK
0xAA	Vide	"P5 ",0	Vide avant et après chaine 'scroll'	OK
0xB2	DelayCol	"D040",0	Durée entre chaque colonne de led en ms 0..255	OK
0xB3	brightness	"B03",0	Luminosité de 0 à 15	OK
0xB4	TimeSound0	"T0050",0	Durée du bip alame1 en ms 0..255	OK
0xB5	TimeSound1	"T1150",0	Durée du bip alame2 en ms 0..255	OK
0xB6	TimeSound2	"T2003",0	Durée du bip alame3 en s 0..255	OK
0xB7	Reserved	-	Reservé
0xB8	Reserved	-	Reservé
0xB9	Reserved	-	Reservé
0xBA	Checksum
0xBB	Fin parmètres

Branchement

Pour la plaque d'essai:

Le petit cavalier permet de déconnécter le bluetooth HC-06 ainsi que l'afficheur afin de permettre la mise à jour du firmware.

Et les deux circuits, un pour l'alimentation 24V vers 5V et le pilotage des 8 lumières 24V :

Et un pour l'arduino, le bluetooth et le buzzer.

Démo de lumières

Et le logiciel sur android à pour logo

Uilisation de l'application mobile android

Avant tout il est nécessaire de coupler les deux appareils en bluetooth.

Ensuite l'application cherche à se connectée, et en attendant l'ecran affiche :

Si la connection n'a pas lieu, c'est que vous êtes trop loin ou pire, que l'horloge n'est pas allumée.
Une fois la connection établie, voilà l'affichage:

Quatre possibilités s'offrent à vous :

Start Chrono, comme son nom l'indique, démarre le chronomètre
Faire un reset pour repartir sur le bandeau de départ
Aller dans "Paramètres"
Envoyer un message (25 caractères maximum)

Une fois le chronomètre lancé, vous pouvez vous déconnécter l'heure sera toujours affichée, si vous décidez de resté connecté ou de vous reconnécter l'écran suivant vous propose :

Vous pouvez alors:

Faire un reset pour repartir sur le bandeau de départ et redémarrer le chrono
Faire une pause du chronomètre

Mais vous ne pouvez plus accéder aux paramètres, ni au "Start Chrono" (normal, il est déjà lancé)

Si vous faite une pause, il est toujours possible de redémarrer le chrono ou de faire un reset.

L'accès aux paramètres :

Il est nécessaire de faire un ou plusieurs "Load Paramètres", jusqu'a ce que l'état passe à "Lecture OK"
Vous pouvez changer chacun des paramètres, mais attention

Il faut valider paramètre par paramètre (Le paramètre validé est transferé dans la RAM de l'horloge, en mémoire jusqu'au "reset" ou à l'extinction)
Descendre en bas, une fois tous les paramètres modifiés, et enfin "SAUVEGARDER". L'ensemble des paramètres de la RAM passe de l'EEPROM (Sauvegardés pour quelques dizaine d'années)!

Le firmware

Le logiciel installé sur l'arduino nano entièrement réalisé en assembleur ATMEGA328P ne prend que peu de place.

Segment   Begin    End      Code   Data   Used    Size   Use%
---------------------------------------------------------------
[.cseg] 0x000000 0x000e9e   1930   1812   3742   32768  11.4%
[.dseg] 0x000100 0x00027c      0    380    380    2048  18.6%
[.eseg] 0x000000 0x0000dc      0    133    133    1024  13.0%

Sans compter les essais, cela fait 2288 lignes de programme écrites à la main, sans compter les essais et l'optimisation des différents librairies en assembleur, fait maison
Ont peux largement compter 8000 lignes de code et quelques heures de casse-tête. Mais le résultat est là!!!
Si le besoin s'en fait sentir, je rajouterai un lecteur MP3 micro SD et bien sur deux haut-parleurs.
C'est tout pour aujourd'hui!

Les capteurs de positions

Objectif :Réaliser une maquette pédagogique de capteurs de positions

Moyen:

Arduino Nano ATmega328P - 20mA - 1,98€
Transformateur de tension 230V-5V
led + capteur de lumière

Objetif pédagogique

Cette dernière est constituée de 5 photorécepteurs sur lesquels on pose un disque codeur de position absolue ou un disque codeur de position relative.
Le disque codeur permet d’exposer, ou non, à la lumière, les photo récepteurs suivant qu’ils sont situés au dessous d’une région vide ou pleine.
Cela permet d’obtenir des signaux logiques binaires délivrés par les photo récepteurs.
Ces signaux sont ensuite mis en forme et traités par l'unité logique et l'afficheur qui donne les informations sur la position.

Définition des capteurs de positions

Capteur de position incrémental

Un capteur incrémental est mis sous tension, donnera sa position qu’une fois qu’il disposera d’un point de référence à partir duquel il pourra effectuer des mesures.
Exemple d'une imprimante jet d'encre au démarrage, lance ses moteurs jusqu'a arriver à la position de référence. C'est donc un comptage incrémental (Pas de capteur dans ce cas, c'est un moteur pas à pas, mais, il sera expliqué plus tard!)

Capteur de position absolue

Un capteur de position absolu, signale sa position par rapport à une échelle. Lorsqu’un capteurs de positions absolu est mis sous tension, il donne de sa position sans informations de référence.

Forme de ma maquette

La maquette disposera de plusieurs disques (imprimés en 3D) pour 4 types d'information :

Capteur incrémental, avec Top Zéro
Capteur incrémental, à deux rangés pour le sens de rotation avec Top Zéro
Capteur absolu en binaire naturel sur 4 bits
Capteur absolu en binaire de gray sur 4 bits

Auquel nous pourrons ajouter un regle pour le codeur linéaire.

Codage binaire

Pour la codage absolu :

Position		Binaire	Binaire
Décimale	Hexadécimal	Naturel	Gray
0	0	0000	0000
1	1	0001	0001
2	2	0010	0011
3	3	0011	0010
4	4	0100	0110
5	5	0101	0111
6	6	0110	0101
7	7	0111	0100
8	8	1000	1100
9	9	1001	1101
10	A	1010	1111
11	B	1011	1110
12	C	1100	1010
13	D	1101	1011
14	E	1110	1001
15	F	1111	1000

Lunettes informations virtuelles

Objectif :Visualiser au travers de lunettes du texte virtuel.
Moyen:
- Un micro-contrôleur Attiny 85 <8mA En Stand-by : 5μA
  - Une batteries Lipo 3.7V 520mAh 1.9Wh Lipo 801844
    - Taille : 47x17x8mm
    - Connecteur Molex 51005/MX2.0-2P
    - Masse: environ 40gr
- AT-09 Android IOS BLE 4.0 Bluetooth module pour arduino
  - Module compatible HM-10
  - Tension : HM-10 2-3.7V
  - Alimentation: En mode veille 400uA ~ 1,5mA, mode actif 8,5mA
  - Dimensions : 38 x 16 x 2.2 mm
- Module afficheur OLED 0.66" 64x48 I²C, 0.06W soit environ 16mA SSD1306
  - Adresse I2c : 0x78

Principe

Calcul de la lentille

Les lentilles jouent un rôle essentiel dans ces lunettes virtuelles. Le punctum proximum est le point le plus proche visible par l’œil accommodant (dilatation du cristallin) au maximum.
Celui-ci est situé à environ 25 cm de l’œil humain. Si un objet est situé à une distance plus proche que celle du punctum proximum, celui-ci sera vu flou.
Cela signifierait alors qu’il faudrait que l’écran des lunettes soit situé à au moins 50 cm (2 fois le punctum proximum pour garantir un certain confort visuel) de l’œil, ce qui est dans la pratique et dans l’esthétisme impossible.
Tout comme avec une loupe, on souhaite que l’image soit agrandie, qu’elle soit à l’endroit et qu’elle se forme directement sur notre oeil, et non pas sur un écran.
Et tout comme avec une loupe, l’image observée par l’oeil dans ces lunettes virtuelle sera une image elle aussi virtuelle.
Recevoir des données "Bluetooth" et les afficher sur un écran OLED. L'image est ensuite réfléchi sur un miroir, passe à travers une lentille, puis, l'image est projetée sur un verre acrylique transparent.
Le plus important à savoir, c'est qu’un œil humain ne peut focaliser un objet qu’à une distance minimale de 25 cm.
Et tout ce dont j'avais besoin était cette formule $\dfrac{1}{f} = \dfrac{1}{o} + \dfrac{1}{ i}$ où $f$ est la longueur de la focale, $o$ la distance de l'objet à la lentille et $i$ la distance de l'image virtuelle.
$M=\dfrac{-i}{o}$
Valeurs utilisées:
avec $f = 10~cm$ et $o = 7,3~cm$ on obtient un $i = -27.03~cm$ (les images virtuelles ont toujours une valeur négative) et un grossissement $M = 3,7$

Consommation

Composant
Composant	Courant
Attiny85	8mA
HC-06	8mA
SSD3306	16mA
Un total cumulé de	32mAh

Avec une batteries de 3,7V 550mAh cela fait 37.5 Heures

Protocole Owon B33+

Multimètre avec communication Bluetooth 4.0 BLE "Bluetooth Low Energy" interne.

ASCII

43
'+'

50 53 49 53
'2515'

32
' '

64 128

13 10

'+' ou '-' (43 ou 45)

'2515'

' ' espace

Position de la virgule :

48 '0' pas de virgule
49 '1' après le premier nombre
50 '2' après le deuxième nombre
52 '4' après le troisième nombre

AC, DC et modeauto

49 0110001 mode DC auto
41 0101001 mode AC auto
17 0010001 mode DC manuel
09 0001001 mode AC manuel

Bit 7	Bit 6	Bit 5	Bit 4	Bit 3	Bit 2	Bit 7	Bit 0
0	0	0	0	0	0	0	0	Unité U
1	0	0	0	0	0	0	0	μU
0	1	0	0	0	0	0	0	mU
0	0	1	0	0	0	0	0	kU
0	0	0	1	0	0	0	0	MU
0	0	0	0	1	0	0	0	Buzzer
0	0	0	0	0	1	0	0	Led
0	0	0	0	0	0	1	0	Duty

0 null

unité Octet1:

Bit 7	Bit 6	Bit 5	Bit 4	Bit 3	Bit 2	Bit 7	Bit 0	Unités
0	0	0	0	0	0	0	0	Unité U
1	0	0	0	0	0	0	0	micro U
0	1	0	0	0	0	0	0	milli U
0	0	1	0	0	0	0	0	kilo U
0	0	0	1	0	0	0	0	Mega U
0	0	0	0	1	0	0	0	Buzzer
0	0	0	0	0	1	0	0	Led
0	0	0	0	0	0	1	0	Duty

Octet 2:

Bit 7	Bit 6	Bit 5	Bit 4	Bit 3	Bit 2	Bit 7	Bit 0	Commentaire
1	0	0	0	0	0	0	0	Volt V
0	1	0	0	0	0	0	0	Ampère A
0	0	1	0	0	0	0	0	Ohm Ω
0	0	0	1	0	0	0	0	hFE
0	0	0	0	1	0	0	0	Hertz Hz
0	0	0	0	0	1	0	0	Nano Farad nF
0	0	0	0	0	0	1	0	°Celsius
0	0	0	0	0	0	0	1	°Fahrenheit

25 ???

13 10 CR LF

Configuration du module

Vous devez d'abord définir le module sur maitre.

AT+ROLE1	module = Maitre
AT+RESET	Redémarrer le module
AT+SHOW1	Afficher le nom Bluetooth esclave recherché
AT+IMME0	Lorsque le module est sous tension, répond uniquement à la commande AT, ne rien faire avant la réception de AT + WORK. Connecter automatiquement avec le Owon B33+
AT+FILT0	Rechercher des appareils, trouvera tous les modules BLE
AT+DISC?	Afficher les appareils Reception: OK+NAME: xxx Après l'envoi de la valeur du nom, enverra deux octets ASCII de valeur "\r\n" supplémentaires. Reception: OK+DIS[P0]: 234567890123 Reception: OK+NAME: xxx

Pour se connecter au Owon B35T tapez 'AT+CONE0' (adresse Mac du multimètre) AT + CON[Chaîne MAC]

Le POV V3.0

Persistence Of Vision : La Persistance rétinienne.
Il existe déjà plusieurs versions de POV, mais j'ai décidé d'en faire un nouveau projet.

Objectif :Ce dispositif permet de tracer des mots lumineux (qui semblent s'afficher dans le vide) au moyen de quelques LEDs en rotation rapide.
Moyen:
- Utilisation d'un processeur ATTiny85-20PU
- 74HC595 8-Bit registre à décalage DIP-16
  Basse consommation énergétique, 80μA Max
- 1 US1881 : CAPTEUR EFFET Hall, 5mA
  Masse: 0,11 g; Dimensions : 5 x 4.1 x 1,5 mm (L * l * h);
- 1 aimant permanent : Aimant Disque Rond Néodyme Puissant Terres Rares Ø10xØ5x3mm
- 1 Lipo 852540 3.7V 550mAh 25C
  Masse: 40gr; Taille : 45x25x8mm mm
- 8 LED verte Ø3mm - 20mA
- 8 résistance 220Ω
- 1 Moteur DC 1.5-6.5V - Vitesse: 1700-7300RPM
  Masse: 21g; Dimensions:Ø24x12mm Arbre Ø2x4mm

Le principe

Pour que les lettres demeurent visibles de façon stable pendant une longue période de temps, la barette de LEDs doit repasser par les mêmes positions de façon périodique afin de retracer les lettres avant qu'elles ne disparaissent...

On y arrive en plaçant les LEDs à l'extrémité d'une tige rotative: le mouvement devient périodique et le texte est réécrit à chaque tour de la tige.

Pour que l'éclairage des leds commence toujours au même moment, il est necessaire de démarrer toujours à la même position.

C'est à ce moment qu'intervient le capteur à effet hall et l'aimant
Un capteur à effet Hall permet de mesurer une variation de champ magnétique.

Le temps d'alumage d'une rangée à l'autre dépend avant tout de la vitesse de rotation.

Cette vitesse de rotation doit permettre d'afficher l'intégralité du message en 1/25^ème de seconde soit 25tr/s x 60s =1500 tr/min minimum.

Il est nécessaire de faire attention à l'équilibrage de l'ensemble en rotation, la vitesse étant élevée, des vibrations pourrai survenir et détériorer le moteur.
Lors de la rotation j'ai choisi un angle entre deux rangées de 4°, ce qui représente donc 360/4=90 caractères maximum.
Ceci sera peut-être à rectifié lors des essais.

Le mécanisme

Celui-ci est en cours de conception sur solidworks et imprimante 3D.

L'éléctronique

Soit une consommation maximale totale d'environs : 100mA
Source d'énergie pour le circuit: F Power 7.4V 550mah
C'est un peut lourd, mais je vais la mettre proche du centre, pour équilibrer la masse.

Le programme (A tester également)

Diviseur de vitesse du processeur
Fréquence du processeur		MHz
Fréquence de rotation maxi du moteur		min^-1

;______________________________________
;       SHIFT REGISTER 74HC595
; ***************** ATTENTION NON TESTE
; Matériel :    ATtiny 85 16MHz 5V
;             74HC595
; (c) sammy76.free.fr
;   V1.0 2018/23/01 Janvier 2018 au 2018/03/02 Février 2018
;   V1.1 2018/01/05 Mai 2018 MAJ HALL inversé
;______________________________________
;        ATtiny85 - 16MHz interne
;             +-\/-+
;        PB5 1|-  -|8  VCC
;   HALL PB3 2|-  -|7  PB2 Serial Clock 74HC595
;        PB4 3|-  -|6  PB1 Store Clock 74HC595
;        GND 4|-  -|5  PB0 Serial Data Out 74HC595
;             +----+
;
;ATtiny85 - 16 MHz Digispark
;P0 :  Serial Data Out 74HC595
;P1 :  Store Clock 74HC595
;P2 :  Serial Clock 74HC595
;P3 :  HALL
;P4 :  
;P5 :
;FUSE H:FE, E:DD, L:61
;w lfuse 0 0x61
;w hfuse 0 0xdd
;w efuse 0 0xfe;
;set AVRDUDECONF="C:\Program Files (x86)\Arduino\hardware\tools\avr\etc\avrdude.conf"
;avrdude -C %AVRDUDECONF% -p t85 -c avrisp -P COM7 -b 19200 -U flash:w:POV.hex:i


; Code      :        1452  bytes/8192
; Code      :        1452  bytes/8192
; Data      :         0 bytes
; EEPROM    :         0 bytes

.CSEG
.include "includes/tn85def.inc"
#define F_CPU 16000000 ;16MHz pour Attiny85
;#define F_CPU 16500000 ;16.5MHz pour Digispark

#ifndef DIVISEUR
   #define DIVISEUR 64
#endif

.def    ANSL        = R0   ;To hold low-byte of answer (réponse)
.def    ANSH        = R1   ;To hold high-byte of answer     
.def    REML        = R2   ;To hold low-byte of remainder (reste)
.def    REMH        = R3   ;To hold high-byte of remainder
.def    ONERL       = R4   ;one_rot_time
.def    ONERH       = R5   ;one_rot_time
.def    A           = r16   ;General
.def    DATA        = r20   ;Read/Write data 
.def    count       = r21   ;Count bit in char
.def    DCounter    = r10   ;Count char
.def    delayTimeL  = r22   ;delayTime
.def    delayTimeH  = r23   ;delayTime

.def    last_IN_state= r17   ;Here we store the previous state on digital pin 13

.def    BL          = R18   ;To hold low-byte of divisor
.def    BH          = R19   ;To hold high-byte of divisor
.def    C           = R24   ;Bit Counter

.equ    HALL        =PB3   ;Sensor HALL
.equ    SERDT       =PB0   ;Serial Data Out 74HC595
.equ    SRCLK       =PB2   ;Serial Clock 74HC595
.equ    RCLK        =PB1   ;Store LATCH 74HC595

#define DDR74HC595    DDRB 
#define PORT74HC595   PORTB
;************************************************
;*               register use            *
;************************************************
;YH:YL micros: current count value in micros seconds
;r3:r2 one_rot_time : time for one rot
; 
;-----------------------------------------------------------------
   .org 0000
;************************************************
;* Interrupt Vectors                  *
;************************************************
   rjmp      ON_RESET    ; Reset Handler
   reti       ; External Interrupt 0
   rjmp      Restart_Disp ; Pin change Interrupt Request 0
   reti      ; Timer/Counter1 Compare Match 1A
   reti      ; Timer/Counter1 Overflow
   rjmp      TimerOVF   ; Timer/Counter0 Overflow
   reti      ; EEPROM Ready
   reti      ; Analog comparator
   reti      ; ADC Conversion ready
   reti      ; Timer/Counter1 Compare Match B
   reti      ; Timer/Counter0 Compare Match A
   reti      ; Timer/Counter0 Compare Match B
   reti      ; Watchdog Time-out
   reti      ; USI START
   reti      ; USI Overflow
;***** Include modules
;.include    "wait.inc"
;______________________________________
;           SETUP
;______________________________________
ON_RESET:
   ldi      A, LOW(RAMEND)   ;Setup of stack pointer 0x15F
   out      SPL, A
   ldi      A, HIGH(RAMEND)
   out      SPH, A

   ldi      A,0b10000000   ;Attention, ces 2 instructions sont importantes pour le changement de fréquence (sécurité AVR)
   out      CLKPR,A
   ldi      A,0b0000000      ;divise par 0le clock RC de 8MHz, donc 8MHz ou 16.5MHz (DIGISPARK)
   out      CLKPR,A
   
   ;Eteint le CAN
   cbi      ADCSRA, ADEN   ;switch Analog to Digitalconverter OFF   
   
   rjmp     Init_count
   
    
Write74HC595:
   ;(Enter : Data){
   push     A
   ldi      A,8 ;8 bits
   mov      DCounter,A
   pop      A
    
HCSendBits:
   add      DATA,DATA         ;*2 décalage à gauche
   brcc     HCSendBits0         ; si carry=0 HCSendBits0
   sbi      PORT74HC595,SERDT   ; send 1 (floats high)
   rjmp     HC595Send1
HCSendBits0:
   cbi      PORT74HC595,SERDT   ; send 0 (drives low)
HC595Send1:   
   ;CLOCK
   sbi      PORT74HC595,SRCLK
   cbi      PORT74HC595,SRCLK
   dec      DCounter
   brne     HCSendBits
   ;LATCH
   sbi      PORT74HC595,RCLK
   cbi      PORT74HC595,RCLK
   ;Attente 4°
   rcall    Wait4deg         ;Entre chaque ligne 4°
   ret 
;______________________________________
;WRITE CHAR 1+5x8
;______________________________________
write_char_font6x8:
   push     ZL
   push     ZH
   subi     DATA,32   
   ldi      ZL, LOW(POVled_font5x8<<1)
   ldi      ZH, HIGH(POVled_font5x8<<1)
   clr      A
   ldi      count,5    ;x5 octets pour l'adresse
mul_5:
   add      ZL,DATA
   adc      ZH,A
   dec      count
   brne     mul_5
   ldi      count,5    ;6 octets  pour les données
overdata:   
   lpm      DATA,Z+
   rcall    Write74HC595 ;Ecrire la donnée Write74HC595
   dec      count
   brne     overdata
   pop      ZH
   pop      ZL
   ret

;______________________________________
;WRITE STRING
;______________________________________      
write_string:   
   lpm      DATA, Z+         ;DATA=(Z) FLASH Z=Z+1 CHR(A)
_write:
   ser      A               ;0xFF
   cp       DATA,A            ;Si egal fin
   breq     end_write_str
   rcall    write_char_font6x8   ;Ecrire caractère
   rcall    Wait4deg         ;Entre chaque caractère 4°
   rjmp     write_string
end_write_str:
   ret

;Attent 4°
Wait4deg: 
#if (DIVISEUR==64 || DIVISEUR==8)
;With diviseur 64
   ;Wait ANSH:ANSL cycles avec disiseur/64
   movw     XH:XL,ANSH:ANSL
   lsr      XH ; Divide XH:XL by two
   ror      XL ; XH:XL is an unsigned two-byte integer /2
   lsr      XH ; Divide XH:XL by two
   ror      XL ; XH:XL is an unsigned two-byte integer /2
   ;XH:XL=nbre de fois 4 cycles
#endif
#if DIVISEUR==256
;With diviseur 256
   ;Wait ANSH:ANSL cycles avec disiseur/256 soit à 16MHz un 4° en 
   ;Soit ANSH cycle
   clr      XH
   mov      XL,ANSH ;Temps pour 4°
   lsr      XL   ;/2
   lsr      XL   ;/2
   ;XH:XL=nbre de fois 4 cycles
#endif
#if DIVISEUR==1024
;With diviseur 1024
   ;Wait ANSH:ANSL cycles avec disiseur/1024
   clr      XH
   mov      XL,ANSH ;
   lsr      XL   ;/2
   lsr      XL   ;/2
   lsr      XL   ;/2
   lsr      XL   ;/2
   ;XH:XL=nbre de fois 4 cycles : Temps pour 4°
#endif
   clr      A
   cp       XL,A       ; Compare low byte XH:XL>0
   cpc      XH,A       ; Compare high byte
   breq     endwait4deg   ; Si XH:XL=0 fin

Wait4xCycles:
   sbiw     XH:XL, 1      ; x-- (2 cycles)
   brne     Wait4xCycles   ; jump if not zero (2 cycles)
endwait4deg:
   ret

;Initialise compteur
Init_count:
   cli
   ;On configure le diviseur sur 256 (cf. documentation du microcontrôleur, page 80)
   in       A,TCCR0B
   ;ori A,(1<<CS00)          ;Sans diviseur /1
   #if DIVISEUR==8
      ori      A,(1<<CS01)          ; disiseur /8
   #endif
   #if DIVISEUR==64
      ori   A,(1<<CS01)|(1<<CS00)   ; disiseur /64
   #endif
   #if DIVISEUR==256
      ori   A,(1<<CS02)          ; disiseur /256
   #endif
   #if DIVISEUR==1024
      ori   A,(1<<CS02)|(1<<CS00)    ; disiseur /1024
   #endif
   out      TCCR0B,A
   ;On active les interruptions pour dépassement du compteur 0
   in       A,TIMSK
   ori      A,(1<<TOIE0)|(1<<PCIE)
   out      TIMSK,A
   ;On définit une variable qui comptera les itérations d'interruptions
   clr      YH
   clr      YL       ;micro=0

Init74HC595:
   ;in A,DDR74HC595
   ldi      A,(1<<SERDT) | (1<<SRCLK) | (1<<RCLK) | (0<<HALL) ;3 OUTPUT 1 input
   out      DDR74HC595,A

   ;Init Hall Sensor
   
   ;External Interrupt(s) initialization
   ;Toujours GIFR avant GIMSK
   in       A,GIFR
   ori      A, (1<<PCIF) ;Enable Pin Change Interrupt Flag
   out      GIFR,A
   
   ;INT0: On
   in       A,GIMSK      
   ori      A,(1<<PCIE);PCIE Pin Change Interrupt Enable
   out      GIMSK,A
   in       A,PCMSK
   ori      A, (1 << HALL) ;Pin Change Enable Mask
   out      PCMSK,A
	;INT0 Mode: Rising Edge (Front descendant, MCUR selement en INT0)
   in A,MCUCR
   ori A,(1<<ISC01) | (0<<ISC00)
   out MCUCR,A
   
   ;INT0 Mode: Rising Edge (Front montant, MCUR selement en INT0)
   ;in A,MCUCR
   ;ori A,(1<<ISC01) | (1<<ISC00)
   ;out MCUCR,A
   ;Interrupt on any change on pins PCINT0-5: Off
   
   
   sei
   clr      last_IN_state
;______________________________________
;        BOUCLE PRINCIPALE
;______________________________________
MAIN_LOOP:
   movw     delayTimeH:delayTimeL,ANSH:ANSL
   ldi      A,1      ;4° démarage
   mov      r7,A
   clr      A
   
   cp       YL,r7       ; Compare low byte YH:YL<4°
   cpc      YH,A       ; Compare high byte
   brlo     MAIN_LOOP   ; Branch <4°
   sbrs     last_IN_state,1      ;skip text_ok= 1?
   rjmp     MAIN_LOOP
Disp_text:
   ldi      ZL, LOW(TEXT<<1)
   ldi      ZH, HIGH(TEXT<<1)
   rcall    write_string
   cbr      last_IN_state,2            ;text_ok=0

   rjmp     MAIN_LOOP
;______________________________________
;        DIVIDING TWO 16-BIT NUMBERS
;Input : 
; - Dividend: ANSH:ANSL
; - Divisor BH:BL
;Output :
; - answer : ANSH:ANSL (réponse)
; - remainder : REMH:REML (reste)
;Other Register use: C
;______________________________________   
DIV1616:
   movw     ANSH:ANSL,ONERH:ONERL ;Copy dividend into answer
   ldi      C,17         ;Load bit counter
   sub      REML,REML      ;Clear Remainder and Carry
   clr      REMH         ;
LOOP16:   
   rol      ANSL         ;Shift the answer to the left
   rol      ANSH         ;
   dec      C            ;Decrement Counter
   breq     DONE         ;Exit if sixteen bits done
   rol      REML         ;Shift remainder to the left
   rol      REMH         ;
   sub      REML,BL      ;Try to subtract divisor from remainder
   sbc      REMH,BH
   brcc     SKIP         ;If the result was negative then
   add      REML,BL      ;reverse the subtraction to try again
   adc      REMH,BH      ;
   clc                   ;Clear Carry Flag so zero shifted into A 
   rjmp     LOOP16       ;Loop Back
SKIP:  
   sec                   ;Set Carry Flag to be shifted into A
   rjmp     LOOP16
DONE:
   ret

;______________________________________
;        INT TimerOVF
;______________________________________   
TimerOVF:
   cli                   ;Clear interrupt
   adiw     YL,1         ;On réactive les interruptions
   sei
   reti
   
;______________________________________
;        INT HALL Sensor
;______________________________________   
Restart_Disp: ;Interrupt HALL
   ;First we take the current count value in micro seconds using the micros() function
   cli
   push     A   
   in       A,PINB
   sbic     PINB,HALL    ;Skip if HALL=1  (inversé)       
   rjmp     NOHall       ;If PINB&HALL=0 ->NOHall
   
   sbrc     last_IN_state,0   ;last_IN_state = 0? Skip if Bit in Register is Cleared 
   rjmp     fin_Restart_Disp  ;Si last_IN_state=1 ->fin_Restart_Disp
   sbr      last_IN_state,1   ;last state=1
   rjmp     fin_Restart_Disp
   
NOHall:
   sbrs     last_IN_state,0   ;last_IN_state = 1?
   rjmp     fin_Restart_Disp  ;Si last_IN_state=0 ->fin_Restart_Disp
   cbr      last_IN_state,1   ;last state=0
   mov      ONERL,YL
   mov      ONERH,YH          ;one_rot_time = current_count
   ldi      BL,LOW(90)        ;Load low-byte of divisor into BL
   ldi      BH,HIGH(90)       ;Load high-byte of divisor into BH      
   rcall    DIV1616
   ;time_per_deg=ANSH:ANSL
   ;time_per_deg = one_rot_time/(360.0/4);Time for 4 deg
   
   clr      YL                ;restart current_count
   clr      YH
   sbr      last_IN_state,2   ;text_ok=1
   
fin_Restart_Disp:
   pop      A
   sei
   reti

TEXT:       .db "BTS CPI 2019 "cmd,0xFF,0xFF

.include    "pov6x8.inc"
.ESEG
   .org     0xc0
   buildtime:
   .db      "sammy76.free.fr "
   .db      "V1.00:%DAY%.%MONTH%.%YEAR% %HOUR%:%MINUTE%"
   .db      13,10,"POV V1.0 "

Et enfin la police de caractère pov6x8.inc

; Standard ASCII 5x8 font
POVled_font5x8:
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf4,0x00,0x00 ;   0x20 032 ! 0x21 033
.db 0x00,0xe0,0x00,0xe0,0x00,0x28,0xfe,0x28,0xfe,0x28 ; " 0x22 034 # 0x23 035
.db 0x24,0x54,0xfe,0x54,0x48,0x46,0x26,0x10,0xc8,0xc4 ; $ 0x24 036 % 0x25 037
.db 0x6c,0x92,0xaa,0x44,0x0a,0x00,0xa0,0xc0,0x00,0x00 ; & 0x26 038   0x27 039
.db 0x00,0x38,0x44,0x82,0x00,0x00,0x82,0x44,0x38,0x00 ; ( 0x28 040 ) 0x29 041
.db 0x28,0x10,0x7c,0x10,0x28,0x10,0x10,0x7c,0x10,0x10 ; * 0x2a 042 + 0x2b 043
.db 0x00,0x00,0x05,0x06,0x00,0x10,0x10,0x10,0x10,0x10 ; , 0x2c 044 - 0x2d 045
.db 0x00,0x06,0x06,0x00,0x00,0x04,0x08,0x10,0x20,0x40 ; . 0x2e 046 / 0x2f 047
.db 0x7c,0x8a,0x92,0xa2,0x7c,0x00,0x42,0xfe,0x02,0x00 ; 0 0x30 048 1 0x31 049
.db 0x42,0x86,0x8a,0x92,0x62,0x84,0x82,0xa2,0xd2,0x8c ; 2 0x32 050 3 0x33 051
.db 0x18,0x28,0x48,0xfe,0x08,0xe4,0xa2,0xa2,0xa2,0x9c ; 4 0x34 052 5 0x35 053
.db 0x3c,0x52,0x92,0x92,0x0c,0x80,0x8e,0x90,0xa0,0xc0 ; 6 0x36 054 7 0x37 055
.db 0x6c,0x92,0x92,0x92,0x6c,0x60,0x92,0x92,0x94,0x78 ; 8 0x38 056 9 0x39 057
.db 0x00,0x6c,0x6c,0x00,0x00,0x00,0x6a,0x6c,0x00,0x00 ; : 0x3a 058 ; 0x3b 059
.db 0x10,0x28,0x44,0x82,0x00,0x28,0x28,0x28,0x28,0x28 ; < 0x3c 060 = 0x3d 061
.db 0x00,0x82,0x44,0x28,0x10,0x40,0x80,0x8a,0x90,0x60 ; > 0x3e 062 ? 0x3f 063
.db 0x4c,0x92,0x9a,0x8a,0x7c,0x3e,0x48,0x88,0x48,0x3e ; @ 0x40 064 A 0x41 065
.db 0xfe,0x92,0x92,0x92,0x6c,0x7c,0x82,0x82,0x82,0x44 ; B 0x42 066 C 0x43 067
.db 0xfe,0x82,0x82,0x44,0x38,0xfe,0x92,0x92,0x92,0x82 ; D 0x44 068 E 0x45 069
.db 0xfe,0x90,0x90,0x90,0x80,0x7c,0x82,0x92,0x92,0x5e ; F 0x46 070 G 0x47 071
.db 0xfe,0x10,0x10,0x10,0xfe,0x00,0x82,0xfe,0x82,0x00 ; H 0x48 072 I 0x49 073
.db 0x04,0x02,0x82,0xfc,0x80,0xfe,0x10,0x28,0x44,0x82 ; J 0x4a 074 K 0x4b 075
.db 0xfe,0x02,0x02,0x02,0x02,0xfe,0x40,0x30,0x40,0xfe ; L 0x4c 076 M 0x4d 077
.db 0xfe,0x20,0x10,0x08,0xfe,0x7c,0x82,0x82,0x82,0x7c ; N 0x4e 078 O 0x4f 079
.db 0xfe,0x90,0x90,0x90,0x60,0x7c,0x82,0x8a,0x84,0x7a ; P 0x50 080 Q 0x51 081
.db 0xfe,0x90,0x98,0x94,0x62,0x62,0x92,0x92,0x92,0x8c ; R 0x52 082 S 0x53 083
.db 0x80,0x80,0xfe,0x80,0x80,0xfc,0x02,0x02,0x02,0xfc ; T 0x54 084 U 0x55 085
.db 0xf8,0x04,0x02,0x04,0xf8,0xfc,0x02,0x1c,0x02,0xfc ; V 0x56 086 W 0x57 087
.db 0xc6,0x28,0x10,0x28,0xc6,0xe0,0x10,0x0e,0x10,0xe0 ; X 0x58 088 Y 0x59 089
.db 0x86,0x8a,0x92,0xa2,0xc2,0x00,0xfe,0x82,0x82,0x00 ; Z 0x5a 090 [ 0x5b 091
.db 0xaa,0x54,0xaa,0x54,0xaa,0x00,0x82,0x82,0xfe,0x00 ; \ 0x5c 092 ] 0x5d 093
.db 0x20,0x40,0x80,0x40,0x20,0x02,0x02,0x02,0x02,0x02 ; ^ 0x5e 094 _ 0x5f 095
.db 0x00,0x80,0x40,0x20,0x00,0x04,0x2a,0x2a,0x2a,0x1e ;   0x60 096 a 0x61 097
.db 0xfe,0x12,0x22,0x22,0x1c,0x1c,0x22,0x22,0x22,0x04 ; b 0x62 098 c 0x63 099
.db 0x1c,0x22,0x22,0x12,0xfe,0x1c,0x2a,0x2a,0x2a,0x18 ; d 0x64 100 e 0x65 101
.db 0x10,0x7e,0x90,0x80,0x40,0x18,0x25,0x25,0x25,0x3e ; f 0x66 102 g 0x67 103
.db 0xfe,0x10,0x20,0x20,0x1e,0x00,0x22,0xbe,0x02,0x00 ; h 0x68 104 i 0x69 105
.db 0x02,0x01,0x21,0xbe,0x00,0xfe,0x08,0x14,0x22,0x00 ; j 0x6a 106 k 0x6b 107
.db 0x00,0x82,0xfe,0x02,0x00,0x3e,0x20,0x18,0x20,0x1e ; l 0x6c 108 m 0x6d 109
.db 0x3e,0x10,0x20,0x20,0x1e,0x1c,0x22,0x22,0x22,0x1c ; n 0x6e 110 o 0x6f 111
.db 0x3f,0x24,0x24,0x24,0x18,0x18,0x24,0x24,0x18,0x3f ; p 0x70 112 q 0x71 113
.db 0x3e,0x10,0x20,0x20,0x10,0x12,0x2a,0x2a,0x2a,0x04 ; r 0x72 114 s 0x73 115
.db 0x20,0xfc,0x22,0x02,0x04,0x3c,0x02,0x02,0x04,0x3e ; t 0x74 116 u 0x75 117
.db 0x38,0x04,0x02,0x04,0x38,0x3c,0x02,0x0c,0x02,0x3c ; v 0x76 118 w 0x77 119
.db 0x22,0x14,0x08,0x14,0x22,0x38,0x05,0x05,0x05,0x3e ; x 0x78 120 y 0x79 121
.db 0x22,0x26,0x2a,0x32,0x22,0x08,0x36,0x41,0x00,0x00 ; z 0x7a 122 { 0x7b 123
.db 0x00,0x7f,0x00,0x00,0x00,0x41,0x36,0x08,0x00,0x00 ;  0x7c 124 } 0x7d 125
.db 0x10,0x20,0x10,0x08,0x10,0x28,0x28,0x28,0x28,0x28 ; ~ 0x7e 126  0x7f 127
;ATTENTION ANSI
.db 0x7C,0xAA,0xAA,0x82,0x44,0x5c,0x02,0x02,0x04,0x5e ; € 0x80 128 ü 0x81 129
.db 0x1c,0x2a,0x2a,0xaa,0x9a,0x84,0xaa,0xaa,0x9e,0x82 ;  0x82 130  0x83 131
.db 0x84,0x2a,0x2a,0x1e,0x82,0x84,0xaa,0x2a,0x1e,0x02 ;  0x84 132  0x85 133
.db 0x04,0x2a,0xaa,0x9e,0x02,0x30,0x78,0x4a,0x4e,0x48 ;  0x86 134  0x87 135
.db 0x9c,0xaa,0xaa,0xaa,0x9a,0x9c,0x2a,0x2a,0x2a,0x9a ;  0x88 136  0x89 137
.db 0x9c,0xaa,0x2a,0x2a,0x1a,0x00,0x00,0xa2,0x3e,0x82 ;  0x8a 138  0x8b 139
.db 0x00,0x40,0xa2,0xbe,0x42,0x00,0x80,0xa2,0x3e,0x02 ;  0x8c 140  0x8d 141
.db 0x0f,0x94,0x24,0x94,0x0f,0x0f,0x14,0xa4,0x14,0x0f ;  0x8e 142  0x8f 143
.db 0x3e,0x2a,0xaa,0xa2,0x00,0x04,0x2a,0x2a,0x3e,0x2a ;  0x90 144  0x91 145
.db 0x3e,0x50,0x90,0xfe,0x92,0x4c,0x92,0x92,0x92,0x4c ;  0x92 146  0x93 147
.db 0x4c,0x12,0x12,0x12,0x4c,0x4c,0x52,0x12,0x12,0x0c ;  0x94 148  0x95 149
.db 0x5c,0x82,0x82,0x84,0x5e,0x5c,0x42,0x02,0x04,0x1e ;  0x96 150  0x97 151
.db 0x00,0xb9,0x05,0x05,0xbe,0x9c,0x22,0x22,0x22,0x9c ;  0x98 152  0x99 153
.db 0xbc,0x02,0x02,0x02,0xbc,0x3c,0x24,0xff,0x24,0x24 ;  0x9a 154  0x9b 155
.db 0x12,0x7e,0x92,0xc2,0x66,0xd4,0xf4,0x3f,0xf4,0xd4 ;  0x9c 156  0x9d 157
.db 0xff,0x90,0x94,0x6f,0x04,0x03,0x11,0x7e,0x90,0xc0 ;  0x9e 158  0x9f 159
.db 0x04,0x2a,0x2a,0x9e,0x82,0x00,0x00,0x22,0xbe,0x82 ;  0xa0 160  0xa1 161
.db 0x0c,0x12,0x12,0x52,0x4c,0x1c,0x02,0x02,0x44,0x5e ;  0xa2 162  0xa3 163
.db 0x00,0x5e,0x50,0x50,0x4e,0xbe,0xb0,0x98,0x8c,0xbe ;  0xa4 164  0xa5 165
.db 0x64,0x94,0x94,0xf4,0x14,0x64,0x94,0x94,0x94,0x64 ;  0xa6 166  0xa7 167
.db 0x0c,0x12,0xb2,0x02,0x04,0x1c,0x10,0x10,0x10,0x10 ;  0xa8 168  0xa9 169
.db 0x10,0x10,0x10,0x10,0x1c,0xf4,0x08,0x13,0x35,0x5d ;  0xaa 170  0xab 171
.db 0xf4,0x08,0x14,0x2c,0x5f,0x00,0x00,0xde,0x00,0x00 ;  0xac 172  0xad 173
.db 0x10,0x28,0x54,0x28,0x44,0x44,0x28,0x54,0x28,0x10 ;  0xae 174  0xaf 175
.db 0x55,0x00,0xaa,0x00,0x55,0x55,0xaa,0x55,0xaa,0x55 ;  0xb0 176  0xb1 177
.db 0x00,0x00,0x00,0xff,0x00,0x08,0x08,0x08,0xff,0x00 ;  0xb2 178  0xb3 179
.db 0x28,0x28,0x28,0xff,0x00,0x08,0x08,0xff,0x00,0xff ;  0xb4 180  0xb5 181
.db 0x08,0x08,0x0f,0x08,0x0f,0x28,0x28,0x28,0x3f,0x00 ;  0xb6 182  0xb7 183
.db 0x28,0x28,0xef,0x00,0xff,0x00,0x00,0xff,0x00,0xff ;  0xb8 184  0xb9 185
.db 0x28,0x28,0x2f,0x20,0x3f,0x28,0x28,0xe8,0x08,0xf8 ;  0xba 186  0xbb 187
.db 0x08,0x08,0xf8,0x08,0xf8,0x28,0x28,0x28,0xf8,0x00 ;  0xbc 188  0xbd 189
.db 0x08,0x08,0x08,0x0f,0x00,0x00,0x00,0x00,0xf8,0x08 ;  0xbe 190  0xbf 191
.db 0x08,0x08,0x08,0xf8,0x08,0x08,0x08,0x08,0x0f,0x08 ;  0xc0 192  0xc1 193
.db 0x00,0x00,0x00,0xff,0x08,0x08,0x08,0x08,0x08,0x08 ;  0xc2 194  0xc3 195
.db 0x08,0x08,0x08,0xff,0x08,0x00,0x00,0x00,0xff,0x28 ;  0xc4 196  0xc5 197
.db 0x00,0x00,0xff,0x00,0xff,0x00,0x00,0xf8,0x08,0xe8 ;  0xc6 198  0xc7 199
.db 0x00,0x00,0x3f,0x20,0x2f,0x28,0x28,0xe8,0x08,0xe8 ;  0xc8 200  0xc9 201
.db 0x28,0x28,0x2f,0x20,0x2f,0x00,0x00,0xff,0x00,0xef ;  0xca 202  0xcb 203
.db 0x28,0x28,0x28,0x28,0x28,0x28,0x28,0xef,0x00,0xef ;  0xcc 204  0xcd 205
.db 0x28,0x28,0x28,0xe8,0x28,0x08,0x08,0xf8,0x08,0xf8 ;  0xce 206  0xcf 207
.db 0x28,0x28,0x28,0x2f,0x28,0x08,0x08,0x0f,0x08,0x0f ;  0xd0 208  0xd1 209
.db 0x00,0x00,0xf8,0x08,0xf8,0x00,0x00,0x00,0xf8,0x28 ;  0xd2 210  0xd3 211
.db 0x00,0x00,0x00,0x3f,0x28,0x00,0x00,0x0f,0x08,0x0f ;  0xd4 212  0xd5 213
.db 0x08,0x08,0xff,0x08,0xff,0x28,0x28,0x28,0xff,0x28 ;  0xd6 214  0xd7 215
.db 0x08,0x08,0x08,0xf8,0x00,0x00,0x00,0x00,0x0f,0x08 ;  0xd8 216  0xd9 217
.db 0xff,0xff,0xff,0xff,0xff,0x0f,0x0f,0x0f,0x0f,0x0f ;  0xda 218  0xdb 219
.db 0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0xff,0xff ;  0xdc 220  0xdd 221
.db 0xf0,0xf0,0xf0,0xf0,0xf0,0x1c,0x22,0x22,0x1c,0x22 ;  0xde 222  0xdf 223
.db 0x3e,0x54,0x54,0x7c,0x28,0x7e,0x40,0x40,0x60,0x60 ;  0xe0 224  0xe1 225
.db 0x40,0x7e,0x40,0x7e,0x40,0xc6,0xaa,0x92,0x82,0xc6 ;  0xe2 226  0xe3 227
.db 0x1c,0x22,0x22,0x3c,0x20,0x02,0x7e,0x04,0x78,0x04 ;  0xe4 228  0xe5 229
.db 0x60,0x40,0x7e,0x40,0x40,0x99,0xa5,0xe7,0xa5,0x99 ;  0xe6 230  0xe7 231
.db 0x38,0x54,0x92,0x54,0x38,0x32,0x4e,0x80,0x4e,0x32 ;  0xe8 232  0xe9 233
.db 0x0c,0x52,0xb2,0xb2,0x0c,0x0c,0x12,0x1e,0x12,0x0c ;  0xea 234  0xeb 235
.db 0x3d,0x46,0x5a,0x62,0xbc,0x7c,0x92,0x92,0x92,0x00 ;  0xec 236  0xed 237
.db 0x7e,0x80,0x80,0x80,0x7e,0x54,0x54,0x54,0x54,0x54 ;  0xee 238  0xef 239
.db 0x22,0x22,0xfa,0x22,0x22,0x02,0x8a,0x52,0x22,0x02 ;  0xf0 240  0xf1 241
.db 0x02,0x22,0x52,0x8a,0x02,0x00,0x00,0xff,0x80,0xc0 ;  0xf2 242  0xf3 243
.db 0x07,0x01,0xff,0x00,0x00,0x10,0x10,0xd6,0xd6,0x10 ;  0xf4 244  0xf5 245
.db 0x6c,0x48,0x6c,0x24,0x6c,0x60,0xf0,0x90,0xf0,0x60 ;  0xf6 246  0xf7 247
.db 0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x08,0x08,0x00 ;  0xf8 248  0xf9 249
.db 0x0c,0x02,0xff,0x80,0x80,0x00,0xf8,0x80,0x80,0x78 ;  0xfa 250  0xfb 251
.db 0x00,0x98,0xb8,0xe8,0x48,0x00,0x3c,0x3c,0x3c,0x3c ;  0xfc 252  0xfd 253

Recycler d'ABS

Projet permettant de recycler les restes d'ABS.

J'utilise régulièrement des imprimantes 3D depuis 2007 environs, celui ou celle qui me dit que l'impression de fil ABS se passe toujours bien, me jette la première pierre.
De la même manière, les projets évoluent (C'est aussi ça les projets), que faire des anciennes impressions?
Je propose de faire un système de recyclage complet de ABS sous différentes formes au retour vers le fils ABS.

Objectif : Recycler de l'ABS d'imprimante 3D.
Moyen:
- Utilisation d'un processeur ATmega328P sur Arduino Nano
- Énergie utilisée : Batterie/Alim/Piles/Solaire???
- Télécommande : HF433/Bluetooth/Wifi ???
Démarche de pré-étude
- Calcul de l'énergie nécessaire pour chauffer l'ABS afin de connaitre le débit
- Déterminer le bloc de chauffe nécessaire
- Déterminer les caractéristique de l'enrouleur
- Déterminer les caractéristique du broyeur
- Déterminer les caractéristique du transfert
Etablir de Cahier Des Charges Fonctionnel

Pré-étude

Caractéristiques de l'ABS (Acrylonitrile butadiène styrène) :
Masse volumique 1,03-1,08 kg·dm^-3
Solvant Acétone
Capacité calorifique massique de l'air à pression constante : $c_{p_{air}} = 1,15 kJ\cdot kg^{-1} \cdot K^{-1}$
Calcul de la chauffe

Hypothèse

L'ensemble de chauffe est considéré sans perte, après fabrication, le rendement sera mesuré.
Masse volumique $\rho_{abs}=1,04 g\cdot cm^{-3}$
Capacité calorifique massique de l'ABS : $C_{p_{abs}} = 1,8~J\cdot g^{-1}\cdot K^{-1}$.
Soit deux résistances chauffantes de $ 120~W$, $ P_u=120 \times 2=240~W~\rightarrow~\dot Q_R=240~J\cdot s^{-1}$
L'ABS entre $ T_A=20~^{\circ}C$ et en ressort à $ T_B=240~^{\circ}C$

Calcul

$ Q_{abs}=m_{abs}\cdot C_{p_{abs}}\cdot \Delta T=m_{abs}\cdot q_{abs}$

$ q_{abs}=C_{p_{abs}}\cdot \Delta T=1.8 \times (240-20)=+396~J\cdot g^{-1}$ , l'ABS reçois l'énergie.

On obtient le débit $\dot m_{abs}$ en prenant $\dot Q_{abs}=\dot Q_R$
$ \dot m_{abs}=\dfrac{\dot Q_{abs}}{q_{abs}}~\rightarrow~\dot m_{abs}=\dfrac{\dot Q_R}{q_{abs}}=\dfrac{ 240}{ 396}=0,61~g\cdot s^{-1}$

Je calcul ensuite le débit du fils de Ø2.85 mm soit Ø0,285cm :
$\dfrac{4\cdot \dot m_{abs}}{\pi \cdot D^2\cdot \rho_{abs}}=\dfrac{4\times 0,61}{\pi \times 0,285^2\times 1,40}=6,79~cm\cdot s^{-1}$

Une bobine contenant 750 gr d'ABS, le temps pour une bobine est de :
$\dfrac{ 750}{0,61}=1 237,50~secondes~\rightarrow$ environs 20 minutes.
Pour une longueur de $ L=\dfrac{4\cdot M}{\pi \cdot D^2\cdot \rho_{abs}}=\dfrac{4\times 750}{\pi \times 0,285^2\times 1,40}=8397~cm$ soit 83m

Le refroidissement :

Hypothèse

Il est indispensable que le fils conserve une température d'environs $70^{\circ}C $ de façon à pouvoir l'enrouler sans que la matière continue à coller.
Dans un premier temps, il faut déterminer le volume et la température d'eau ou d'air nécessaire.
Et revoilà les calculs:
Capacité calorifique massique de l'ABS : $C_{p_{abs}} = 1,8~kJ\cdot kg^{-1}\cdot K^{-1}$.
Capacité calorifique massique de l'air à pression constante : $C_{p_{air}}=1,15 kJ\cdot kg^{-1} \cdot K^{-1}$

Énergie cédée par l'ABS:$Q_{abs}=m_{abs}\cdot C_{p_{abs}} \Delta T$
$q_{abs}=C_{p_{abs}}\cdot \Delta T=1800 \times (70-240)=-306~000J\cdot kg^{-1}$
$\dot m_{abs}=0,61~g\cdot s^{-1}~\rightarrow~0,00061~kg\cdot s^{-1}$
$\dot Q_{ABS}=\dot m_{abs}\cdot q_{abs} = -185,5~J\cdot s^{-1}$ c'est la puissance à fournir pour le refroidissement.
Par air: Puissance à dissipé par le ventilateur : $P=186~W$
$\dot Q_{air}=\dot m_{air}\cdot C_{p_{air}} \cdot \Delta T$ avec $\dot Q_{air}=\dot Q_{ABS}$ et le résultat $\dot m_{air}~(kg\cdot s^{-1})$
$\dot m_{air}=\dfrac{\dot Q_{air}}{C_{p_{air}}\cdot \Delta T}$
A.N.: $\dot m_{air}=3600\times \dfrac{185,5}{1150\times (70-20)}=11,6~kg\cdot h^{-1}$

$\rho_{air}=1,213~kg\cdot m^3$ à 100m avec une pression de 1013,25 hPa, 20°C.
Le débit d'air nécessaire $Q_{v_{air}}=\dfrac{\dot m_{air}}{\rho_{air}}=\dfrac{11,6}{1,213}=9,575~m^3\cdot h^{-1}$
Comme il s'agit d'un coffret relativement aéré, nous considérerons (arbitrairement) que nous sommes assez proches d'un coffret vide, et que le débit d'air est réduit de 25 %. J'ajoute donc 25% :
$Q_{v_{air}}=9,575\times 1,25=11,97~m^3\cdot h^{-1}$
Comme la plupart des ventilateur l'unité de débit est le CFM (Cubic foot/minute) $1~m^3\cdot h^{-1} = 0,588578~ft^3\cdot min^{-1}$
$11,97~m^3\cdot h^{-1}\approx 7~CFM$

Pour réaliser un enrouleur automatique (Trancannage) :

Le principe est simple enrouler autour du tambour ($D_{tambour} \times L_{tambour}$) un fils de diamètre $D_{fil}$.
Prenons un exemple :
$ D_{tambour}=100 mm$
$ L_{tambour}=70 mm$
$ D_{fil}=2,85mm$

Un rang l'enroulement fait $\dfrac{ 70}{2,85}=24,56 tours$
Le 1^er tour fait $ P=2\cdot \pi\cdot \dfrac{D_{tambour}+D_{fil}}{2}=\pi\cdot(D_{tambour}+D_{fil})=\pi \times (100+2,85)=323,11 mm$
Soit une longueur de $323,11\times 24,56=7 936,10 mm$
Le 2^ème tour fait $ P=\pi\cdot(D_{tambour}+3 \cdot D_{fil})=\pi \times (100+3 \times 2,85)=341,02 mm$
Soit une longueur de $341,02\times 24,56=8 375,93 mm$
Le 3^ème tour fait $ P=\pi\cdot(D_{tambour}+5 \cdot D_{fil})=\pi \times (100+5 \times 2,85)=358,93 mm$
Soit une longueur de $358,93\times 24,56=8 815,75 mm$
...
On peut donc écrire $ \pi \sum\limits_{i=0}^{nb_{rang}} (D_{tambour}+(2\cdot i+1)\cdot D_{fil})$