Dimanche, septembre 14 2014

Régulation PID, comment la régler 1/2

Étant donné que je n’ai pas encore tout le matériel nécessaire pour avancer mes autres projets, j’en profite pour approfondir un peu mes connaissances théoriques et vous en fait donc profiter. Mon projet ici est simple : Réguler une température à l’aide d’un microcontrolleur, mais surtout bien comprendre les tenants et aboutissements des différents réglages et algorithmes. L’objectif ici n’est pas tant d’expliquer ce qu’est un PID, ni comment il fonctionne dans le detail, mais plutôt de donner une méthode permettant d’approximer les coefficients du régulateur.

Je profiterais de cette expérience pour faire 2 articles :
– celui-ci concernant le PID a proprement parler
– Un second article concernant ma méthode pour obtenir des courbes « lives » a partir d’un arduino et d’un PC.

Qu’es-ce qu’un PID

Pour simplifier, on parlera dans la suite de régulation de température, vu que ce sera notre application ici. Mais bien entendu, une régulation peut se faire sur tout type de process (vitesse, débit, etc…)

Lorsqu’on veut réguler la température (d’une pièce par exemple), l’idée la plus simple qui nous vient à l’esprit est de faire une régulation tout-ou-rien : on est en dessous d’un premier seuil, on allume la chauffe, on passe au dessus d’un second seuil on coupe la chauffe. Cette façon de procéder, bien que très simple à implémenter n’est pas exempte de défauts. Par exemple, la température ne sera jamais vraiment constante, même si elle l’est « en moyenne ». Selon le process, on peut arriver à fortement dépasser les consignes (dans un sens ou dans l’autre), en fonction de l’inertie du système, ce qui peut s’avérer nuisible selon ce qu’on veut faire. Enfin, la puissance du chauffage oscillera entre 0 et 100%, ce qui engendre une surconsommation non négligeable.

La régulation PID permet de coller « au plus juste » à la consigne, en évitant les dépassement (en fonction du réglage comme on le verra plus loin), et en n’utilisant que la puissance nécessaire à aller à la consigne et à la maintenir. Concrètement, dans PID, on a P pour Proportionnelle, D pour Dérivée, et I pour Intégrale. Si comme moi vous avez tendance à être un peu allergique aux maths, vous commencez déjà à vous sauver, mais en fait c’est moins compliqué que ça n’en a l’air.

Proportionnelle : c’est ni plus ni moins que la différence entre votre consigne et la valeur actuelle, multiplié par un coefficient de proportionnalité (Que vous définissez, cf la suite). Dans la suite, nous l’écrirons Kc.e(t)

Intégrale : A chaque mesure, vous allez avoir une différence avec la consigne (en plus ou en moins). Prenez cette erreur à chaque pas de temps, multipliez la par un (autre) coefficient de proportionnalité, et additionnez le résultat de tous les pas de temps depuis le début, et vous avez la fameuse composante Intégrale. Dans la suite, l’intégrale sera notée de la façon suivante :

I

 

Dérivée : Son rôle est de « freiner » l’augmentation de puissance calculée en fonction de P et de I, de manière à ne pas dépasser la consigne. C’est une façon de prendre en compte la vitesse d’évolution de notre process. Pour le calculer, vous faites erreur actuelle – erreur précédente, multiplié par un troisième coefficient de proportionnalité

La formule globale de notre régulateur PID peut donc s’écrire de la manière suivante (plus d’explications plus bas):

Formule PID, source ControlGuru

Formule PID, source ControlGuru

 

Description du materiel

Le montage utilisé pour ces essais est très simple : un arduino, un bouton 2 positions, 1 capteur de température (DS18B20), un mosfet (IRF540), une résistance 10Ω 5W, et une alimentation 12V. Le mosfet est piloté par une sortie PWM de l’arduino, et gère le courant (puissance) transitant dans la résistance. Cette dernière chauffe donc plus ou moins en fonction du ratio PWM (la tension change) envoyé par l’arduino. Le bouton 2 positions sert à passer d’une première consigne (valeur PWM 5 sur 255) à une seconde (valeur PWM 30 sur 255) Un petit programme python enregistre les valeurs dans un fichier texte sur le pc (via connection série), et j’utilise GnuPlot pour avoir une jolie courbe et pouvoir lire les valeurs des graphiques plus facilement que directement sur l’image. Par la suite, j’ai ameliore mon script python, de maniere a pouvoir saisir une consigne via le port serie, tout en continuant de logguer.

