Gaggia Classic et Raspberry Pi

Me revoilà, avec une Gaggia Classic entièrement modifiée. J'ai installé une Raspberry Pi, connectée à 2 relais statiques en sortie: un pour la chauffe, l'autre pour la pompe. Et un petit écran 2.8 pouces Adafruit PiTFT+ pour de jolis graphiques et une interface utilisateur (c'est un écran tactile, mais je n'en fais rien pour l'instant: j'utilise simplement les 4 petits interrupteurs sur le côté de l'écran pour tout contrôler).

En entrée, un capteur thermique DS18B20 sur la chaudière (température maximale = 125 degrés, donc bye-bye la vapeur et les capuccinos pour l'instant ; mais j'ai eu de gros problèmes avec mon thermocouple, et j'avais ce capteur sous la main), et une petite balance 0-1000g à 5 euros démontée pour en faire sortir les fils de la jauge de contrainte, et les connecter à un ampli d'instrumentation INA125P, alimenté directement sur les 5V de la Raspberry Pi. Les 2 fils de sortie de l'ampli viennent se connecter à un convertisseur analogique-digital ADS1115 en mode différentiel qui communique avec la Raspberry Pi via I2C. Et un potentiomètre 10K avec un gros bouton sur le côté droit de la machine, qui ne sert pas à grand chose pour l'instant (flow profiling manuel à mettre en place).

Le tout orchestré par un mauvais script en Python codé par mes soins (mes pieds diront les pros -- je vais le mettre en ligne dès que je l'aurai un peu nettoyé, mais je préviens : je ne suis pas programmeur, et j'ai dû presque tout apprendre de la programmation en me lançant dans ce projet -- c'était un peu le but en fait ; mon script est bourré de variables globales, c'est un véritable sac de noeuds, pas toujours facile à débugger quand j'introduis des modifications, mais je suis arrivé à quelque chose qui fonctionne, c'est déjà ça).

Les principales fonctionnalités :

- Contrôle de la température de chauffe en boucle fermée (PID) à l'équilibre, quand aucun shot ne passe, et en boucle ouverte lors des shots.

- Contrôle assez précis de la puissance de la pompe, sur chaque pulsation fournie par le courant alternatif -- par exemple, quand le relai statique de la pompe reçoit un signal 0101010101 (où chaque 0 et 1 ne dure que 20 ms), la pompe tourne à 50% de sa puissance sur ces 2 dixièmes de seconde; si le relai reçoit 0010010010, elle tourne à 30% de sa puissance.

- Sur l'écran : un graphique de la température de la chaudière et de la puissance de la chauffe; et pendant les shots, on ajoute un graphe sur la puissance de la pompe, un chronomètre, et le poids mesuré du café qui coule dans la tasse.

- Pendant les shots, ajustement automatique de la pompe en fonction du débit mesuré: si ça coule trop vite, la pompe réduit sa puissance, si ça coule trop lentement, elle l'augmente. Intérêt : tous mes shots coulent en 32-33 secondes indépendamment de la taille de la mouture, et je n'ai plus à jeter 1 shot sur 2 dans l'évier dès que j'ajuste mon moulin (tous les jours car je n'ai qu'un seul moulin pour mes extractions douces du petit déjeuner, et pour l'espresso). Le résultat en tasse est incroyable. Je viens de mettre un long post sur Coffee Hustle (en anglais) à ce sujet (moins sur les aspects techniques, et plus sur la théorie de l'extraction, et les raisons qui m'ont motivé à me lancer dans ce projet).

- Possibilité de flow profiling ascendant en début de shot (d'une durée ajustable et jusqu'à une puissance max de la pompe ajustable).

- Arrêt automatique des shots quand un poids spécifié (aussi ajustable) a été atteint dans la tasse.

- A la fin, envoi de graphiques sur le poids, le débit et la puissance de la pompe générés par un script R dans ma boîte mail.

- Menu pour gérer les paramètres

Voilà voilà... il me reste à ajouter un relai pour contrôler la vanne à 3 voies (pour l'instant, je l'active manuellement avec l'interrupteur standard de la machine), à trouver une jolie boite en alu ou en inox (pour l'instant tout est dans une boite en plastique visée à l'arrière de la machine -- pas très beau), et à trouver une boite étanche (ou à peu près) pour la balance.

Voilà quelques videos et photos:

L'installation, avec le PID lors de la chauffe initiale (ou presque : la machine refroidissait et commence donc à 50 degrés).



Le PID à l'équilibre (c'est presque hypnotisant).



La pompe à différents niveaux de puissance.



Le menu des paramètres



Le rapport automatiquement envoyé par e-mail après chaque shot (plus de détails à ce sujet dans mon post sur Coffee Hustle):

Vraiment, un grand bravo.
Il y a effectivement, comme tu le dis, deux types de commentaires sur ton travail: techniques ou bien sur l'extraction.

Sur la technique, peu-être que les paramètres du PID ne sont pas ajustés ? Est-ce un algorithme vraiment basé sur P, I et D ? Là, on est un peu trop en régime oscillant je crois. On doit pouvoir atteindre un régime davantage "critique", c.à.d convergeant le plus rapidement possible vers la consigne sans la dépasser. Là, ça monte à 95C pour converger vers 91C. (Ensuite, les petites oscillations sur cette grosse, qu'on voit sur ta video, j'imagine sont +/- inévitables.)

Question extraction il y a je crois des phénomènes paradoxaux : si on envoie une forte pression, il faut parfois moudre plus GROS. Certains disent que c'est à cause des fines qui se tassent sous l'effet brutal de la haute pression et qui bouchonnent. Je ne sais pas si c'est la raison mais c'est vrai que dans certains domaines de pression/finesse mouture, on a cet effet contre-intuitiif. Ca pourrait compliquer dans certains cas l'usage de ton algorithme : trop lent => j'augmente la puissance de la pompe.

Complètement d'accord sur le PID. Il reste encore du boulot pour stabiliser la température à l'équilibre et éviter l'oscillation de +0.3 / -0.3 par rapport à la température de consigne. A vue de nez, tu ferais quoi ? Augmenter d'un poil le paramètre sur la dérivée, et réduire celui sur l'intégrale ?

Je ne m'inquiète pas trop de l'overshoot au départ. C'est même plutôt une bonne chose car sur une machine froide, il faut chauffer les parois de la bouilloire (sur lesquelles les résistances sont montées), l'eau à l'intérieur, et le groupe situé juste en dessous. La machine n'entre en mode PID qu'à partir d'une certaine température. Il y a une condition dans la fonction qui gère la puissance de la chauffe :


if temp < 0.90 * target_temp:
   heat_power = 100

On le voit d'ailleurs sur la vidéo : il y a un changement de régime de chauffe à partir de 82-83 degrés quand la machine entre en mode PID ; en dessous, elle chauffe à fond. L'overshoot permet de raccourcir à la marge l'arrivée à l'équilibre (en gros, inutile d'y aller à tâtons avec un PID un peu précautionneux quand le groupe est froid).

Sur l'extraction, j'ai pas mal réfléchi au problème que tu soulèves. D'après ce que j'ai pu lire, il s'agit surtout d'une histoire de migration des fines qui descendent dans le PF sous l'effet de la montée en pression violente et, comme tu le dis, viennent rapidement s'accumuler et former un bouchon en bas du PF. Evidemment, je n'ai jamais pu observer ce qui se passe dans un PF pendant le shot, mais apparemment, la migration des fines se produit en début de shot et sous l'effet d'une augmentation brutale de débit/pression (par exemple passage de 0 à 9 bar en 2 secondes). Ici on est sur des augmentations assez graduelles (+10 % de puissance de la pompe par seconde au maximum), et en milieu de shot (il faut 4 grammes dans la tasse ou 14 secondes au chrono pour que l'ajustement automatique du débit s'enclenche).

Bravo, tu as réalisé une machine presque tout automatique ! :-)

Sans rire, c'est une jolie manip que tu as réalisée là. Pour réduire l'oscillation du PID j'aurais personnellement pas touché la dérivée, mais plutôt mis dans l'intégrale la valeur du temps de réponse du système (ta période d'oscillation) et j'aurais monté la proportionnelle jusqu'à supprimer les oscillation. La dérivée, c'est plutôt utile dans un deuxième temps quand tu fais des gros changements de température.

Je me pose une question. Je croyais qu'il fallait une pression assez importante pour éjecter les hydrocarbures des grains de café. Si tu diminues la pression pour gagner du temps, les hydrocarbures sont ils extraits de la même manière ?

Oui : je n'ai plus qu'à intégrer mon moulin dans la machine, et j'aurai une Jura !

Pour ta question : très honnêtement, je ne sais pas -- d'autant que je n'ai pas de mano. Mais d'après ce que j'ai pu lire, la pression a 3 effets sur l'extraction en espresso :

1- faire passer l'eau à travers le café finement moulu
2- émulsifier les huiles du café
3- faire passer des fines dans la tasse pour augmenter le corps

Mon système permet de négliger le premier effet (la pompe envoie juste le débit et donc la pression nécessaire pour que ça passe), mais les effets 2 et 3 risquent forcément d'introduire des variations entre les shots produits sous différents profils de puissance de pompe.

Après c'est une question de degré. J'ai gouté des espressi à 7 bar fantastiques, donc peut-être que les 9 bars ne sont pas nécessaires. 5 bar, même, c'est déjà énormément de pression. Est-ce assez pour produire un espresso? Je n'en sais rien. Ça doit dépendre du café, de la torréfaction, et de plein d'autres choses.

L'autre jour, j'ai voulu m'amuser et j'ai tenté un Kenya Kiunyu bien clair (donc un café qui pousse à 1600-1800 mètres, hyper dense, et pas très soluble -- je le réserve d'habitude exclusivement au V60) -- le shot est passé en 29 secondes, mais la pompe s'est mise à réduire sa puissance très vite : dès les 14 secondes, elle était passée à 10%. Résultat: 34g en tasse (dose de 18g), pas de créma, presque pas de corps ; pas dégueu, mais un drôle d'arrière goût salé, de bacon presque... Il aurait peut-être bénéficié d'un brew ratio plus élevé (45g? 50g?), mais clairement avec ce profil de débit, je ne pouvais pas m'attendre à avoir un espresso dans la tasse. (Je ne me suis pas acharné, et j'ai arrêté les frais).

Voilà le graph du Kenya en question:



Par contre, j'ai fait un Daterra Bruzzi qui s'est formidablement bien exprimé l'autre jour malgré une mouture un poil trop grossière, qui a rendu nécessaire une baisse progressive mais continue du régime de la pompe à partir de 20 secondes jusqu'à 10%.



Donc pour répondre a ta question : est-il nécessaire de maintenir la pompe à plein régime pour faire de l'espresso ? C'est sans doute préférable, mais je pense qu'il y a une marge de manoeuvre assez significative, et largement inexplorée pour l'instant, qui doit dépendre entre autres choses de la solubilité du café, de la déviation de la taille de la mouture par rapport à une mouture optimale, etc.

C'est clair que pour le Kenya, à partir de 14s, la pompe est quasiment éteinte.... tu dois pouvoir pousser le système dans ses retranchements mais faut pas exagérer quand même. Sinon ton système permet une sorte de pré-infusion progressive. Ca serait intéressant de comparer au profil de pression d'une pré-infusion de E61.

Merci pour cette réponse détaillée. En tous cas, tu as là un joli joujou pour expérimenter.

superbe ton projet, bravo tu es doué!
chapeau pour l'algorithme de réduction automatique de la pression de la pompe en fonction du débit!
par contre, au niveau du temps d'extraction, je trouve que certains shots extraits plus lentement (plus de 30 secondes) sont aussi bons sinon meilleurs

pour régler le PID, il y a beaucoup d'informations sur le net (check google!)
sinon as-tu vu le projet de James sur sa Gaggia?
[Vous devez être inscrit et connecté pour voir ce lien]
il a un réglage prédéfini, peut-être fonctionnera-t-il aussi chez toi:
[Vous devez être inscrit et connecté pour voir ce lien]

j'aime beaucoup ton rapport envoyé par email, je pensais à un truc similaire mais pas aussi beau
comment fais-tu pour les graphiques?
utilises-tu une librairie graphique particulière?

je serais intéressé aussi pour le montage de ta pompe sur le SSR: tu connectes juste le SSR à la pompe, sans d'autres composants?

Merci ! Tu devrais pouvoir intégrer ce genre de fonctionnalité assez facilement dans ta Rocket -- et je suis sûr que ton code sera plus beau que le mien !

Pour le contrôle de la pompe, j'avais commencé par mettre le SSR en série avec la pompe, mais ça ne marchait pas. J'envoyais un signal au SSR, la LED s'allumait, mais la pompe ne s'activait pas... J'ai passé pas mal de temps à essayer de comprendre ce qui se passait, et j'ai fini par comprendre : mon SSR est de type "zero crossing", cad qu'il ne ferme le circuit que lorsqu'il détecte le passage à zéro du courant. Or la pompe a une diode intégrée en série qui ne laisse passer que la moitié (positive) des cycles du courant AC ; du coup, le SSR attendait bien sagement le passage à zéro, mais ne le voyait jamais arriver car les tensions <0 étaient bloquées par cette foutue diode. La solution est simple : ajouter une résistance de forte valeur en parallèle avec la pompe/diode (résistance branchée aux bornes de la pompe), histoire de ne laisser passer qu'un courant de l'ordre du milliampère et de ne pas avoir à dissiper trop de chaleur (je n'ai plus la valeur exacte de la résistance en tête -- elle est maintenant cachée sous de la gaine thermorétractable). Ce faible courant, qui passe quoi qu'il arrive est suffisant pour que le SSR détecte un passage à zéro et ferme le circuit (active la pompe) quand on lui demande.

Merci pour le lien vers le projet de James (j'avais essayé ses valeurs de PID au départ, mais le résultat n'était pas top -- il faut dire que j'ai un cycle de conversion de la température, et du coup de chauffe plus long que le sien, donc ça doit jouer sur la stabilité). Tu as sans doute remarqué qu'il contrôle sa pompe d'une autre manière, grâce à un IGBT -- c'était bien au delà de mes maigres connaissances en électronique, donc j'ai cherché à faire plus simple. Mais son système m'a l'air plus "propre".

Pour les graphs : j'utilise en fait un script en R, avec la librairie ggplot2. Il y aurait sans doute moyen de faire la même chose avec matplotlib en Python, mais j'utilise R pour mon boulot en statistiques/analyse de données -- du coup, j'ai préféré installer R sur la Raspberry Pi.

Promis je mets tout mon code en ligne dès que je l'aurai nettoyé.

Sinon, j'ai une question sur ton installation : quel thermocouple utilises-tu ? J'avais essayé de connecter un thermocouple avec une carte MAX31855, mais c'était un thermocouple connecté à la terre (grounded thermocouple) et qui était du coup incompatible.

ok merci pour l'astuce de la résistance. si je prends une de 220Kohm, ça me ferait un courant de 1mA (cf U=R*I si je ne m'abuse)

petite question, tu as utilisé le PWM hardware pour le SSR de la pompe et un PWM software pour le SSR du PID? (sachant que le raspberry n'a qu'un seul PWM hardware)

pour le PID, effectivement si tu mets plus de temps à calculer la température, ça peut jouer. moi j'ai repris ses réglages, ça marchait du premier coup, mon temps de rafraichissement PID est de 0,5 secondes.
Ah James contrôle sa pompe avec une usine à gaz lol c'est un crack de l'électronique.
je me demande si son système fait le même son (les "clac clac") lorsqu'il le met en route à basse puissance? sinon, tant que ça marche écoute...

as-tu testé si la pression d'extraction est proportionnelle à la puissance appliquée au SSR?

Pour les graphs, je connaissais pas le R, c'est vachement bas niveau et ça a l'air hyper puissant pour les statistiques! quand je vois comment tu crées des graphes de prédiction de fin de shot et cie, chapeau c'est du haut niveau

Pour mon installation, j'utilise des thermocouples choppés sur ebay, j'en ai pris deux types:
[Vous devez être inscrit et connecté pour voir ce lien]
et
[Vous devez être inscrit et connecté pour voir ce lien]

l'avantage du deuxièmme c'est qu'il est plus fin et j'ai pu l'insérer dans des doigts de gants assez étroits. les deux marchent au poil!

C'est un superbe projet. Je dispos d'un Raspberry pi 2 mais je suis très software, l'électronique étant plutôt un hobby.

J'ai quelques réalisations domotiques à mon actif, et dès que je recevrai mon moulin et ma machine je pense que je craquerai et tenterai de les connecter au Pi... Ta réalisation me motive beaucoup

[Vous devez être inscrit et connecté pour voir ce lien] : pour la valeur de la résistance, il faut surtout bien faire attention à rester sous la puissance max de la résistance (230^2 / valeur de la résistance < puissance max en Watts).

Je n'utilise pas le PWM hardware de la Raspberry -- pour la chauffe, la fréquence est très faible (cycle de 0.79 seconde, pour qu'il soit à peu près calé sur le temps de conversion de mon capteur thermique, qui est de l'ordre de 0.81 seconde), donc on consomme vraiment peu de CPU en faisant :

Code:

   
    if power > 0:
        GPIO.output(heat_pin, True)
        time.sleep(.79 * power/100)
    if power < 100:
        GPIO.output(heat_pin, False)
        time.sleep(.79 * (100-power)/100)
    GPIO.output(heat_pin, False)


Pour la pompe, c'est également logiciel, mais ça tourne plus vite car je demande au SSR de s'ouvrir ou de se fermer tous les 2 centièmes de seconde. En gros : je définis les pulsations à effectuer, dans les différents cas possibles :

Code:


pulse_sequence = [[0,0,0,0,0,0,0,0,0,0], # 0% power
                  [0,0,0,0,1,0,0,0,0,0], # 10%
                  [0,0,0,0,1,0,0,0,0,1], # 20%
                  [0,0,0,1,0,0,1,0,0,1], # 30%
                  [1,0,0,1,0,0,1,0,0,1], # 40%
                  [1,0,1,0,1,0,1,0,1,0], # 50%
                  [0,1,1,0,1,1,0,1,1,0], # 60%
                  [1,1,1,0,1,1,0,1,1,0], # 70%
                  [1,1,1,1,0,1,1,1,1,0], # 80%
                  [1,1,1,1,0,1,1,1,1,1], # 90%
                  [1,1,1,1,1,1,1,1,1,1]] # 100% power

def output_pump(pump_power):
    if pump_power < 0 or pump_power > 10:
        print "Error, choose pump_power between 0 and 10"
    else:
        pulses = pulse_sequence[pump_power]
        for i in range(0, 10):
            GPIO.output(pump_pin, pulses[i])
            time.sleep(.02) # wait 20 ms between pulses


Je peux dire une grosse bêtise, mais je pense qu'un PWM hardware regrouperait forcément les pulsations On en début de cycle et les pulsations Off en fin de cycle (ou inversement), mais ne les distribuerait pas uniformément. Je peux me tromper.

Je n'ai pas vérifié l'effet sur la pression (je n'ai pas de mano sur ma machine). La seule chose que j'ai pu vérifier, c'est que le débit était linéaire en fonction de la puissance de la pompe quand j'active la pompe et que je fait couler l'eau sans PF. Je ne pense pas qu'on puisse obtenir la même linéarité en modulant la tension de la pompe avec un IGBT comme James (mais là encore, je peux me tromper !). Mais son système est plus propre dans le sens où la pompe continue à effectuer l'ensemble des pulsations à la fréquence de 50Hz (donc pas de "clac-clac" comme chez moi).

doubleshot a écrit:
Je n'utilise pas le PWM hardware de la Raspberry -- pour la chauffe, la fréquence est très faible (cycle de 0.79 seconde, pour qu'il soit à peu près calé sur le temps de conversion de mon capteur thermique, qui est de l'ordre de 0.81 seconde), donc on consomme vraiment peu de CPU en faisant :  

Code:

    
    if power > 0:
        GPIO.output(heat_pin, True)
        time.sleep(.79 * power/100)
    if power < 100:
        GPIO.output(heat_pin, False)
        time.sleep(.79 * (100-power)/100)
    GPIO.output(heat_pin, False)


Attention, à moins de faire tourner ça avec un scheduler real-time, le time.sleep peut durer bien plus longtemps que prévu (et même avec un scheduler RT si les threads kernel ne sont pas préemptibles). Encore pire si la RAM est un peu pleine et que ça swappe...

Pour la pompe, c'est également logiciel, mais ça tourne plus vite car je demande au SSR de s'ouvrir ou de se fermer tous les 2 centièmes de seconde. En gros : je définis les pulsations à effectuer, dans les différents cas possibles :

Code:


pulse_sequence = [[0,0,0,0,0,0,0,0,0,0], # 0% power
                  [0,0,0,0,1,0,0,0,0,0], # 10%
                  [0,0,0,0,1,0,0,0,0,1], # 20%
                  [0,0,0,1,0,0,1,0,0,1], # 30%
                  [1,0,0,1,0,0,1,0,0,1], # 40%
                  [1,0,1,0,1,0,1,0,1,0], # 50%
                  [0,1,1,0,1,1,0,1,1,0], # 60%
                  [1,1,1,0,1,1,0,1,1,0], # 70%
                  [1,1,1,1,0,1,1,1,1,0], # 80%
                  [1,1,1,1,0,1,1,1,1,1], # 90%
                  [1,1,1,1,1,1,1,1,1,1]] # 100% power

def output_pump(pump_power):
    if pump_power < 0 or pump_power > 10:
        print "Error, choose pump_power between 0 and 10"
    else:
        pulses = pulse_sequence[pump_power]
        for i in range(0, 10):
            GPIO.output(pump_pin, pulses[i])
            time.sleep(.02) # wait 20 ms between pulses


Je peux dire une grosse bêtise, mais je pense qu'un PWM hardware regrouperait forcément les pulsations On en début de cycle et les pulsations Off en fin de cycle (ou inversement), mais ne les distribuerait pas uniformément. Je peux me tromper.

C'est bien le cas, pour chaque PWM il y a un RANGE et un DATA, le GPIO est high pendant DATA/RANGE cycles.

[Vous devez être inscrit et connecté pour voir ce lien]: merci pour l'info
(230^2 / valeur de la résistance < puissance max en Watts) => tu parles de la puissance max de la machine, ou bien de la pompe?
(j'ai l'impression que je vais cramer une résistance lol)

[Vous devez être inscrit et connecté pour voir ce lien]: cool un nouveau Raspbery-ien
j'ai hâte de voir ta prochaine création!

Bradlin a écrit:Attention, à moins de faire tourner ça avec un scheduler real-time, le time.sleep peut durer bien plus longtemps que prévu (et même avec un scheduler RT si les threads kernel ne sont pas préemptibles). Encore pire si la RAM est un peu pleine et que ça swappe...

d'accord avec toi, doubleshot peut éventuellement améliorer le comportement du PID avec un PWM (temps de chauffe plus stable et prédictif), mais peut être que la gestion par "sleep" suffit à son besoin, si ça marche bien comme ça?

[Vous devez être inscrit et connecté pour voir ce lien]: complètement d'accord sur l'idée que les time.sleep peuvent durer plus longtemps que prévu pour tout un tas de raisons liées à l'OS. Mais dans les faits, est-ce que c'est grave ? Même si le SSR de la chaudière reste On ou Off pour 1, 2 ou 3 cycles du courant alternatif que prévu parce que Linux décide que c'est le moment de swapper, on peut toujours rattraper le coup en chauffant plus ou moins par la suite ?

En fait j'avais un peu plus d'inquiétudes sur le contrôle de la pompe (que se passerait-il si un des "time.sleep(.02)" venait à s'éterniser un peu ?), mais le timing m'a l'air assez précis -- si je me fie à mes tests de débit et à mon oreille pendant les shots. Enfin, pour l'instant, on dirait que ça marche suffisamment bien... maintenant je croise les doigts...

Evidemment, ce n'est qu'une machine à espresso : je ne pense pas qu'on ait vraiment besoin d'un timing à la microseconde ou même à la milliseconde pour cette application -- et ce n'est pas non plus comme si des vies humaines en dépendaient !

[Vous devez être inscrit et connecté pour voir ce lien]: clairement, pour le contrôle de la chauffe on n'est pas à quelques millisecondes près, ça suffit bien.

[Vous devez être inscrit et connecté pour voir ce lien]: c'est sûr que ça ne va pas faire de grande différence dans ce cas-ci. En pratique, si tu n'as pas d'appli lourde qui tourne en même temps, il y a peu de chance que le sleep dure plus de quelques millisecondes que prévu...

Il faut juste y penser pour contrôler des éléments très critiques (ou pour implémenter un protocole de communication sur GPIO par exemple). Pour les besoins de précisions de l'ordre de quelques dizaines de nanosecondes, on peut "tricher" en faisant du DMA sur un PWM pour contrôler très finement le signal sans dépendre du CPU (mais ça rend les choses bien plus complexes).

@ doubleshot : non, je parle de la charge max que la résistance peut tolérer (avant de partir en fumée). Pour les petites resistance, on trouve souvent des valeurs entre 0.25 et 1W. Par exemple, si tu prends une résistance qui tolère 0.5W, elle pourra laisser passer jusqu'à 0.5W / 230V = 2mA. Donc une valeur supérieure à 150 kOhm (qui laissera passer 230V/150kOhm = 1.5mA) fera l'affaire et laissera un peu de marge. Je te conseille de faire une essai hors de ta machine avant, juste pour t'assurer qu'elle ne chauffe pas (et qu'elle n'explose pas...).

ok merci, j'avais en effet négligé ce petit détail

Je n'ai toujours pas tenu ma promesse de mettre mon script Python en ligne. J'aurais voulu le nettoyer un peu, mais au lieu de ça, j'ai continué à ajouter des fonctionnalités et à rendre le tout encore plus bordélique... J'en ai un peu honte, donc je préviens encore une fois : ça marche, mais c'est *très* moche ! Voilà le lien vers le repo:

[Vous devez être inscrit et connecté pour voir ce lien]

Et voilà une petite vidéo qui montre la Raspberry Pi à l'oeuvre, avec l'ajustement automatique du débit en temps réel :

waaaa toujours aussi top ton implémentation !

Reste plus qu'à intégrer les profils de température avec un robinet thermostatique piloté

Salut, j'aime beaucoup cette modification, je vais donc pousser un peu ma lecture… J'ai une oscar, je me demande dans quelle mesure cette implémentation est possible sur ma machine… C'est le coté volumétrique et flow control de la pompe qui m'hypnotisent !
C'est sur qu'ensuite, quitte à penser le truc globalement, une chaudière à HX sur PID, le coté volumétrique et autres implémentations, ça semble pas mal sur le papier ^^
Par contre, le hic, c'est que j'y connais rien dans ces p'tits automates ^^ (bon je commence à savoir ce que je fais avec Linux, et je suis plutot curieux donc je pense pas que ça soit impossible à apprendre, si [Vous devez être inscrit et connecté pour voir ce lien] ? )

Honnêtement, c'est pas hyper compliqué. Il y a énormément de resources disponibles en ligne sur la Raspberry Pi et Python pour commencer. C'est vrai aussi pour Arduino, mais la programmation se fait en C++, et je me suis dit que ce serait un peu galère et que je n'aurais pas la patience nécessaire... L'avantage de Python pour un débutant, c'est que tu peux devenir très vite opérationnel (ou à peu près). Si tu prends le problème pas à pas, tu peux facilement construire un truc chouette. Dans mon cas, j'ai commencé par essayer d'allumer deux LEDs (en me disant que ce seraient mes relais statiques pour la chaudière et la pompe) ; et puis, j'ai appris à exécuter des fonctions dès qu'on appuyait sur un bouton, à lire le capteur thermique, à créer des threads, à faire apparaître des éléments graphiques sur l'écran (à mon avis, c'est de loin le plus pénible) et en quelques semaines, j'avais un truc encore incomplet mais fonctionnel, prêt à être monté dans ma machine.

Bravo super boulot

Impressionnant

Ah ouais c'est super impressionnant ton système ! Bravo. Je pensais même pas que c'était possible ce genre de trucs. J'en profite pour te poser une petite question vu que tu me sembles la personne idéale pour y répondre, j'espère que ça t'embête pas (j'ai pas assez de messages pour passer par MP).

Prendre la température sur la chaudière ça marche bien pour savoir à quelle température sera le shot ? J'ai bien envie de mettre un thermocouple pour voir la température de ma gaggia afin de savoir quand y'aller pour mon shot, mais je sais pas trop où placer le capteur. La chaudière c'est l'idéal à ton avis ?