des veilleuses en céramique

C’est le moment de faire état ici d’un projet né de belles rencontres et qui rassemble des techniques très différentes réunies dans l’asso. Avec Isabelle on a cherché à faire des objets en terre capables de laisser passer la lumière, et on a réussi!
Petit récap’ technique des grandes étapes de notre année et sources du projet pour remercier l’équipe MakerSpace 56 de son soutien.

Cristaux en terre cuite

Je cherchais des exercices pour apprivoiser Inkscape, j’aime bien la géométrie et je sentais que les polyèdres nous aiderait à progresser dans notre quête. Nous avons donc mené des recherches sur des modèles “simples” de dodécaèdre et d’icosaèdre.

Ci-contre les premiers essais, cuits le 12 janvier dernier dans l’atelier d’Isabelle.
On commence par découper, plier et coller les patrons en carton.

liens vers les .inkscape des patrons géométriques

Dodécaèdre

Icosaèdre

La découpeuse laser nous permet d’ajouter facilement un motif complexe et unique à chaque itération de ces formes, ici avec de petites étoiles.
Ces petits morceaux coupés sont recollés sur le patron – puis la forme est pliée et assemblée à la main. Suivent aussi plusieurs étapes de ‘trempette’ où on habille notre moule de terre crue.

Après la première cuisson le papier a disparu. C’est l’état “biscuit”  de la terre  qu’il faut émailler et  recuire pour obtenir une pièce céramique. Tout un univers technique et un vocabulaire transmis par Isabelle dans son atelier.

Pour obtenir ce four étoilé “réussi” à la veille de la makerfaire de Nantes nous avons surmonté plusieurs surprises pendant 6 mois : explosions, déformations…

le prototype présenté à Nantes en juillet, à peine cuit et pas du tout construit!

La lumière

Inspirée par l’enseigne MakerSpace et les possibilités offertes par les LED RGB, j’avais quelques idées sur la façon d’allumer ces précieuses cloches géométriques.

Déjà, que chaque loupiotte puisse embarquer plusieurs ambiances lumineuses.

On a donc commencé à chercher avec Arduino, à poser quelques montages expérimentaux sur une carte UNO, d’abord avec des LED classiques puis avec les ‘neopixels’ et la bibliothèque d’Adafruit.

Au fil de nos recherches le dispositif évolue, plusieurs codes sont testés et assemblés pour aboutir à un résultat sympa.
À la veille de Noël Christophe trouve “la” solution et réunit plusieurs sources dans un code qui permet de passer d’un programme à l’autre: de l’arc en ciel au feu grégeois, de la lumière blanche à la veille éteinte sans heurter les limites de mémoire de notre carte miniature.

Voir le code Arduino


/**
* Arduino Uno - Veilleuse Diastem
* v. 1.0
* Copyright (C) 2016 Laure & Christophe Sivadier
*
* Code inspired by buttoncycler example from Adafruit_Neopixel
* Fire Effect by Robert Ulbricht http://www.arduinoslovakia.eu/blog/2015/9/simulacia-ohna?lang=en
* Drop Effect inspired by https://gist.github.com/suhajdab/9716028
*
* 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 <http://www.gnu.org/licenses/>.
*/


#include <Adafruit_NeoPixel.h>

#define BUTTON_PIN   2
#define PIN 0
#define Pixels 9 // 9 pour dodecaedre, 12 pour icosaedre
Adafruit_NeoPixel strip = Adafruit_NeoPixel(Pixels, PIN, NEO_GRB + NEO_KHZ800);

///////////////////
///////////////////
/////* SETUP */////
///////////////////
///////////////////

bool oldState = LOW;
bool active = HIGH;

float redStates[Pixels];
float blueStates[Pixels];
float greenStates[Pixels];
float fadeRate = 0.95;

void setup() {
pinMode(BUTTON_PIN, INPUT_PULLUP);
strip.begin();
strip.show();
}



///////////////////
///////////////////
/////* LOOP *//////
///////////////////
///////////////////

void loop() {
rainbow(100);
debounce();
rainbowCycle(50);
debounce();
fire(225, 70, 25); // Orange flame
debounce();
fire(158, 8, 148); // Purple flame
debounce();
fire(74, 150, 12); // Green flame
debounce();
fire(226, 15, 30); // Red flame
debounce();
drops();
debounce();
couleur(strip.Color(255, 255, 255), 50);
debounce();
couleur(strip.Color(0, 0, 0), 50);
debounce();
}


//******************
//******************
//****** VOID ******
//******************
//******************

////////////////////
////////////////////
/// SIMPLE COLOR ///
////////////////////
////////////////////

void couleur(uint32_t c, uint8_t wait) {
for(;;) {
for(uint8_t i=0; i<strip.numPixels(); i++) {
strip.setPixelColor(i, c);
strip.show();
delay(wait);
if(digitalRead(BUTTON_PIN) == active) {
return;
}
}
}
}


///////////////////
///////////////////
//// RAINBOW 1 ////
///////////////////
///////////////////

