Introduction

Quand on travaille sur le logiciel libre, on finit, au bout d'un certain nombre d'années par se rendre compte que la masse de travail à achever est encore immense et qu'il manque sacrément de contributeurs pour tout faire.

C'est ce que je constate sur des projets comme QGIS: beaucoup d'utilisateurs ont des idées très intéressantes mais hélàs, même avec la meilleure volonté du monde, le flot des développeurs ne suffit pas à combler ces besoins. En conséquence, le projet voit s'amonceler un tas de nouvelles idées qui prennent du temps à être mises en place, fautes de moyens humains, les plages de développement s'allongent, il faut faire des choix, prioriser, etc.

Parfois cela peut même conduire à mettre en péril des pans entiers de sécurité comme ce fut le cas avec GnuPG il y a quelques années.

C'est que travailler sur du logiciel libre, ça prend du temps. Quand on fait ça sur son temps libre comme moi, le niveau de contribution est assez faible. Je me rends bien compte que les types qui sont payés pour faire ça sont bien plus productifs que mes petites heures glanées ici et là. D'ailleurs, on le voit à leur nombre de commits et aux messages de la mailing-list de développement.

Se pose finalement, la question du financement de tout ça ! Car, au delà de l'aspect éthique des choses, il faut bien que le développeur puisse vivre, pas forcément de son travail mais au moins subsister physiquement. En règle générale, les développeurs de logiciel libre sont loin d'être des golden boys avides de flouz. Leurs besoins sont donc très en deça des besoins du commun des mortels mais il leur faut un minimum quand même: de quoi satisfaire au moins les besoins indispensables à couvrir comme la bouffe, la flotte, un toît sur sa tête, un ordinateur pour coder, de quoi payer un peu d'électricité, un endroit pour pouvoir se focaliser, etc.

Si on veut des logiciels libres de qualité, il faut donc un moyen de rétribuer un minimum certains développeurs. On peut observer un peu tous les profils, du type payé pour le projet dans une SS2L ou un grand groupe comme RedHat, au type qui fait ça pour ses loisirs. Néanmoins, dans la tranche intérmédiaire, le besoin de €$ est visiblement indispensable, surtout quand les méthodes traditionnelles du financement de logiciel classique ne peuvent s'appliquer.

Après ce constat sévère, voyons maintenant comment je me suis mis à une plate-forme de financement de logiciel libre.

Comment je suis arrivé à tester Liberapay ?

Cela fait maintenant quelques années que j'essaye de rétribuer les projets libres que j'utilise au quotidien. Généralement, en début d'année, au moment des étrennes, je fais ma campagne de dons.