Montage régulation de température

Montage régulation de température. Attention, utiliser une résistance 5W mini !

Méthode de réglage

Je vous présente une méthode « graphique » directement tirée du site Control Guru, appliquée à mon montage de test. Ce site étant en anglais et très dense en informations, j’ai essayé de résumer les points essentiels ici. J’invite ceux qui voudraient approfondir le sujet à consulter ce site qui est une véritable mine d’information sur la régulation.

Définitions

  • PV : Process Variable, cela correspond à la grandeur mesurée que l’on veut influencer (la température dans cet exemple)
  • CO : Controller Output , la sortie de notre contrôleur en %. (Correspond à l’ouverture de la vanne par exemple)
  • Kp : Gain du process
  • Kc : Gain du contrôleur

Introduction

Une fois modélisé notre boucle de contrôle, nous allons pouvoir en déterminer les trois paramètres principaux par expérimentation, mesure et calcul (et oui…)

Les paramètres à déterminer sont :

  • Kp : la Gain du process, ou, dit autrement, le sens et la grandeur de la variation de la sortie
  • Tp : Constante de temps du process, ou la vitesse de variation quand le process a commencé à répondre
  • θp : (Prononcer Thêta P) Temps mort du process, ou le délai écoulé avant que le process commence à réagir
Boucle de contrôle

Boucle de contrôle

Afin de pouvoir déterminer nos trois paramètres, il va nous falloir mesurer la façon dont réagis notre système. La première étape consiste donc à fixer une première valeur de sortie à notre contrôleur (CO) et attendre que la variable de sortie (PV, ici la température) soit bien stabilisée.

Une fois cette dernière stable, nous allons modifier la valeur de sortie du contrôleur (CO), et mesurer le changement obtenu sur la variable de sortie (PV). On logue bien sûr tout ça dans un fichier, avec les pas de temps, de manière à pouvoir également déterminer le temps mort du process (θp) et la vitesse de variation (Tp).

On se sert ensuite de ces mesures pour tracer un joli graphique, qui nous servira à déterminer nos différentes valeurs.

La formule permettant de déterminer notre premier paramètre Kc, qui est à la base du calcul de nos 3 paramètres (cf. formule) est la suivante :

source : controlguru

source : controlguru

pour déterminer Kc, nous devons donc commencer par déterminer différentes variables intermédiaires.

Calcul de Kp

Kp décrit le sens et de combien va évoluer PV, en fonction d’un changement de consigne (CO) Le cacul de Kp est assez simple : Kp=ΔPV/ΔCO ou en d’autre termes Kp = (différence en PV initial et PV final)/(différence entre consigne initiale et finale)

Sur mon prototype, j’ai modifié la consigne initiale (1,96%) pour une nouvelle consigne à 11.76%, voici la courbe obtenue:

Graphique test du système.

Graphique test du système.

En appliquant la formule ci-dessus, on a donc Kp = (79-40)/(11,76-1,96) = 39/9.8 = 3.98°C/%

Détermination de la constante de temps Tp