void rainbow(uint8_t wait) {
for(;;) {
for (uint16_t j = 0; j < 256; j++) {
for (uint8_t i = 0; i < strip.numPixels(); i++) {
strip.setPixelColor(i, Wheel((i + j) & 255));
}

strip.show();
delay(wait);

if(digitalRead(BUTTON_PIN) == active) {
return;
}
}
}
}


///////////////////
///////////////////
//// RAINBOW 2 ////
///////////////////
///////////////////

void rainbowCycle(uint8_t wait) {
for(;;) {
for(uint16_t j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
for(uint16_t i=0; i< strip.numPixels(); i++) {
strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
}
strip.show();
delay(wait);
if(digitalRead(BUTTON_PIN) == active) {
return;
}
}
}
}


///////////////////
///////////////////
////// DROPS //////
///////////////////
///////////////////

void drops(){

for(;;) {
for(int x=0; x<400; x++) {
if (random(20) == 1) {
uint8_t i = random(Pixels);
if (redStates[i] < 1 && greenStates[i] < 1 && blueStates[i] < 1) {
redStates[i] = 0; // random(256)
greenStates[i] = random(256);
blueStates[i] = random(256);
}
}

for(uint16_t l = 0; l < Pixels; l++) {
if (redStates[l] > 1 || greenStates[l] > 1 || blueStates[l] > 1) {
strip.setPixelColor(l, redStates[l], greenStates[l], blueStates[l]);

if (redStates[l] > 1) {
redStates[l] = redStates[l] * fadeRate;
}
else {
redStates[l] = 0;
}

if (greenStates[l] > 1) {
greenStates[l] = greenStates[l] * fadeRate;
}
else {
greenStates[l] = 0;
}

if (blueStates[l] > 1) {
blueStates[l] = blueStates[l] * fadeRate;
}
else {
blueStates[l] = 0;
}

}
else {
strip.setPixelColor(l, 0, 10, 10);
}
}
strip.show();
delay(35);
if(digitalRead(BUTTON_PIN) == active) {
return;
}

}
}
}


///////////////////
///////////////////
// FIRE  EFFECT ///
///////////////////
///////////////////
void fire(byte r, byte g, byte b){
for(;;) {
for(byte i=0; i<strip.numPixels(); i++) {

int flicker = random(0,55);
int r1 = r-flicker;
int g1 = g-flicker;
int b1 = b-flicker;
if(g1<0) g1=0;
if(r1<0) r1=0;
if(b1<0) b1=0;
strip.setPixelColor(i,r1,g1, b1);
}
strip.show();
delay(random(10,113));
if(digitalRead(BUTTON_PIN) == active) {
return;
}
}
}

//////////////////////
//////////////////////
/// RAINBOW WHEEL ////
//////////////////////
//////////////////////

uint32_t Wheel(byte WheelPos) {
WheelPos = 255 - WheelPos;
if(WheelPos < 85) {
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
if(WheelPos < 170) {
WheelPos -= 85;
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
WheelPos -= 170;
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}


////////////////////
////////////////////
////// BUTTON //////
////////////////////
////////////////////

void debounce() {
byte start = millis();
while(millis() - start < 20UL) {
if(digitalRead(BUTTON_PIN) == active) {
start = millis();
}
}
delay(500);
}

En effet pour miniaturiser le montage et obtenir un objet qui mette en valeur la céramique, on utilise la Digispark càd une Arduino ATTiny déjà reliée à un micro-usb pour la programmation et l’alimentation.

Le socle & l’objet

J’aimais bien l’idée du bouchon de liège, devenu un socle en bois découpé à la laser pour pouvoir contenir la carte électronique et les LED. L’idée aussi de les terminer avant Noël et de pouvoir les proposer en 2016.

Ci-dessus, les photos des différentes étapes pour arriver à notre v1: un socle de 16mm d’épaisseur (2*3 & 2*5mm) qui accueille la carte électronique  en laissant son port micro-usb et l’interrupteur “accessibles”, je veux dire tangents au bord du cylindre.

Après l’assemblage du socle on le ponce et on le peint à la bombe. Par coquetterie et pour souligner le caractère unique de ces objets on les repasse sous le laser pour graver une constellation différente à chacune…

Et voilà! Ces premières veilleuses céramiques et électroniques sont donc des lampes à cordon, branchées sur un adaptateur secteur – microUSB type chargeur de portable.

Améliorations possibles

On en est donc là. Pour une seconde génération d’objets on pourrait plancher sur différents points, liste à compléter de conseils et d’idées entendus cette année :

  • Protéger le port micro-USB du socle car on a constaté sa grande fragilité.
  • les faire en carbone plutôt qu’en céramique
  • Programme : que la veilleuse s’éteigne seule au bout d’un temps donné (25min par ex).
  • les faire en carton plutôt qu’en céramique
  • Vers une version mobile autonome (sans fil), peut-être avec une batterie type LIPO?
  • les faire en béton plutôt qu’en céramique
  • améliorer la jonction entre le socle et la cloche

😉 Rdv en 2018 pour voir où on en sera sur ce projet, d’ici là merci et…

…une merveilleuse et lumineuse année à tous!

Laisser un commentaire

Aller à la barre d’outils