Si vous êtes un peu au courant de tout ce qui se passe dans le monde du DIY, vous avez peut-être entendu parler du pcDuino, concurrent direct du RaspberryPi. Certes, il n’a pas bénéficié du même effet d’annonce, mais pourtant il le mérite au moins autant. En effet, c’est une incroyable petite bestiole qui pousse le concept de mini-ordinateur hackable à souhait bien plus loin encore que le RasPi…

Trêve de bla-bla, voyons un peu à quoi ressemble l’engin:

Au programme:

• CPU: Cortex A8 cadencé à 1GHz
• GPU: OpenGL ES2.0, OpenVG 1.1 Mali 400 core
• 1Go de RAM
• Ports: HDMI, Ethernet, 3 ports USB
• Slot micro-SD (pour le stockage)

Déjà là, on sent bien que le Raspberry Pi a du souci à se faire! CPU beaucoup plus puissant, 1Go de RAM contre 256/512Mo…Mais attendez, ce n’est que le début!

La carte embarque une mémoire flash NAND de 2Go. Ca semble con comme ça, mais l’intérêt est avant tout d’y loger le système d’exploitation. Et oui, là où le Raspi charge l’OS en RAM à partir d’une carte SD, le pdDuino utilise une mémoire flash. Et là, croyez-moi, ça dépote. A titre d’info, le pcDuino effectue un reboot complet en 45 secondes. D’ailleurs, parlons-en de l’OS…

Le pcDuino est livré avec Ubuntu 12.10, mais il est possible d’y installer un Android Ice Cream Sandwich. Oui, vous avez bien lu. Ubuntu et Android. Je vous laisse imaginer la suite!

Bon, on est pas mal là quand même! Et si je vous dit que ce n’est pas fini? Si je vous dis en plus que le pcDuino est compatible avec la plupart des shields Arduino?

Elle est pas belle la vie?

Le pcDuino dispose en effet des quatres séries de pins d’un Arduino standard: les analog, les PWM, les TX/RX…et ça, c’est vraiment cool.

Maintenant, passons au travaux pratiques!

Première prise en main

Pour lancer la bestiole, rien de plus simple: clavier, souris, écran sur le HDMI, Ethernet, alimentation. Quelques secondes plus tard, tadaaaaa:

Petit test de Chrome:

Bon, visiblement ça fonctionne! Maintenant, il s’agit de configurer tout ce petit monde!

Configurer le clavier

Parce que le QWERTY ça va 5 minutes:

sudo dpkg-reconfigure keyboard-configuration

Si nécessaire, rebootez:

sudo reboot

Configurer SSH

Oui, ça peut aider, non? Cette partie est un basée sur cet article.

Tout d’abord, on se créé un utilisateur qu’on ajoute de suite au groupe admin, histoire d’avoir les droits qui vont bien et de pouvoir faire du sudo avec ce compte:

sudo su
adduser deabdird

puis:

adduser deadbird admin

Ensuite, récupérez votre adresse IP:

ifconfig

Installez le package SSH:

apt-get install ssh

Puis nano, un éditeur de texte en ligne de commande:

apt-get install nano

Le but est d’éditer un peu la conf de SSH pour le sécuriser un tout petit peu plus. Modifiez la ligne suivante:

PermitRootLogin yes

en

PermitRootLogin no

et ajoutez celle-ci:

AllowUsers deadbird

Ces changements permettent de n’autoriser que l’user que vous avez créé à se logger en SSH. Maintenant, rebootez et testez avec une autre machine.

Changer la résolution

Si comme moi vous brancher votre pcDuino sur un écran d’ordi avec un adapteur HDMI vers VGA, vous devriez avoir une résolution moisie. Mon but: avoir du 1280*1024. Changer la résolution d’affichage n’est pas une partie de plaisir, mais voici la manip, tirée du site the greathouses:

Tout d’abord, installez git, libusb et pkg-config:

sudo apt-get install git libusb-1.0.0-dev pkg-config

Ensuite, nous allons récupérer et compiler les sources de sunxi-tools, un programme permettant d’éditer le fichier evb.bin, où se trouve la configuration de l’affichage.

git clone https://github.com/linux-sunxi/sunxi-tools

cd sunxi-tools

make

Maintenant, il va nous falloir accéder à evb.bin, qui est stocké dans la partition de boot, plus précisément dans la mémoire flash de la carte:

sudo mount /dev/nanda /boot