Tp représente le « en combien de temps » le système va réagir. En partant du même graphique, on va déterminer quand l’état de sortie vaut 63% de δPV, à partir du moment où le système à déjà commencé à réagir (et pas à partir du moment où on a modifié la consigne. Pour ceux qui se demandent d’où sort les 63%, vous trouverez toutes les explications (attention, maths !) dans ce pdf Fichier:Derive63rule.pdf On regarde donc le nombre de secondes écoulées lorsqu’on arrive à 63% de δPV (ici 39*0.63 + 40 = 64.6°C), et le nombre de secondes écoulées au moment où le système commence à réagir (très rapide ici)

Détermination de la constante de temps TP

Détermination de la constante de temps Tp

On obtiens donc Tp = 172 secondes.

Le cas de θp

θp représente le temps mort avant réaction. Dans une boucle de contrôle, il n’est jamais très bon d’avoir du temps mort, et il sera nécessaire d’avoir cette valeur la plus faible possible. Du fait de mon montage de test, le temps mort est ici très réduit. Ceci s’explique facilement par la position du capteur (sur la résistance), et par le faible volume à chauffer (uniquement la résistance. De manière assez intuitive, on imagine très bien que plus le volume à chauffer sera important, plus le temps mort sera long, pour une même puissance de chauffe.

Si on reprend le graphique ci-dessus, on vois que la consigne a été modifié à T1=195s, et j’ai décider de compter le début de la réaction à T2=198s. On a donc θp = T2 – T1 = 198 – 195 = 3s.

Il est intéressant de noter ici que mon échantillonnage étant d’une seconde, la valeur de θp peut être sensiblement erronée, du fait de sa faible durée dans ce cas.

Application à un modèle PID

Formule PID, source ControlGuru

Formule PID, source ControlGuru

Avec:

  • CO = Sortie du contrôleur (Controller Output)
  • CObias = biais du contrôleur, ou valeur nulle.
  • e(T) = Erreur actuelle, définie par SP – PV
  • SP = consigne (Set Point)
  • PV = valeur actuelle du process (Process Value)
  • Kc = Gain du controlleur, un paramètre de réglage
  • Ti = reset time, un paramètre de réglage
  • Td = derivative time, un paramètre de réglage

Calcul du gain et du reset time

Il faut tout d’abord se demander si notre process accepte un dépassement de consigne ou pas, ainsi que la vitesse à laquelle ce process doit réagir.

  • Si on accepte un dépassement, on peut choisir un réglage agressif, et donc un faible temps de réponse (petit Tc). Dans ce cas, Tc est le plus grand de 0.1Tp ou 0.8θp
  • Modéré, le contrôleur produira peu ou pas de dépassement. Dans ce cas, Tc est le plus grand de 1.Tp ou 8.θP
  • Conservateur, le contrôleur ne produira pas de dépassement, mais ira doucement, Tc sera le plus grand de 10.Tp ou 80.θP

Une fois décidé du comportement de notre contrôleur, et calculé Tc, on peut calculer le gain du contrôleur et le reset time grâce à la formule suivante :

source : controlguru

source : controlguru

Pour mon application, je vais choisir un comportement modéré. Tc sera donc la plus grande valeur de 1.Tp ou 8.θP (1×172 ou 8*3=24). On retiendra donc Tc = 172.

J’obtiens donc Kc = (1/3.98)*(172/(3+172)) = 0.25%/°C et Ti = 172

Je peux maintenant calculer mes deux principaux paramètres P et I :
P = Kc = 0.25
I=Kc/Ti. = 0.25/172 = 0.00145
Reste à déterminer D. la formule permettant de déterminer D est Kc.Td, avec Td = (Tp.θP)/(2Tp+θP) = (172*3)/(344+3) = 1.487. D vaut donc 0.25*1.487=0.372
D = 0.372

Mise en application

Reste maintenant à confronter les calculs à la réalité. Voici le code Arduino que j’ai utilisé pour effectuer mes tests :

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);
DeviceAddress insideThermometer;

unsigned long lastTime;
double Input, Output, Setpoint;
double ITerm, lastInput;
double kp, ki, kd;
int sampleTime = 1000; //1 sec
double outMin, outMax;
String cmd = String("");
double tfirst = 0;

float printTemperature(DeviceAddress deviceAddress)
{
  sensors.getAddress(insideThermometer, 0);
  float tempC = sensors.getTempC(deviceAddress);
  Serial.print(tempC);
  Serial.print(" ");
  Serial.print(Output);
  Serial.print(" ");
  Serial.println(Setpoint);
  return(tempC);
}

void compute()
{
  unsigned long now = millis();
  int timeChange = (now-lastTime);
  if(timeChange>=sampleTime)
    {
      //get the new input value
      Input = getInput();
      //compute all working error variables
      double error = Setpoint - Input;
      ITerm+=(ki * error);
      if(ITerm>outMax) ITerm = outMax;
      else if(ITerm < outMin) ITerm = outMin;
      double dInput = (Input - lastInput);
      
      //compute PID output
      Output = kp * error + ITerm - kd * dInput;
      if(Output > outMax) Output = outMax;
      else if(Output < outMin) Output = outMin;
      
      //remember some variables for next round
      lastInput = Input;
      lastTime = now;
    }
}

void setTunings(double Kp, double Ki, double Kd)
{
  double sampleTimeInSec = ((double)sampleTime)/1000;
  kp = Kp;
  ki = Ki * sampleTimeInSec;
  kd = Kd / sampleTimeInSec;
}

void setSampleTime(int NewSampleTime)
{
  if (NewSampleTime>0)
  {
    double ratio = (double)NewSampleTime / (double)sampleTime;
    
    ki *= ratio;
    kd /= ratio;
    sampleTime = (unsigned long)NewSampleTime;
  }
}

void setOutputLimits(double Min, double Max)
{
  if(Min > Max) return;
  outMin = Min;
  outMax = Max;
  
  if(Output > outMax) Output = outMax;
  else if (Output < outMin) Output = outMin;
  
  if(ITerm>outMax) ITerm = outMax;
  else if(ITerm<outMin) ITerm = outMin;
}

double getInput(void)
{
  sensors.setResolution(insideThermometer, 9);
  sensors.requestTemperatures(); // Send the command to get temperatures
  return printTemperature(insideThermometer);
}

void setup()
{
  Serial.begin(9600);
  pinMode(3, OUTPUT);
  Setpoint = 0; //on fixe 0 de consigne
  double P, I, D;
  P = 0.25;
  I = 0.00145;
  D = 0.372;
  int STime = 1000;
  setTunings(P,I,D);
  setSampleTime(STime);
  setOutputLimits(0, 255);
}

void loop(){
compute();
analogWrite(3,Output);
if (Serial.available() > 0) {
      char SerialInByte;
      SerialInByte = Serial.read();
      
      if(SerialInByte==13){
        Setpoint = cmd.toInt();
        cmd = String("");
      }
      else
      {
        cmd += String(SerialInByte);
      }
  }
}

et voici le résultat :

Test des paramètres PID calculés

Test des paramètres PID calculés

Conclusion :

J’ai utilisé des paramètres « conservateurs » afin d’éviter de dépasser la consigne. On peut voir qu’effectivement la consigne n’est jamais dépassée, au prix d’une montée en charge un peu lente. En partant sur cette bonne base, il est maintenant facile d’affiner si l’on souhaite quelque chose d’un peu plus réactif, il reste de la marge de manœuvre.

Sources :

La régulation étant un vaste domaine, j’ai trouvé beaucoup d’informations pertinentes sur les deux sites suivants. Si vous n’êtes pas anglophobe, et désirez approfondir le sujet, je vous les recommandes chaudement !
ControlGuru
brettbeauregard.com, auteur d’osPID

Vendredi, septembre 12 2014

[DIY] Table basse et matrices de leds – Partie 2

Bonjour tout le monde !

Ça y est, ma table basse est vivante !
(enfin, pas au sens propre bien sûr)

Il reste encore quelques petites finitions à réaliser, un petit coup de papier de verre sur les angles par exemple, mais l’ensemble donne déjà un résultat très satisfaisant !

Je vous laisse juger par vous-même ;)

