Aller au contenu

VéLow

Dans un monde où la mobilité douce est en plein essor, les outils de génération d’énergie se multiplient. En effet les vélos électriques et plus particulièrement les vélos à moteurs électriques sont en capacité de produire de l’énergie tout autant qu’en consommer. L’objectif de ce chantier est de se concentrer sur l’aspect génération à l’arrêt de ces outils de mobilités.

Ce projet s’inscrit dans la recherche de la compagnie Organic Orchestra qui place sa philosophie créative en étroit lien avec les mobilités, les déplacements de leur tournée se faisant en effet en vélo. Cette mobilité est couplée avec un souci d’autonomie énergétique, conduisant le projet vers une tendance à l’autarcie énergétique. Aujourd’hui les moyens de recharger les batteries utiles à leurs spectacles sont des panneaux solaires couplés à différents blocs permettant la recharge ou simplement un adaptateur secteur. L’objectif de ces recherches est de donner un nouveau moyen de générer de l’énergie afin de charger les batteries mais également de sensibiliser et faire de la médiation autour de ces techniques.

Préambule & Matériel

Dans un premier temps nous éclairerons le matériel disponible afin de générer de l’énergie et résumerons la théorie de manière simplifiée afin de mieux appréhender le fonctionnement de cette génération. Tout d’abord nous disposons d’un vélo équipé d’un moteur OZO DD27 type Cargo sur la roue arrière. Ce moteur est alimenté par une batterie Li-ion 48V et 21Ah. Ces dispositifs proviennent d’un kit installé sur un vélo standard.

Le moteur nous offre des sorties cablées en Andersen. Les moteurs direct drive comme celui-ci sont des moteurs brushless sans engrenage. Le moteur est muni d’un bobinage dans lequel circule un champ électromagnétique qui permet la rotation du moteur autour de l’axe. La rotation du moteur se fait grâce au changement de polarité du bobinage. Pour cela, un moteur brushless dispose de 3 phases (fils VERT, BLEU et JAUNE) qui sont alimentées séquentiellement par le contrôleur. C’est ces phases qui nous intéresse car si elles peuvent etre controllées, elles sont également génératrice.

Ces 3 phases nous donne un courant alternatif qu’il faudra redresser. On utilise pour cela un pont de Diode. Ce système composé de 6 diodes permet de ne laisser passer que le courant positif ainsi on peut avoir un courant dit « continu » (en réalité ce pont de diode ne fait que redresser la tension). Généralement on filtre cette tension pour avoir un lissage en sortie pouvant etre utilisé par n’importe quel appareil en alimentation direct (en respectant les plages de tensions).

Références :

Premières expérimentations

Dans un premier temps il nous a fallu prendre note des plages de tensions fournies par le vélo en fonctionnement générateur.

Le schéma ci-dessus explique le procédé de test. Les valeurs obtenues sont indiquées dans le tableau suivant :

Après avoir pris en compte les plages de tension de notre vélo, nous avons acheté un module électronique réhausseur de tension. En effet on part d’une tension plutot faible pour pouvoir recharger une batterie à 54,6V (nos batterie de vélo sont des batteries de 48V). Ce réhausseur permet d’ajuster la tension d’entrée variable à une tension de sortie plus élevée et fixée. Le schéma ci-dessous présente l’organisation du système. Il est constitué par ordre, par le vélo, suivi d’un pont de diode redresseur, ensuite le step-up (réhausseur, symbolisé par les flèches bleues) et enfin la batterie. Nous plaçons également des Watt-mètre dans le circuit pour visualiser les échanges et s’assurer du bon fonctionnement du système. Nous commençons à pédaler, et voilà, la batterie se charge.

Réglage du Step-Up

Le réglage de la sortie du step-up doit s’effectuer au préalable. Pour cela on utilise un générateur de préférence continu non variable pour bien régler la sortie. Nous avons dans notre cas utilisé une alimentation de laboratoire (une pile pourrait suffire, ou meme directemen le vélo). En modifiant la valeur de sa tension nous avons pu vérifier que le step-up était bien calibré.

Génération d’énergie

Lors des essais avec la batterie en charge en sortie nous avons pu effectuer plusieurs mesures :

  • Vitesse 5 – Plateau 2 : 150W facile → MAX 300W