Maintenant, vous avez accès à evb.bin:

ls /boot

Avant de modifier le fichier, faites-en une copie:

sudo cp /boot/evb.bin /boot/evb.bin.bak

Ensuite, décompilez le fichier evb.bin et faites-en un fichier:

./bin2fex /boot/evb.bin >evb.conf

Ouvrez-le avec nano.

Attention à ce que vous touchez dans ce fichier, il y a là de quoi cramer votre pcDuino!

A ce propos, di vous voulez vraiment mettre les mains dans le cambouis, allez donc voir le FEX Guide ici, vous y trouverez de quoi charcuter l’evb.bin. Mais encore une fois, attention…

Cherchez une section nommée “disp_init” (utilisez Ctrl+W pour chercher avec nano). Elle devrait ressembler à ceci:

[disp_init]
disp_init_enable = 1
disp_mode = 0
screen0_output_type = 3
screen0_output_mode = 5
screen1_output_type = 3
screen1_output_mode = 9
fb0_framebuffer_num = 2
fb0_format = 10
fb0_pixel_sequence = 0
fb0_scaler_mode_enable = 1
fb1_framebuffer_num = 2
fb1_format = 10
fb1_pixel_sequence = 0
fb1_scaler_mode_enable = 0

Modifiez la valeur de la variable “screen0_output_mode”:

Une fois les modifs enregistrées, transformez le fichier en un nouvel evb.bin:

sudo ./fex2bin evb.conf /boot/evb.bin

puis démontez la partition:

umount /boot

et redémarrez:

sudo reboot

Et là…croisez les doigts. Si ca ne fonctionne pas, recommencez la manip inverse ou restaurez l’evb.bin que vouz avez sauvegardé. Essayez d’autres résolutions jusqu’à tomber sur quelque chose de bien.

Si vous êtes comme moi, c’est à dire que vous aimez bien les plantes vertes, mais que vous avez la fâcheuse tendance à les oublier, rassurez vous, il n’y a pas que les cactus qui sont fait pour vous. Il est tout à fait possible d’avoir une vraie plante, sans avoir à configurer un reminder pour penser à l’arroser ! (Astuce : ça marche aussi si vous avez la fâcheuse habitude de trop les arroser, ou tout ce que vous voulez qui fait que votre plante verte dépérit en moins d’une semaine)

La liste des courses

Pour réaliser ce petit miracle, il vous faut un socle (ici à gauche, un morceau de plexiglas usiné avec une rainure qui va bien. Pratique mais pas obligatoire), une cloche en verre (après coups, celle là s’avère un peu petite), une plante verte pas trop capricieuse non plus et aimant bien les ambiances humides et/ou tropicales, et du silicone, pas obligatoire, mais c’est pour valider le concept.

Vous l’aurez deviné, l’idée est de reproduire le concept de l’écosphère, version plante verte. On met donc la plante verte (préalablement arrosée mais pas trop non plus) sous cloche, et on scelle le tout hermétiquement.
Le fonctionnement général est le suivant :
- en journée, la plante respire du co2 et produit de l’oxygène, et transpire de la vapeur d’eau.
- La vapeur d’eau se condense sur les parois, et est ré-absorbée par les racines
- La nuit, la plante consomme de l’oxygène et produit du CO2.

Pour les nutriments, c’est un peu la même idée : les poussent qui meurent sont décomposées et ré-assimilées pas la plante.

Pour ce qui est de la plante verte, je suis personnellement partis sur le genre Soleirolia : ça coûte pas cher, ça se trouve dans toutes les jardineries, et surtout les conseils de culture laissaient envisager de bons résultats : « Placez la plante à l’extérieur ou à l’intérieur dans une structure de type terrarium/paludarium avec beaucoup d’humidité atmosphérique pour une croissance optimale »Dernier avantage, elle rentrait dans ma cloche en verre qui s’est avérée être beaucoup plus petite en vrai que ce dont elle avais l’air sur les photos
Sinon, pourquoi le silicone ? S’il n’est en rien obligatoire, il présente deux avantages majeurs : Il permet de soulever la plante par la cloche et non par par le socle, ce qui évite quelques petites déconvenues, et rend les échanges intérieur/extérieur impossibles. Je suis donc sûr que la condensation proviens bien de la plante, ainsi que l’atmosphère qui n’est pas perturbé par le milieu ambiant.

Une « ecosphère » terrestre