Les perçages pour les fils

DSCF3265

Vous remarquerez que j’ai utilisé de la (sainte) colle chaude (amen) pour éviter aux câbles une décapitation lente et douloureuse.

Résultat final sans les matrices

DSCF3267

Le dessous avec l’électronique et l’alimentation

DSCF3271

NB Je vais devoir faire une nouvelle version du contrôleur de matrices avec les connecteurs pour les manettes de SNES et des trous de fixation (c’est pratique les trous de fixation …).
En attendant, le contrôleur pend en dessous de la table … ça fera l’affaire pour le moment.

Résultat final avec les matrices

DSCF3273

It’s alive !

DSCF3288

(J’ai toujours pas trouvé de moyen de faire des photos claires en filmant un truc lumineux … je suis pas doué en photo …)

Test de charge

DSCF3291

Toutes les leds à pleine puissance, soit 8 ampères au total, et rien ne sent le brûlé. Test validé ! :)
Lunettes de soleil conseillées, ces matrices sont vraiment très lumineuses.


Classé dans:projet Tagged: diy, leds, madeinfr, matrices, table basse

Mardi, septembre 9 2014

[DIY] Table basse et matrices de leds – Partie 1

Bonjour tout le monde !

Il y a déjà quelques mois maintenant, j’avais dans l’idée un projet assez sympa de table basse intégrant des matrices de leds RGB.
L’idée (pour faire simple) est d’avoir une table basse sur laquelle il est possible de jouer à des mini jeux (en pixel art) tout en buvant un verre.