En réglant les potentiomètres sur le module de réhausseur on peut adapter la “difficulté” en faisant attention a ce que la LED rouge ne s’allume pas trop fort (indicateur de sur-intensité en entrée). Le potentiomètre à côté de la sortie gère la tension de sortie variable, celui du milieu gère l’intensité limite de la sortie. Nous avons également indiqué la difficulté de pédalage pour avoir une indication sur le couple (cette échelle est empirique et assez arbitraire).

La prochaine étape est de considérer plusieurs vélo en générateur de la manière suivante :

Dans le cadre du spectacle de la compagnie, ces stations de générations seront utilisées en médiation. L’idée est maintenant de pouvoir visualiser des valeurs importantes dans ce système. Notamment savoir en combien de temps sera chargé la batterie à un rythme de pédalage donné. Pour se faire nous allons développer un watt-mètre à l’aide d’une carte Arduino afin de récupérer des données et les afficher.

Affichage et Médiation

Après avoir testé et mis à l’épreuve le système, il était nécéssaire de construire un enrobage pour ce dispositif. Il a été réfléchi d’éclater les différents composants afin de mieux rendre compte de la chaine de génération d’énergie. On commence par fixer le pont diode sur le cadre arrière du vélo (à coté des freins) de manière à ne pas gener le pédalage. Ensuite le cable suit le cadre sur ce qu’à l’avant dans le Step-Up. Nous avons découpé des boites à la découpe laser afin de protéger le système.

L’idée est de rendre le système compréhensible et de pouvoir suivre les étapes de génération. De plus il est nécessaire de créer un afficheur ludique et ouvert. L’idée est de développer un système récupérant les données de tension et d’intensité afin de pouvoir allumer une bande de LEDs en fonction de l’intensité énergétique généré par le public. Ce système pourra également remplacé le Watt-Mètre utilisé.

Tout d’abord il faudra commencer par le plus simple, mesurer la tension. Pour cela nous allons faire appel à un pont diviseur de tension, un petit système électronique composé de deux resistances (ou deux groupes de resistances) permettant de diviser la tension. Les formules liés à ce système sont simple : V_out = V_in * (R_2)/(R_1+R_2).

Le schéma ci-dessus nous donne les indications nécessaires à sa compréhension. Nous prendrons alors la sortie de ce pont diviseur (situé entre les deux resistances) et la brancherons à une entrée « analogique » d’une carte Arduino. Dans notre cas nous utiliserons une carte Arduino Leonardo.

L’étape d’après consiste en l’utilisation d’un capteur d’intensité de courant. Nous avons besoin de cette information afin d’avoir la puissance par la suite (P = U*I). L’ACS712 est un capteur de courant fonctionnant sur le principe de l’effet Hall. En le mettant en série avec une source et une charge, on peut alors mesurer le courant avec la carte Arduino. L’objectif suivant est de brancher à notre système le système de LED. Cependant la carte Arduino ne permet pas d’alimenter ce genre de système. Il nous alors fallu utiliser une alimentation externe, celle-ci est un convertisseur DC-DC transformant une tension pouvant aller de 8 à 38V en 5V. Elle permet d’alimenter la carte Arduino ainsi que la bande LED. Le schéma de ce système ainsi finaliser est le suivant :

Une fois avoir soudé sur une petite carte vierge et brancher le tout, nous pouvons tester le système. Le système est très fonctionnel et est alimenté par la batterie lors des premiers tests. Une alimentation variable de labo est branchée au step-up précédemment décrit puis dans le système Arduino. Les tests ont ensuite été réalise avec le système complet de VéLow, c’est à dire :

1- Le pont de diode ;

2- Le step-up ;

3- Le watt-mètre maison ;

4- La batterie.

Ainsi plus on pédale et on génère de l’énergie, plus la barre led s’allumera. On peut également rajouté des modes supplémentaires si on veut que la barre n’agisse pas uniquement comme une jauge. Nous réalisons ainsi 2 systèmes complets avec deux vélos dans chaque système afin de faire s’affronter des équipes pour qui génèrera le plus d’énergie.

/*WattMetre pour VeLow
    WattMeter and LED strip visualization of Power
    Copyright (C) 2022  Organic Orchestra

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

//librairie pour la LED
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif


const int LED_Pin = 10;
const int ACS712_Pin = A2;
const int DiviseurPin = A0;


float vArduino = 0.0; //tension lue par la carte Arduino
float vActual = 0.0; //tension avant le pont diviseur
//valeurs des resistances
float R1 = 100000.0;
float R2 = 10000.0;
uint32_t rawValueRead= 0; //valeur lue brute
float sensitivity = 0.066; //sensibilite de l'acs712 30A
uint32_t adcValue= 0 ; //valeur lue brut
uint32_t offsetVoltage = 2500; //offset
uint32_t adcVoltage = 0; //valeur de tension lue
uint32_t currentValue = 0; //valeur de courant

float PowerValue =0;                          /* Initial calculation Power Value */
unsigned long startMillisPower;               /* start counting time for power */
unsigned long currentMillisPower;             /* current counting time for power */
const unsigned long periodPower = 1000;       // refresh every X seconds (in seconds) Default 1 = 1 second 