Mais, même en 2018, cette opération n'est pas si simple que ça. En effet, il y a un site de don par projet libre que j'utilise voire parfois, on ne peut pas faire de dons du tout. Il faut d'abord explorer les projets manuellement sur Internet, trouver la page de dons, étudier quels sont les moyens de paiement acceptés. Enfin, on peut passer à l'analyse des coûts en fonction de la devise utilisée, des frais bancaires, du mode de paiement (un virement SEPA dans l'Union Européenne ou par carte bancaire)...

L'ensemble requiert un peu de temps, surtout, si on veut faire les choses bien, c'est à dire en maximisant la quantité d'argent qui arrive dans la poche du ou des développeur(s) tout en minimisant les frais de gestion (car ce qu'on veut rémunérer, c'est le développeur, pas le type qui fait la transaction).

Pour autant, j'ai toujours eu un peu de méfiance vis à vis des acteurs du financement participatif qui font un peu la pluie et le beau temps. Ces startups du genre qui finissent toujours par mettre la clef sous la porte après s'être rendu compte que ça ne rapportait pas assez et pas assez vite et qui finissent par essayer de se faire du fric en revendant des données personnelles à "d'autres partenaires" ou en envoyant une floppée de spams pour te forcer à acheter leur ultime option qui tue.

Dans le courant du mois de novembre 2017, Patreon, qui est la plate-forme de financement continu d'un peu de tout la plus connue, a décidé de modifier unilatéralement ses conditions de rémunération. En résultat de ce changement, beaucoup de développeurs ont cherché d'autres moyens pour se financer. Comme en dehors de Patreon, tous les projets qui ont été lancés ont été exterminés à l'exception de Liberapay; ces developpeurs ont commence à faire un peu de pub pour Liberapay.

C'est le cas de Joey Hess, un ancien développeur Debian ultra-connu pour qui j'ai un profond respect (et je ne suis pas le seul d'ailleurs). J'ai lu son article de blog et ça m'a convaincu d'aller faire un tour sur Liberapay.

Les gens que je finance

J'ai décidé de porter mes dons à 100€ sur l'année. Ce n'est pas beaucoup mais c'est déjà un bon début. Voici les liens vers les personnes à qui je verse une modeste obole:

Qu'est-ce-qui est bien dans Liberapay ?

D'abord, le site web n'a aucune publicité et ça fait franchement du bien. Même mieux, le site n'utilise aucune ressource tierce: je n'ai aucun bloquage dans µBlock, ce qui est assez rare pour le souligner. C'est loin d'être le cas pour Patreon qui ne m'affiche pratiquement rien si je ne modifie pas ma configuration de µBlock.

  • Pas de spam après la création du compte.
  • C'est du logiciel libre.
  • Ça gère Libravatar, une alternative moins intrusive que Gravatar.
  • Ça semble léger en terme de technologie et du coup, c'est léger dans mon navigateur comparé à Patreon par exemple.
  • L'interface de traduction est WebLate, la solution libre de référence de traduction communautaire.
  • On se repère finalement assez bien.
  • Il existe des widgets pour indiquer sur son site combien on reçoit ou combien on donne.
  • Il y a une page de stats simple à comprendre, faite pour le long terme.

Quelques conseils pour donner

Pour ma part, j'ai toujours pensé qu'un virement SEPA était l'opération la moins chère pour effectuer un don d'argent au sein d'un pays de l'Union Européenne. Mais c'était sans compter sur les frais bancaires de ma banque qui me facture 3,3€ par virement ponctuel, en 2018, alors que je me tape toute la paperasse à écrire, attendre mon passage au guichet pour dépenser mon propre fric. 3,3€ sur un don de 50€, ça fait beaucoup ! On est à environ 7% de frais ce qui est énorme.

Donc, si vous avez une banque restée en 1918 comme la mienne, je vous invite à réaliser un achat de crédits plutôt par carte bancaire si vous êtes pressés, ce n'est pas si cher que ça.

Que manque-t-il à Liberapay ?

Parmi les seuls reproches que je peux faire à la plate-forme Liberapay, on trouve le manque de projets ou d'acteurs d'intérêt. En effet, point de Mozilla Foundation, de The Document Foundation, des développeurs emblématiques du Kernel Linux, idem pour Debian (même si ça commence à changer), etc.

Ce qui m'a fait adhérer (et donner), c'est principalement la présence de Joeyh Hess dont j'utilise un logiciel depuis près de 10 ans (ikiwiki, qui fait tourner ce site web d'ailleurs). S'il y avait d'autres projets phares, ça attirerait plus de monde sur le site. Comme ce dernier est plutôt pas trop mal fait, on pourrait alors utiliser ses fonctions d'exploration pour trouver autre chose que les projets très exposés.

Très clairement, le site manque de financeurs et les niveaux de rémunération sont quand même faibles même si la plate-forme brasse environ 10000€ par mois.

Ce qui serait vachement bien, ce serait de trouver les projets majeurs du logiciel libre sur Liberapay histoire que plus de gens puissent participer: des pans entiers de Debian avec des développeurs connus ou méritants (ou moins méritants mais ayant besoin d'un financement), des projets que j'utilise de Apache à BorgBackup en passant par Bind, Exim, Dovecot, Radicale, Roundcube, LibreOffice, archive.org, i3-wm, , Tor, i2pd, etc... et bien sûr QGIS !

Pour rester sur une note positive, on peut toutefois constater que les montants de financement ne font qu'augmenter, ce qui est une très bonne chose. C'est juste moins spectaculaire que sur d'autres plate-formes déjà bien implantées.

Une autre chose qui me manque, c'est de pouvoir m'adresser, via la plate-forme, aux personnes que je finance. Mon objectif est juste de leur donner une information, ce que j'aime dans leur projet, en quoi il me plaît et surtout les encourager à persévérer dans leur action. Néanmoins, je n'oublie pas aussi que les développeurs ont déjà de très nombreux moyens de récupérer cette information. C'est juste qu'on pourrait lier la rétribution avec des mots d'encouragement.

Maintenant, quand on fait un don, ce n'est pas pour demander quelquechose en retour, sinon ce n'est plus un don !

Conclusions

Sans être parfait, Liberapay se propose de financer le logiciel libre par le logiciel libre.

Le projet semble d'ailleurs assez résilient. Il n'a qu'un niveau de dépenses assez faible, qui doit être limité à quelques frais de gestion et d'hebergement. Si vous suivez l'actualité des sites de financement participatifs, vous vous rendez compte que la majorité, en dehors de Patreon a disparu, comme le défunt Gratipay.

Avec sa petite équipe limitée à 1 développeur qui ne gagne pas encore le SMIC avec la plate-forme, Liberapay fait quand même son bonhomme de chemin. Je pense que la sauce va prendre, il faut juste être patient et sans doute se concentrer un peu plus sur la communication ou sur la mise en communauté. Quelques "gros acteurs" pourraient apporter un nouveau flot de contributeurs.

Bien entendu, comme avec toutes ces plate-formes, ce qui fait le succès, c'est aussi la communication publique qu'on peut faire dessus. C'est chose faîte avec cet article.

Posted mar. 15 mai 2018 21:37:07 Tags:

Introduction

J'ai retrouvé une vieille eeprom que j'avais récupérée en desossant un viel écran CRT. C'est une LC21B de ST Microelectronics, plus précisément une ST24LC21B.

Je me suis dit que ça serait chouette de travailler un peu à une étude de son fonctionnement avec un arduino, ça fait bien longtemps que je n'ai pas utilisé ce dernier.

La datasheet de cette EEPROM montre qu'elle ne fait que 1Kbits soit 1024bits et non 1024 octets. La capacité de l'EEPROM est donc de 128 octets ce qui est très faible (mais mieux que rien).

A l'origine, cette EEPROM servait à stocker les paramètres VESA des moniteurs (sans doute les données d'EDID). Elle est donc principalement faite pour être lue via le câblage VGA par la carte graphique. Mais, à la base, c'est une EEPROM alors on peut mettre ce qu'on veut dedans.

Mais ce qui est sans doute plus important c'est qu'elle est capable de fonctionner via le BUS I2C. Ce sera donc un bon moyen de voir comment lire et écrire des bits via ce mode de communication avec l'Arduino.

I2C

I2C est un standard de communication sur deux fils créé par Philips. Il est utilisable par l'Arduino via la bibliothèque Wire que nous allons utiliser.

Pour résumer, I2C utilise deux ports analogiques spécifiques de votre Arduino. Ces deux ports correspondent aux port SDA (Serial Data) et SCL (Serial clock). Chaque "périphérique" I2C dispose d'une adresse (un peu comme une adresse MAC) et répond quand un maître (l'Arduino dans notre cas) y fait appel.