Avec tous mes problèmes de temps libres et de météo (cela fait presque 3 mois maintenant qu’il pleut tous les jours dans ma région, c’est super), je n’avais pas pu avancer sur ce projet.
Mais les choses ont évolué, voici donc la première partie de mon aventure dans le monde salissant de la menuiserie ;)

Le commencement

DSCF2996

Une table basse c’est quoi ? Un plateau, 4 côtés et 4 pieds.
Sur le papier ça à l’air assez simple à faire … ou pas.

En début de mois d’août, j’avais fait une première tentative pour réaliser le corps en bois de la table basse.
Effectivement sur le papier c’est simple. Mais en réalité, ça ne l’est pas vraiment.

La table basse fait 50cm de côté et comporte au centre un évidemment de 32cm de côté pour les matrices.
Avec un peu de calcul mental, on arrive facilement à déterminer les dimensions de chacune des pièces de bois.

DSCF3091

Les matrices faisant 26mm de haut (avec les pieds de fixation), j’avais choisi pour ma première tentative de faire un sandwich de 3 couches de bois d’épaisseur 10mm (soit 30mm au total).

Les deux couches inférieures sont de simples planches de bois mises bout à bout.
Le dessus n’est quant à lui qu’un simple cadre en bois de 9cm de large (9 + 9 + 32 = 50cm) avec des angles à 45° pour faire plus jolis.

Sur le papier, la découpe des pièces de bois semble aussi simple que de sortir la scie à disques de son placard.
Mais vous vous en doutez, les choses ne se sont pas vraiment passées comme prévu.

Première tentative, premiers ratés

DSCF3094

Pour commencer, les angles à 45° n’étaient finalement pas vraiment à 45°.
Sur le coup, je n’avais pas vu le problème, mais après collage il y avait clairement un problème, et un gros.

J’ai donc coupé une planche de test, sorti le rapporteur et regardé l’angle réel : environ 43°.
Conclusion : ma scie ne coupe pas droit. Pire, même les coupes à 90° ne sont pas vraiment à 90° …
Comme on dit, à vouloir faire des économies sur le matériel ça finit toujours mal.

DSCF3097

Mais le problème d’angles pas vraiment à 45° n’est qu’esthétique.

Le vrai problème concerne le collage, que j’ai (il faut l’avouer) un peu beaucoup foiré.
Conséquence : certains angles de la couche du dessus (celle visible) ont rebiqué et ne sont donc pas alignés avec la surface des autres angles …
Impossible donc de poser une plaque de plexiglas par dessus sans qu’elle dépasse par endroit ou bouge quand on appuie sur l’angle opposé.

Mais ce n’est pas encore le pire …

DSCF3099

Durant le collage (enfin, durant le serrage post-collage pour être précis) la couche du milieu a bougé.

Les côtés ne sont donc pas lisses. Et il est donc impossible de coller les planches des côtés.
J’aurai pu rattraper le coup, mais avec tous les autres problèmes j’ai préféré reprendre mes plans et changer de solution.

Sky-wood 2, le retour. Ça va scier !

DSCF3109

Pour la deuxième tentative, j’ai décidé de travailler avec deux couches de bois seulement : une grosse couche de soutien, d’épaisseur 18mm et une petite couche (visible) de 10mm par dessus.
La couche du dessus aura toujours des angles à 45° (pour faire jolie), mais coupé avec une autre scie.

DSCF3111

J’ai donc sorti ma plus belle planche de sapin, la scie linéaire et …

DSCF3105

… en moins d’une journée, le plus gros des découpes était fait.

Au passage mon "coin menuiserie" est passé de ça :

DSCF3101

À ça :

DSCF3122

Et sur cette photo, j’avais déjà ramassé/aspiré un bon paquet de sciure ;)

DSCF3105

Bref, une fois la montagne de sciure dehors, j’ai pu commencer l’assemblage de la table basse.