Pour la conclusion, je n’ai pas posté l’article tout de suite, histoire de vérifier que la chose survivait un peu…. et pour le moment, ça se passe plutôt bien, elle est sous cloche depuis le 22 mars. Record à battre : 53 ans

Bon, si je me suis embêté à vous pondre une série d’articles sur la programmation AVR, c’est que j’avais une petite idée derrière la tête. En l’occurrence, j’avais besoin de pouvoir couper une alimentation embarquée dans un avion RC, bien sûr à distance.
L’idée était donc de réaliser un petit périphérique qui se connecte comme un servo-moteur standard de modélisme, mais qui active un relais en fonction de la valeur.

Déjà, il est important de savoir à quoi ressemble les signaux transmis par le récepteur RC aux servos :

Credit : http://nononux.free.fr

Bon, il s’agit d’une sorte de PWM, mais avec un champs très limité car allant de 5 à 10% de la valeur. Dans mon cas, je ne suis intéressé que par 2 cas : On ou Off. Je décide donc de couper à 50%, de manière à pouvoir utiliser le manche des gaz en guise d’interrupteur : de 0 à 50% je suis Off, de 50% à 100% je suis On.
A partir de là, il y a plusieurs façons de voir les choses : il est possible de régler ça en analogique pur, mais j’avais peur que ce soit trop sensible aux éventuelles perturbations. (Et dans mon cas, je préférerais que ce ne soit pas sensible ). Je suis donc partis sur la solution numérique pour traiter les impulsions.
Comme c’est pour embarquer dans un avion RC, il ne faut pas que ce soit lourd, donc j’ai choisi le micro-controlleur le plus petit possible, à savoir l’AtTiny85, que vous devez bien connaître désormais (voir ici, ici et ici), et qui plus est dans sa version CMS.

Le sch

Comme vous pouvez le constater sur le schéma ci-dessus, la partie électronique est réduite au strict minimum : Un régulateur de tension, pour fournir le 5v nécessaire à tout l’appareillage (servos, récepteur, etc…) dans le cas où l’on ne dispose pas de BEC (par exemple s’il n’y a pas de moteur). L’AtTiny85 dans sa configuration la plus simple (oscillateur interne), un mosfet pour piloter le relais, et le relais en lui même, petit relais 5v, capable de couper 175W quand même.
Le circuit a été réalisé sur un PCB de 0.8mm d’épaisseur, de manière, là encore à gagner du poids.

Vous l’aurez donc compris, dans ce montage, c’est le code qui fait tout le travail :

#include <avr/io.h>
#include <avr/interrupt.h>

//	   ___
//  PB5  *|+  |*  VCC
//  PB3  *|   |*  PB2
//  PB4  *|   |*  PB1   --> declenchement relais
//  GND  *|___|*  PB0   --> entrée PWM
//

volatile int count = 0; //le rapport cyclique
volatile int toff = 0;  //durée du signal à 0
volatile int ton = 0;	//durée du signal haut

int main(void)
{
	//configuration de la pin de sortie
	DDRB |= (1 << PORTB1); 	//on configure PB1 en tant que sortie
				//DDRB = Port B Data Direction Register

	//configuration du timer1 (Ton)
	TCCR0B |= (1 << CS00) | (1<<CS02); 	//Set up timer1 with prescaler 1/1024


	//configuration des interruptions
	GIMSK |= (1 << PCIE); 	//Enable pin change interrupt for PORTB 
				//GIMSK = General Interrupt Mask Register
				//PCIE = Pin Change Interrupt Enable

	PCMSK = (1 << PB0);  	//Enable pin change interrupt for PB0 (pcint0)
				//PCMSK = Pin Change Mask Register

	sei(); //mise en place des interrupts (set global interrupts)

	for(;;)
	{
		
		
		if(count>=7.5) //Si le rapport cyclique est > à 7 (Ton ~1.5ms)
		{
			PORTB |= (1 << PB1);
		}
		else
		{
			PORTB &= ~(1<<PB1);
		}
	}
}


ISR (PCINT0_vect) { //vecteur d'interruption
	if (PINB & (1<<PB0)) // detection de front montant
	{  
		
		toff = TCNT0; 	//Enregistrement de la valeur du timer Toff
		TCNT0 = 0;	//Réinitialisation du timer
	}
	else //detection de front descendant
	{
		ton = TCNT0;	//Enregistrement de la valeur du timer Ton
		TCNT0 = 0;	//Réinitialisation du timer
		if(toff)	//si on a déjà une valeur pour Toff
		{
			count = (ton*100L)/(ton+toff); //Le rapport cyclique = ton/(Ton+toff)
		}		
	}
} 