Après, on peut lui envoyer des commandes qui auront une signification propre au périphérique (une EEPROM n'a rien à voir avec un capteur de température par exemple). I2C s'occupe juste des communications, pas de la manière dont fonctionne le périphérique.

Branchements et spécifications

Sur l'Arduino

J'ai un vieil Arduino (un duemilanove) mais je constate que le dernier Arduino correspondant à la gamme (le Uno rev3) n'a pas trop évolué au niveau des grandes lignes des spécifications. On retrouve les mêmes composants, la même quantité de RAM, de Flash, de ports, etc.

Ce qui nous intéresse, cans notre cas, ce sont les ports de l'Arduino que nous allons utiliser pour la communication I2C:

  • Analog 4: SDA
  • Analog 5: SCL

Sur l'EEPROM

Nous avons les connexions suivantes:

  • VCC (+5v): 8
  • GND/VSS : 4
  • SDA: 5
  • SCL: 6
  • VCLK: 7

En lisant la doc de l'EEPROM, on se rend compte que VCLK est un port qui permet d'autoriser ou non l'écriture dans l'EEPROM. S'il est haut (5V), alors l'écriture est autorisée. Sinon, même en envoyant des ordres d'écriture, l'EEPROM ne vera pas son contenu modifié.

Par ailleurs, nous avons besoin de connaître l'adresse unique I2C de l'EEPROM. En consultant la documentation, on se rend compte qu'elle vaut 1010000x. Le x de la fin varie suivant le mode écriture/lecture de l'EEPROM. Ainsi, si vous souhaitez lire son contenu, il faudra s'adresser à 10100001 soit 0x51. Si vous souhaitez écrire dans l'EEPROM, il faudra s'adresser à 10100000 soit 0X50.

Schéma

Au final, voici l'aspect du schéma électronique (que j'ai réalisé avec Kicad):