DSCF3153

J’ai tout d’abord commencé par rassembler toutes les pièces de bois.

À savoir :
– la planche de fond (50x50cm) qui sert de support rigide à l’ensemble (en dessous des autres pièces de bois sur la photo),
– les 4 côtés (à gauche),
– les 4 pieds (au centre),
– les 4 morceaux du plateau supérieur (à droite),
– les 4 morceaux de bois servant de soutien au plateau supérieur (en haut).
Le reste du bois n’est rien d’autre que de simples cales et équerres pour rigidifier un peu le tout.

PS Je travaille quasiment dans le noir. Il fait tellement mauvais dehors que j’ai eu besoin d’installer des lampes de chantier pour pouvoir faire les photos …
C’est pour cela que les photos ont l’air sombres et jaunâtres. Pour toute réclamation, merci de vous adresser à météo France ;)

Assemblage à blanc

On est loin d’un meuble en kit, mais l’assemblage n’est pas vraiment compliqué.
C’est juste de la colle, beaucoup de colle même, et des serres cadres.

DSCF3159

Tout commence par les côtés en bois qui avec l’aide de deux serres-cadres font tenir l’ensemble en attendant le collage final.

DSCF3163

Viennent ensuite, 4 cales qui seront retirées une fois la colle sèche pour maintenir à la bonne hauteur le reste du montage.

DSCF3165

Par-dessus les cales vient se poser le fond servant de support rigide.

DSCF3169

Fond immédiatement suivi de deux feuilles d’acier d’épaisseur 0.5mm qui permettront aux pieds magnétiques des matrices de leds de tenir en place.

DSCF3170

Par-dessus tout ce petit monde vient se placer les supports de soutien pour le plateau supérieur.

DSCF3175

Remarque : Vous remarquerez la découpe un peu bizarre sur les angles, c’est volontaire.
J’avais besoin d’un petit millimètre de marge pour placer les matrices, mais j’avais aussi besoin de pile-poil 9cm pour pouvoir agencer et coller correctement les supports.
Du coup, j’ai fait une découpe incomplète sur les bords pour avoir mes 9cm et ma marge en même temps.

DSCF3179

Par dessus les supports viennent alors se placer les morceaux du plateau supérieur (avec de vrais angles à 45° cette fois-ci).

DSCF3181

Et pour finir une petite plaque de plexiglas qui protégera le bois des verres humides et autres cadavres de cacahuètes traînant sur la table.

La suite ?

DSCF3184

Il faudra attendre encore un peu pour la suite, la colle a du mal à prendre avec l’humidité ambiante.
J’utilise une colle vinylique qui date un peu et qui mériterait de prendre sa retraite …

Une fois la colle sèche, il restera à faire un peu de finition au papier de verre, quelques perçages pour les câbles et l’assemble de l’électronique.

"To be continued" ;)


Classé dans:projet Tagged: diy, leds, madeinfr, matrices, table basse

Vendredi, août 22 2014

Des bricoles en 3D réelle -1-

  • Je vais faire quelques photos pour chaque trucs potable que j'imprime.

Voici une première série !

dsc00112.jpg Un boitier pour le raspberry pi en PLA gris.
J'ai dû élargir à la lime et au cutter la fente pour passer la nappe GPIO.
Défaut de conception, pour cet objet téléchargé ici : http://www.thingiverse.com/thing:47776

dsc00111.jpg dsc00117.jpg


dsc00114.jpg Un boitier pour le second Raspberry pi, en PLA gris.
L'ordinateur est ici présenté sur le dos, car il y a la possibilité de passer des vis pour le fixer au mur.
dsc00113.jpg dsc00115.jpg
À télécharger ici : http://www.thingiverse.com/thing:30843


dsc00121.jpg dsc00120.jpg dsc00119.jpg

Un support en ABS bleu, pour transformer ma mini perceuse en perceuse à colonne, bien pratique pour percer des circuits imprimés électronique.

Car jusqu'à présent je faisais ça les deux coudes bien calés sur la table les mains jointes tenant fermement la perceuse.

dsc00122.jpg dsc00118.jpg

Le trou de blocage pour la roue dentée est perfectible, car trop grand pour empêcher la rotation de l'écrou que j'ai dû noyer dans la colle; mais ça fait l'affaire, à voir ici : http://www.thingiverse.com/thing:144333