Voilà, il ne reste donc plus qu’à assembler tout ça, et à tester :

Le montage avec une led pour tester.

La chaîne complète, avec le récepteur

Et histoire de vérifier que tout fonctionne, une petite vidéo :

Voilà, un nouvel article prochainement pour vous faire voir l’utilisation réelle du bidule
Ps : c’est un kit que vous retrouverez sur la boutique

Point presse

Tout d'abord, un point people, l'information du développement de Bleuette à plutôt bien circulée et Bleuette s'est retrouvée sur plusieurs sites importants :

• Sur Hackaday : 3d printed hexapod robot
• Une introduction que j'ai écrite en anglais sur le blog officiel d'Ultimaker : Bleuette : A 3d printed hexapod robot made with Ultimaker !
• Sur le blog officiel Arduino : Bleuette, the hexapod robot

La vidéo sur Vimeo à été vue plus de 6000 fois.

Plutôt plaisant de voir que ça intéresse du monde mais j'attends avec grande impatience le moment ou un autre Bleuette pointera le bout de son nez en PLA...

Évolutions

Nouvelle carte fille

La shield Bleuette permet le pilotage des servos et le contrôle de la tension / courant consommé par les servos, pour pouvoir ajouter des capteurs multiples, il est tout à fait possible d'utiliser les broches libres des ports de l'Arduino mais il n'y en a pas assez pour tous les capteurs voulus sur Bleuette, du coup, le besoin d'une nouvelle carte d'extension s'est fait sentir et voici ce qu'elle permet :

• 8 entrées supplémentaires multiplexées utilisant que 4 entrées / sorties (3 d'adressage et une sortie)
• Connection pour une carte GY-27 contenant un accéléromètre et un compas
• Un module Bluetooth JY-MCU
• Une connection pour une guirlande de led RGB à base de LPD8806
• Un mosfet pour pouvoir piloter un élément de puissance (je ne sais pas vraiment quoi pour le moment...)

Voici le schéma de principe et le PCB associé (cliquez dessus pour agrandir) :

Le schéma de principe au format est Eagle se trouve par ici : sensor.sch et le PCB : sensor.brd

Comme vous pouvez le voir, le PCB n'est pas dense du tout, du coup, il est simple à réaliser avec des moyens modestes.

Mécanique

Pas de grande nouveauté pour la partie mécanique sauf pour les pieds, ces derniers ont été imprimés en PLA Flex permettant d'avoir un peu de souplesse et trempé dans du PlastiDip afin d'avoir un meilleur grip en plus d'un super rendu !

Avant trempage dans le PlastiDip et après :

Tous les éléments d'un pied de Bleuette, on aperçoit l'interrupteur poussoir, le piston et le cylindre et le pied recouvert de PlastiDip :

Le tout assemblé :

Le fichier source au format OpenSCAD des pieds de Bleuette est disponible, comme tout le reste de Bleuette sur GitHub / Bleuette.

Le cerveau

J'ai subi beaucoup de soucis avec la carte Arduino, notamment des problèmes de programmation, m'obligeant à recommencer la phase 3-4 fois de suite des fois...
Tous ces ennuis m'ont conduit à radicalement changer ma manière de développer avec Arduino, notamment en utilisant Ino, un outils en ligne de commande pour compiler, programmer, etc, bref, un remplaçant du mal aimé environnement par défaut d'Arduino.

Les problèmes de liaison avec la carte Leonardo m'ont également conduit à une solution radicale, j'ai embarqué un Raspberry Pi dans Bleuette auquel est relié la carte Leonardo, ainsi, c'est le Raspberry Pi qui programme la carte Arduino, ça complique un peu mais au moins, je suis moins gêné...

À force d'utiliser ce système, ce qui devait arriver arriva et j'ai donc décidé de créer une carte fille pour le Raspberry Pi qui permettra de piloter Bleuette directement avec cette dernière.
Bien entendu, je ne laisse pas tomber pour autant le dèveloppement sur Arduino, disons que celui ci sera la version simplifiée.

Bleuette embarquant un Raspberry Pi :

D'ici peu, je publierai un article expliquant toutes les caractéristiques de la carte d'extension pour Raspberry Pi.