Un schéma entre Arduino et ST24LC21B

En plus du fait de relier les bons ports entre l'Arduino et l'EEPROM, on trouve quelques composants en plus: * Les deux résistances en 4.7kOhms sur SDA et SCL sont des résistances de pull-up. Elles servent à maintenir l'état haut du bus lorsqu'il n'y a pas de communication, le tout avec un courant assez faible. * La résistance de 4.7kOhms sur VCLK sert à limiter le courant entrant sur le port numérique en sortie de l'Arduino. D'après les spécifications de l'EEPROM, le courant max (Icc) doit être de 2mA lorsque Vcc vaut 5V. Si vous faites un branchement en direct, certes, il y aura du 5V en sortie mais il n'y aura rien pour limiter le courant. Vous risquez donc d'envoyer un flux de courant d'environ 40mA (le max d'une sortie numérique d'un ATMega) ce qui grillera votre EEPROM. Si on prend la moitié de la valeur de Icc, soit 1mA, la valeur de résistance sera de R = U/I soit 5/0.001 soit 5kOhms. Mettre une troisième résistance de 4.7KOhms rentre dans les tolérances (on est à 1.06mA). Pour ma part, j'utilise le port numérique 13, ça porte chance !

En plus du schéma "théorique", voilà le schéma sur une breadboard, ça peut toujours servir pour le débutant:

Une vue de connexion entre Arduino et ST24LC21B

Code

Passons maintenant à la partie logicielle. Dans mon cas, j'ai réalisé une espèce de programme interactif qui permet d'envoyer des commandes à l'Arduino via le port série (qui passe par l'USB). Cela me permet de réaliser des opérations à la demande sur l'EEPROM.

Je me suis arrêté quand j'ai obtenu un résultat significatif: - Savoir lire le contenu complet de l'EEPROM. - Savoir écrire un octet à une adresse spécifique de l'EEPROM. - Exploiter la fonction d'écriture massive de l'EEPROM.

Voici à quoi ça ressemble:

/*
  Use an old ST24LC21B EEPROM with I2C to read and store values.
  I2C address for EEPROM:
  * 1010.0001 for reading: 0x51
  * 1010.0000 for writing: 0x50

  (c) 2018 by Médéric Ribreux
  ***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************
*/
// on inclut la bibliothèque Wire qui fait très bien son travail avec I2C.
#include <Wire.h>

/* Quelques constantes globales */
#define writeID 0x50 // L'adresse I2C d'écriture.
#define readID 0x51  // L'adresse I2C de lecture.
#define romSize 128  // La taille de l'EEPROM en bytes.
#define writePin 13  // Le port qui contrôle le mode écriture.