Jeudi, août 21 2014

Un cyclone pour l’aspirateur

Voilà un petit bricolage simple qui vous permettra de disposer d’un cyclone sur votre aspirateur de chantier et ainsi vous pourrez aspirer gravats et sciure sans utiliser de sac !

Il vous faudra un tube PVC de 100mm et un de 40mm d’une longeur d’environ 50cm chacun. Un bouchon pour le tube de 100mm (le mien est découpé dans une plaque de MDF) et un réducteur 100/40mm.

Pour récupérer les poussières il faut un sceau étanche et résistant. Si comme moi il s’écrase avec la pression vous pourrez le renforcer avec un croisillion en bois.

 

Le cyclone
Le cyclone

Le séparateur
Le séparateur
Prise d'aspiration
Prise d’aspiration
Insertion sur la tangente
Insertion sur la tangente
Le tube de 40mm au centre
Le tube de 40mm au centre
Les mesures
Les mesures
Contre l'écrasement de la cuve
Contre l’écrasement de la cuve
Le renfort du couvercle
Le renfort du couvercle
Supprimer les inserts
Supprimer les inserts
Le réducteur
Le réducteur

Le résultat est visible dans la vidéo :)

Je n’ai pas inventé grand chose, je me suis inspiré de cet article

Samedi, août 16 2014

Une Borne d'Arcade maison, petite touche déco

  • Même si je ne suis pas satisfait de la déco du chapeau de la borne à cause des ratés que j'évoquais plus tôt, il restait les artwork side à poser, ces deux bandes marquées « Astro City », habituellement imprimées en vinyle autocolant.

J'aurais pu faire comme beaucoup, les commander sur le web auprès d'un imprimeur, mais j'avais des craintes quant au collage du vinyle… Genre qu'adviendrait-il de la peinture en cas de décollement volontaire, histoire de changer la déco ?
C'est que la peinture m'a donné tant de travail que j'étais flippé à l'idée de la ruiner d'une manière ou d'une autre, tôt ou tard…
Du coup, j'avais laissé tombé, en attendant le jour où ?

Et bien, où j'ai eu l'idée qui va bien ^^

Satisfait de l'essai réalisé sur le sticker « insert coin » j'ai décidé d'appliquer la même méthode, cependant améliorée pour ces grandes surfaces que sont les sides.

  • La technique est simple !
  1. Imprimer (laser conseillée) en mode miroir la déco sur une feuille de plastique transparent.
  2. La découper soigneusement au cutter.
  3. L'enduire de colle bâton (côté encre donc).
  4. L’apposer sur la borne, presser et frotter fortement.

Les sides imprimé sur un A3 en deux morceaux chacun[1], puis découpés :
dsc00082.jpg dsc00084.jpg

dsc00085.jpg dsc00087.jpg Premier essai…

Pour une petite surface donc tout va bien, l'étalage de colle étant facile à rendre uniforme, mais ici vu la taille des bandes sides, j'ai pu constater avec effrois que les traces d'application de la colle étaient bien visible et ne disparaissaient pas au séchage !

Qu'à ce la ne tienne, décollage facile et nettoyage à l'eau, et on recommence…
Tiens… à l'eau, hum… Mais oui !!

J'ai donc amélioré le point N°3, en diluant des morceaux de colle dans un peu d'eau, que j'ai ensuite appliqué au pinceau brosse.

Une fois la bande de plastique appliquée, on voit des flaques d'eau gluante se former, ainsi que des bulles, qu'il suffit alors de chasser en frottant énergiquement à l'aide d'un chiffon.

C'est assez long, mais on peut surveiller le bon déroulement des opérations, car non seulement il y a les zones transparentes du plastique, mais aussi les endroits pas bien collés qui ne font pas apparaître la même teinte aux couleurs.

  • Voila ^__^

dsc00086.jpg dsc00089.jpg

Note

[1] À télécharger ci-dessous

Dimanche, août 3 2014

Fabrication d'un vélo Cargo - Etape 1 : Le chassis