//Precision decimal pour l'affichage
int decimalPrecision = 2;  
uint32_t pixel_up = 0 ;
uint32_t last_pixel_up = 0 ;

uint32_t color[30]; //couleur des 30 LEDS
Adafruit_NeoPixel strip = Adafruit_NeoPixel(30, LED_Pin, NEO_GRB + NEO_KHZ800); //definition du ruban




void setup() {
  Serial.begin(9600); //pour lire les valeurs dans le moniteur serie
  startMillisPower = millis(); 
  //initialisation du ruban de LED
  strip.begin();
  strip.clear();
  strip.show(); 
  //definition des couleurs pour chaque LEDs, de vert à rouge
  uint32_t green = strip.Color(0,255,0);
  uint32_t red   = strip.Color(255,0,0);
   for( int i=0; i< strip.numPixels(); i++ ){
      color[i] = colorInterpolate( green, red, 30, i );
  }
}

void loop() {
  //strip.clear();
  
  //Voltage Value
  rawValueRead = analogRead(DiviseurPin);
  vArduino = (rawValueRead * 5) / 1024.0;
  vActual = vArduino / (R2/(R1+R2));
  Serial.print("\t Vdc = ");
  Serial.println(vActual);

  //Current Value
  unsigned int x=0;
  float AcsValue=0.0,Samples=0.0,AvgAcs=0.0,AcsValueF=0.0,Value=0.0;
  for (int x = 0; x < 100; x++){ //on compte 100 valeur
    AcsValue = analogRead(ACS712_Pin);     //lecture valeur 
    Samples = Samples + AcsValue;  //addition pour moyenne
  delay (3); // on laisse l'ADC se remettre a zero
  }
  AvgAcs=Samples/100.0; //moyenne des samples
  currentValue = (2.5 - (AvgAcs* (5.0 / 1024.0)) )/0.066; //calcul du courant

  Serial.print("\t Current = ");
  //Serial.println(currentValue*5); 
  Serial.println(currentValue); 

  //Watt Value
  currentMillisPower = millis();                          
  if (currentMillisPower - startMillisPower >= periodPower)
    {
      PowerValue = currentValue* vActual;
      Serial.print("\t P : " );
      Serial.print(PowerValue); 
      Serial.print(" W "); 
      startMillisPower = currentMillisPower ;                                                      
    }

  //affichage de la jauge sur les led
  pixel_up = map(PowerValue, 0, 70, 0, 30) ;
  for(int j=last_pixel_up; j <= pixel_up ; j++){
    strip.setPixelColor( j, color[j] );
  }
  for(int k=pixel_up+1 ; k<=30 ; k++){
     strip.setPixelColor(k,0);
  }
  strip.show();
  delay(5);
}

//permet d'interpoler une couleur par rapport a sa position sur le strip led
/*par exemple pour 30 led, on ira du vert au rouge 
et cela permet de creer une variation de couleur entre les 30 led
 */
uint32_t colorInterpolate( uint32_t fromColor, uint32_t toColor, uint16_t maxSteps, uint16_t position ){
  // fromColor
  uint8_t r = ( fromColor & ((uint32_t)0xFF << 16) ) >> 16;
  uint8_t g = ( fromColor & ((uint32_t)0xFF << 8) ) >> 8;
  uint8_t b = ( fromColor & ((uint32_t)0xFF) );
  // toColor
  uint8_t r2 = ( toColor & ((uint32_t)0xFF << 16) ) >> 16;
  uint8_t g2 = ( toColor & ((uint32_t)0xFF << 8) ) >> 8;
  uint8_t b2 = ( toColor & ((uint32_t)0xFF) );
  
  // Interpolate
  float ri = r - ( ((float)(r-r2)) /maxSteps * position);
  float gi = g - ( ((float)(g-g2)) /maxSteps * position);
  float bi = b - ( ((float)(b-b2)) /maxSteps * position);

  return strip.Color( (int)ri, (int)gi, (int)bi );
}