/* Variables globales */
byte addr = 0;
unsigned char eeprom[romSize]; // un tableau qui capture le contenu de l'EEPROM.
String command; // Une chaîne de caractères pour gérer nos commandes.

// Affecte ou non la protection en écriture via le port dédié
void setWriteProtection(bool state) {
  if (state == false) {
    digitalWrite(writePin, HIGH);
  }
  else {
   digitalWrite(writePin, LOW);
  }
}

// Sélectionne une adresse d'octet dans l'EEPROM (Random Access).
byte selectAddr(byte address) {
  byte state = 0;
  Wire.beginTransmission(writeID);
  Wire.write(address);
  state = Wire.endTransmission();
  return(state);
}

// Dump de l'EEPROM
void dump() {
  byte block = 0;
  byte status = 0;
  byte offset = 0;

  status = selectAddr(0x0);
  if (status!=0) {
    Serial.println("Problème d'adressage");
  }
  else {
    for(block=0;block<=4;block++) {
      Wire.requestFrom(readID, 32, true);
      while(Wire.available()) {
        eeprom[offset] = Wire.read();
        offset = offset + 1;
      }
    }
  }
}

// Test d'écriture
void writeInMemory(byte offset, byte value) {
  byte state = 0;
  // on lève la protection en écriture
  digitalWrite(writePin, HIGH);
  delay(500);
  // On se place à l'offset
  Wire.beginTransmission(writeID);
  Wire.write(offset);
  Wire.write(value);
  state = Wire.endTransmission(true);
  if (state != 0) {
    Serial.print("Erreur d'écriture: ");
    Serial.println(state, DEC);
  }
  // on remet la protection en écriture
  delay(500);
  digitalWrite(writePin, LOW);
}

// Écriture massive
void zeroMemory() {
  byte state = 0;
  byte page = 0;
  unsigned char theZero[8] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
  // on lève la protection en écriture
  digitalWrite(writePin, HIGH);
  delay(500);

  // On écrit séquentiellement
  for(page=0;page<=15;page++) {
    Wire.beginTransmission(writeID);
    Wire.write(page*8);
    Wire.write(theZero, 8);
    state = Wire.endTransmission(true);
    delay(100);
    if (state != 0) {
      Serial.print("Erreur d'écriture page: ");
      Serial.print(page);
      Serial.print(" :");
      Serial.println(state, DEC);
    }
  }
  // on remet la protection en écriture
  delay(500);
  digitalWrite(writePin, LOW);
}
// Configuration de l'Arduino
void setup() {
  pinMode(writePin, OUTPUT);
  setWriteProtection(true);
  Serial.begin(9600);
  Wire.begin(); // On lance le bus I2C
  Serial.println("\nI2C EEPROM Player");
  delay(5000);
}

// Fonction principale
void loop() {
  byte i = 0;
  //byte j = 0;

  // Un mode interactif
  if (Serial.available() > 0) {
    command = Serial.readStringUntil('\n');
    Serial.print("Your command:");
    Serial.println(command);
  }
  // On gère la signification du truc
  if (command.equals("dump")) {
    command = "";
    Serial.println("Dumping...");
    // On dumpe
    dump();
  }
  if (command.equals("print")) {
    Serial.println("Printing...");
    command = "";
    for(i=0;i<=127;i++) {
        Serial.print(eeprom[i], HEX);
        Serial.print("|");
    }
    Serial.println(" ");
  }
  if (command.equals("write")) {
    command = "";
    // on effectue une écriture de base
    Serial.println("Writing in EEPROM...");
    writeInMemory(0x9, 0xFE);
  }
  if (command.equals("flush")) {
    command = "";
    // on effectue une écriture de base
    Serial.println("Flushing data...");
    memset(eeprom,0,sizeof(eeprom));
  }
  if (command.equals("zero")) {
    command = "";
    // on effectue une écriture de base
    Serial.println("Zeroing memory...");
    zeroMemory();
  }
  delay(4000);
}