Bonjour à tous, je me suis mis en tête de fabriquer avec un ami un vélo Cargo (Cargo Bike, Triporteur, ...). J'utilise de plus en plus le vélo et c'est vrai que ce n'est pas toujours pratique pour aller faire les courses, aller faire un pic-nic.... Plusieurs solutions: remorque, tricycle, cargo 3 roues, cargo 2 roues... J'ai choisi le cargo 3 roues car j'ai récupéré un vieux VTT qui se prête bien à la transformation.
J'ai toujours eu envie d'apprendre à souder à l'arc donc, ça tombe bien.






Ce n'est pas si facile....Ce que j'ai retenu de mon expérience de soudure:

- toujours bien préparer les surfaces (meulage, dégraissage),
- caler au maximum les pièces, car au moment de la soudure, tout a tendance à bouger et à se tordre avec la chaleur
- souder toujours à plat ou en descendant, jamais en montant,
- toujours des épaisseurs du même ordre de grandeur (pour les tubes, il m'est parfois arrivé de doubler leur épaisseurs en mettant un autre bout de tube à l'intérieur pour éviter qu'il perce pendant la soudure. C'est une super astuce), et les baguettes adaptées


Le châssis est entièrement fait avec des tubes acier de 25mm de diamètre (2 mm d'épaisseur) et du plat de 35x4mm.


Voici le détail des pièces:


Vous pouvez remarquer que nous avons écrasé et plié les tubes afin de faciliter les soudures.

Pour le calage avant la soudure, il faut être imaginatif. J'ai utilisé une tige filetée avec rondelles et écrous pour bien positionner les fixations des roues. J'ai oublié de prendre en photo cette étape mais je vous la montre sur un autre projet similaire:




Voici aussi une photo sur le doublage de tube (pas utilisé sur ce projet mais très utile quand on veut souder un tube en bout sur un plat ou sur une tôle):



 Et pour finir, une autre photo du châssis:




Je vous donne rendez-vous pour la suite du projet: le cadre.
Ce sera certainement prêt pour la semaine prochaine

A+


Vendredi, août 1 2014

RaspiO'Mix ou GrovePi ?

On m'a demandé par courriel quelles étaient les différences entre le RaspiO'Mix et la carte GrovePi et j'ai pensé qu'il serait intéressant d'en faire un article...et je vais tâcher de faire un effort pour rester objectif, promis !

raspiomixvsgrovepi.png

Tout comme RaspiO'Mix, GrovePi vous permet de connecter vos modules Grove à votre Raspberry, même finalité mais choix technique différent : là ou RaspiO'Mix utilise directement les entrées / sorties du Raspberry, GrovePi utilise en fait un ATMega jouant le rôle d'intermédaire entre le Raspberry et le monde extérieur via une liaison I2C.

L'avantage pour l'un, c'est que GrovePi utilise moins d'entrées / sorties et du coup, vous pouvez les utiliser pour autre chose, l'inconvénient, c'est qu'on ne les pilote par directement, supprimant certaines fonctionnalités des IO du PI.

RaspiO'Mix fait office d'interface direct entre le Raspberry et le monde extérieur, vous pouvez donc utiliser des lignes de commandes, du Python, ce que vous voulez sans avoir à passer par une librairie spécialisée, en gros, pour faire cours, vous n'avez pas besoin d'utiliser un drivers contrairement à GrovePi.

Détails sur le mapping des ports : RaspiO'Mix et GrovePi.

Fonctionnalité GrovePi RaspiO'Mix
Entrées / Sorties 7 4
Entrées analogiques 3 4
Résolution CAN 10bits 18bits
Lignes I2C 4 2
Lignes série 1 1
Horloge Non Oui (via DS1307) avec batterie de sauvegarde
Interrupteur 0 2
Alimentation via le Raspberry via le Raspberry ou une prise jack / bornier

Flag_of_France.svg.png
Autre chose importante, les RaspiO'Mix sont fabriquées en France !

oshw-logo-100-px.png
Dans les 2 cas, GrovePi et RaspiO'Mix sont des projets OpenSource et OpenHardware et vous pouvez retrouver toutes les sources sur GitHub : GitHub / GrovePi et GitHub / RaspiO'Mix

Les cartes RaspiO'Mix devraient être disponible dans des boutiques en ligne mais en attendant, si vous en voulez une, contactez moi directement !

- page 1 de 38