Compiler et mettre le code sur Arduino

En 2018, les bonnes recettes n'ont toujours pas changées: on a toujours besoin d'AVRdude et du paquet arduino-mk pour envoyer des choses vers l'Arduino.

Voici le Makefile que j'utilise:

# Makefile for lc21b
## Directories
ARDUINO_DIR   = /usr/share/arduino
ARDMK_DIR     = /usr/share/arduino
ARDUINO_LIBS  = Wire

## Arduino Board configuration
MCU          = atmega328p
F_CPU        = 16000000
ARDUINO_PORT = /dev/ttyUSB*

## Avrdude configuration
AVRDUDE_ARD_PROGRAMMER = arduino
AVRDUDE_ARD_BAUDRATE   = 57600

## Le nom de notre programme
TARGET        = lc21b

include /usr/share/arduino/Arduino.mk

Ensuite, un simple make suffit pour compiler le code. Pour l'upload, j'utilise make upload.

Utilisation

Ensuite, il faut voir ce que retourne l'Arduino par le port serial:

$ screen -L /dev/ttyUSB0

Vous pouvez ensuite taper vos commandes:

  • dump permet de capturer le contenu de l'EEPROM dans une variable.
  • print affiche la capture de l'EEPROM.
  • write écrit à l'adresse 0x9 la valeur FE (à vous de modifier cette valeur).
  • zero permet de mettre à zéro toute l'EEPROM.

Conclusions

Bon, j'ai bien aimé faire mumuse avec cette EEPROM. Ok, elle n'a pas beaucoup de stockage mais c'est parfait pour la lecture de données par l'Arduino qui n'a pas non plus beaucoup de mémoire. D'un point de vue didactique, c'est plutôt simple.

Bon, la bibliothèque Arduino fait vraiment bien son job: je n'ai jamais du lire les specs du protocole I2C ni faire d'opérations bas niveau pour exploiter le bus.

Bon, vous me direz que je suis bien avancé: je sais utiliser un circuit intégré qui n'est plus produit depuis au moins 10 ans. Mais sachez que le fonctionnement sera quasi-identique pour les derniers produits du moment. En effet, si je prends la M24C02, elle a pratiquement les mêmes spécifications et elles utilise les mêmes ports. Je peux substituer la ST24LCB1 de mon circuit par la M24C02 et tout marchera sans changer une virgule au code !

Ce qui est aussi dingue, c'est que cette EEPROM est assez ancienne. Je dirai qu'elle avait au moins 20 ans lors de la rédaction de cet article et les données dessus n'avaient pas bougé d'un poil de bit. Ce qui est encore plus dingue c'est que je l'ai déssoudée "à la main" pour la récupérer, avec tous les risques de surchauffe que ça comporte et qu'elle est parfaitement opérationnelle car j'arrive à tout lire et à tout écrire sans erreur.

En conclusion, je vous invite à désosser les circuits imprimés de vos rebus électroniques et à les conserver pour le futur. Ça peut toujours vous servir pour un circuit ou pour apprendre. Comme en plus vous n'aurez rien dépenser pour l'avoir, vous n'aurez pas trop de regrets lorsque, à la suite d'une mauvaise manipulation ou mauvais branchement, vous verrez un nuage de fumée en sortir !

PS: Ce composant est fait par ST Microelectronics, un vaillant fondeur de puces électroniques qui est français à l'origine. Cette multinationale embauche encore environ 10000 personnes en France. Souvent oubliée dans le monde de l'électronique qui présente souvent des acteurs américains, chinois ou japonais, ST est un acteur important de l'électronique qui emploie des vrais gens en France. Si vous avez de l'électronique à faire, je vous invite à utiliser les produits ST qui sont à la fois très bien faits, pas forcément chers à l'achat et qui profitent (un peu) à l'économie française !

Références

Posted sam. 26 mai 2018 17:29:25 Tags: