Powerbox für WS2812B LEDs

Aufgrund des fortwährenden Dranges ein Projekt mit WS2812B LEDs umzusetzen, kam mir die Idee, dass Bobby-Car meiner Tochter ein bisschen „aufzuhübschen“ 🙂
Ob Sinn oder Unsinn darf jeder selber entscheiden, aber es war ein tolles Projekt und ich konnte meine gesteckten Ziele erreichen.

Aufgabenstellung

Welche Aufgaben galt es also zu bewältigen?

  • Portable muss es sein
  • Auf Basis von Arduino
  • Einfache Steuerung
  • Versorgt durch vier AA Eneloop Batterien

Stückliste

BaugruppeAnzahlBeschreibungLinkEinzelpreis (Euro)Summe (Euro)
Powerbox13D gedrucktes Gehäuse3D-Druck--
1Arduino NanoGearbest-4,00
110V 330uf KondensatorBestand--
1300 Ohm Widerstand Bestand--
1Div. KabelBestand--
1LochrasterplatineGearbest-1,50
1Vierach AA BatteriehalterGearbest-1,00
1Ein-/AusschalterBestand--
1DrucktasterBestand--
2M3 x 5mm SchraubenBestand--

Gehäuse

So entstand das Gehäuse mittels Inventor und dem geliebten Messschieber.

Die STL-Dateien könnt ihr auf Thingiverse herunterladen.

Code

Innerhalb von Arduino 1.8.2 entstand folgender Code. Nichts weltbewegendes, aber es kann über einen Knopf über eine Case-Abfrage der Modus geändert werden. Aktuell habe ich mal 6 verschiedene Abfolgen umgesetzt.

/*
  Powerbox for WS2812B
  Schwabenpilot.de - Buddinski88
  Version 1.0
*/

#include <Adafruit_NeoPixel.h>

// Digital IO pin connected to the Push-Button
#define BUTTON_PIN   6

// Digital IO pin connected to the NeoPixels
#define PIXEL_PIN    2    

// Count of the connected NeoPixels
#define PIXEL_COUNT 66

// Informations from the Library
// Parameter 1 = number of pixels in strip,  neopixel stick has 8
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_RGB     Pixels are wired for RGB bitstream
//   NEO_GRB     Pixels are wired for GRB bitstream, correct for neopixel stick
//   NEO_KHZ400  400 KHz bitstream (e.g. FLORA pixels)
//   NEO_KHZ800  800 KHz bitstream (e.g. High Density LED strip), correct for neopixel stick
Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);

bool oldState = HIGH;
int showType = 0;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  strip.begin();
  strip.show(); // Initialize all NeoPixels to 'off'
}

void loop() {
  // Read current button state
  bool newState = digitalRead(BUTTON_PIN);

  // Check if state changed from high to low (button press)
  if (newState == LOW && oldState == HIGH) {
    // Short delay to debounce button
    delay(20);
    // Check if button is still low after debounce
    newState = digitalRead(BUTTON_PIN);
    if (newState == LOW) {
      showType++;
      if (showType > 9)
        showType=0;
      startShow(showType);
    }
  }

  // Set the last button state to the old state
  oldState = newState;
}

void startShow(int i) {
  switch(i){
    case 0: colorWipe(strip.Color(0, 0, 0), 50);    // Black/off
            break;
    case 1: colorWipe(strip.Color(241, 38, 205), 50);  // Pink
            break;
    case 2: theaterChase(strip.Color(127, 127, 127), 50); // White
            break;
    case 3: (50);
            break;        
    case 4: rainbow(20);
            break;
    case 5: rainbowCycle(20);
            break;

  }
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}

void rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256*10; j++) { // 10 cycles of all colors on wheel
    for(i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

// Theatre-style crawling lights.
void theaterChase(uint32_t c, uint8_t wait) {
  for (int j=0; j<10; j++) {  // do 10 cycles of chasing
    for (int q=0; q < 3; q++) {
      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, c);    //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        // turn every third pixel off
      }
    }
  }
}

// Theatre-style crawling lights with rainbow effect
void theaterChaseRainbow(uint8_t wait) {
  for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
    for (int q=0; q < 5 /*3*/; q++) {
      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, Wheel( (i+j) % 255));    // turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        // turn every third pixel off
      }
    }
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
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);
}

Endprodukt

Ein Schaltplan habe ich momentan keinen, aber wenn Bedarf besteht (Kommentare oder Kontaktforumular), dann werde ich diesen nachreichen. Mit Google findet man dazu aber genügend Anregungen.

Ausblick

Um die ganze Einheit wirklich unabhängig des Ortes verwenden zu können, habe ich bereits einige ESP8266 bestellt. Damit kann ich dann die Farben mittels App / Webinterface (da bin ich noch nicht sicher) steuern.
Außerdem werde ich das ganze noch etwas kompakter konstruieren um weniger Platz zu benötigen.

 

Baubericht „ZAL“ – Zinn-Dampfabzug Lötstation

Wer kennt es nicht? Die neuen ESCs wollen gelötet werden, die Lipos schreien nach neuen XT60 Steckern oder die Platine für das nächste Projekt will bestückt werden. Ich empfand die dabei entstehenden Dämpfe bisher nicht als störend, aber man liest immer wieder, dass diese giftig sind.
Ich bin bei meiner Recherche auf den Artikel von Hr. Dr. Bernhausen gestoßen. Beim durchlesen wurde mir auch klar, warum ich bei einer längeren Lötsession ein leichtes Kratzen im Hals verspürte und manchmal auch Kopfweh bekam.

Materialliste (BOM)

Einige Teile hatte ich bereits vorliegen und daher werden diese mit Bestand gekennzeichnet. Es sollte aber alles ohne weitere Probleme im Internet oder beim örtlichen Händler zu finden sein.

BaugruppeAnzahlBeschreibungLinkEinzelpreis (Euro)Summe (Euro)
Mechanik
1Grundplatte aus Holz 400 x 300 x 18 mmBestand-4,00
4Flexibler Wasser-/Öl-/Luftschlauch aus KunststoffAmazon-4,00
1Universal AktivkohlefilterAmazon-10,00
4KrokodilklemmenAmazon-3,20
4M3 x 40 mm SchraubenBestand--
2M3 x 20 mm SchraubenBestand--
4M2 x 5 mm SchraubenBestand--
4Holzschrauben 3x16 mmBestand--
6M3 SicherungsmutternBestand--
Elektrik
4ARCTIC F8 PWM PST LüfterAmazon7,9031,60
1Lochraster-Platine 70x50 mmBanggood-10,00
1Arduino Nano V3.0Amazon-3,40
10.96" OLED DisplayAmazon-10,00
1Mosfet IRLIZ44NBestand--
110K WiderstandBestand--
150K DrehpotentiometerBestand--
1DC-BuchseBestand--
112V 1A Netzteil (altes Festplattennetzteil)Bestand--
1Stifleisten für Arduino und OLED DisplayBestand--
Druckteile
4Abdeckungen / Halter für die SchläucheThingiverse--
1Gehäuse für ZAL BasisstationThingiverse--
1Deckel für Gehäuse ZAL BasisstationThingiverse--
1LüfterrahmenThingiverse--
1LüfterabdeckungThingiverse--
2Schaniere LüfterrahmenThingiverse--

Aufbau

Der Aufbau ist relativ einfach, wenn man sich die Bilder anschaut.

Ein paar Worte dazu:

  • Die Maße der Grundplatte kann nach Belieben angepasst werden.
  • Für die Befestigung habe ich verschiedene Varianten getestet. Am Besten funktionierte die Variante vier Löcher mit einem 12 mm Holzbohrer zu bohren und dort die Schläuche einzudrehen.
  • Die Gehäusemaße der ZAL Basisstation ist auf die unten erwähnte 70 x 50 mm Lochrasterplatine angepasst. Wenn das gedruckte Gehäuse vorliegt und die Platine eingelegt ist, ergeben sich daraus die Postionen der einzelnen Bauteile.

Druckdaten

Die Druckdaten gibt es auf Thingiverse. Sie wurden von mir mittels Inventor erstellt und bei Bedarf stelle ich auch die .ipt-Dateien zur Verfügung.

Steuereinheit / Platine

Die Platine ist ein erster Wurf und ich arbeite noch daran eine ätzbare Version zu erstellen, welche dann nur noch mit den Bauteilen bestückt werden muss.
Wer aber direkt schon mit dem Nachbauen beginnen möchte, der darf sich gerne an dem Platinenlayout, welches ich mittels Fritzing erstellt habe, bedienen.

Hinweis: Es müssen ein paar Löcher der Platine aufbebohrt werden. Das betrifft die DC-Buchse sowie das Potenziometer.

Lüftergehäuse

Das Lüftergehäuse ist relativ einfach aufgebaut und wichtig bleibt eigentlich nur zu erwähnen, dass ich die Lüfter mittels Kabelbindern verbunden habe.

Code

Zum Code möchte ich vorab direkt erwähnen das dieser nicht völlig aus meinen Händen stammte. Als Basis habe ich mich bei we-mod-it.com bedient. An dieser Stelle noch mal vielen Dank für dessen Bereitstellung! Meinerseits wurde der Code etwas angepasst um die Funktion zu grafischen Anzeige auf dem OLED-Display erweitert.

Ein paar Worte zu dem Code:

  • Bitte ladet die unten genannten Bibliotheken (Zeile 12-16), da es ansonsten zu Kompilierungsfehlern kommt.
  • In meiner Adafruit_SSD1306 Library habe ich das Bootlogo angepasst. Wer das ebenfalls machen möchte kann sich hier dazu belesen.
/*
  Zinn-Dampfabzug Lötstation
  Schwabenpilot.de - Buddinski88
  Version 1.0

  Basierend auf Scynd 2014
  Link: http://we-mod-it.com/board258-diy-do-it-yourself/
        board263-diy-how-to/board231-raspberry-arduino/
        2522-arduino-tutorial-4-l%C3%BCfterdrehzal-auslesen/

*/

// Bibliotheken einbinden
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Fonts/FreeSansBoldOblique9pt7b.h>

// Konstanten
const int FanPin = 9; // Fan PIN D9
const int PotiPin = A1 ; // Potenziometer PIN A1
const int TachoPin = 2; // Tacho PIN D2

// Fan Symbol normal
const unsigned char PROGMEM fan [] = {
  0x7F, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xCF, 0xE3, 0x87, 0xF3, 0xCF, 0x9F, 0xC1, 0xF3,
  0xFF, 0x1F, 0xC2, 0x7F, 0xFC, 0x0F, 0xC3, 0xBF, 0xF8, 0x07, 0xC3, 0xDF, 0xF7, 0x03, 0xC3, 0xEF,
  0xF7, 0xC3, 0xC7, 0xEF, 0xEF, 0xE3, 0xC7, 0xE7, 0xEF, 0xF7, 0xEF, 0xC7, 0xDF, 0xFF, 0xFF, 0x83,
  0xD9, 0xFF, 0xFF, 0x03, 0xC0, 0x3F, 0xFC, 0x03, 0xC0, 0x3F, 0xFC, 0x1F, 0xC0, 0x7F, 0xFC, 0x7F,
  0xC7, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFB, 0xDF, 0x9F, 0xF9, 0xFB,
  0xDF, 0x1F, 0xF0, 0x03, 0xEE, 0x1F, 0xF8, 0x07, 0xEC, 0x1E, 0x7C, 0x07, 0xF4, 0x3E, 0x7E, 0x0F,
  0xF0, 0x3E, 0x3F, 0xCF, 0xF8, 0x7E, 0x3F, 0xDF, 0xFC, 0x7E, 0x1F, 0xBF, 0xFE, 0x7E, 0x0E, 0x7F,
  0xCF, 0xBF, 0x05, 0xFB, 0xCF, 0xE3, 0x07, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFE
};

// Fan Symbol rotiert
const unsigned char PROGMEM fan_rotiert [] = {
  0x7F, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xCF, 0xD0, 0x47, 0xF3, 0xCF, 0xC0, 0xF9, 0xF3,
  0xFE, 0x60, 0xFC, 0x7F, 0xFD, 0xF8, 0x7C, 0x3F, 0xFB, 0xF8, 0x7C, 0x3F, 0xF7, 0xFC, 0x7C, 0x3F,
  0xF3, 0xFC, 0x7C, 0x2F, 0xE0, 0x7E, 0x78, 0x77, 0xE0, 0x1F, 0xF0, 0xFF, 0xC0, 0x1F, 0xF1, 0xFB,
  0xCB, 0x1F, 0xFB, 0xFB, 0xFF, 0xFF, 0xFF, 0xFB, 0xDF, 0xFF, 0xFF, 0xF3, 0xFF, 0xFF, 0xFF, 0x81,
  0xBF, 0xFF, 0xFC, 0x03, 0xDC, 0x3F, 0xFC, 0x03, 0xD8, 0x3F, 0xFE, 0x0B, 0xC0, 0x7F, 0xFF, 0xFB,
  0xE0, 0xFF, 0xFF, 0xFF, 0xE1, 0xFF, 0xEF, 0xFB, 0xE1, 0xF3, 0xC3, 0xF7, 0xF7, 0xE3, 0xE1, 0xEF,
  0xF7, 0xE1, 0xE0, 0x6F, 0xFB, 0xE3, 0xF0, 0x1F, 0xFC, 0xE1, 0xF8, 0x3F, 0xFF, 0x61, 0xFC, 0xFF,
  0xDF, 0xA1, 0xFD, 0xF3, 0xCF, 0xC0, 0xCF, 0xFB, 0xFF, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0xFF, 0xFE
};

// Variablen
int FanSpeed = 0; // Variable für die Lüftergeschwindigkeit
int FanMin = 50; // Minimaler PWM Wert für den Lüfter
int PotiVar = 0 ; // Variable zum speichern des Potentiometereingangs
int AbfrZeit = 500; // Zeitabstand für die Abfragen des Tachosignals
long TachoMillis = AbfrZeit; // Zeitabstand für Pulse Stretching Funktion
int DisplayAbfrZeit = 500; // Zeitabstand für die Abfragen des Tachosignals
long DisplayMillis = DisplayAbfrZeit; // Zeitabstand für Pulse Stretching Funktion
float RPS = 0; // Variable mit Kommastelle für die Berechnung der Umdrehungen pro Sekunde
int RPM = 0; // Variable für die gemittelte Drehzahl
float UmdrZeit = 0; // Variable mit Kommastelle für die Zeit pro Umdrehung des Lüfters
float FlankenZeit = 0; // Variable mit Kommastelle für die Zeit pro Puls des Lüfters
int FanSymbol = 0; // Entscheidung welches Symbol verwendet werden soll

// DIYMALL OLED spezifische Einstellungen
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

#define NUMFLAKES 10
#define XPOS 0
#define YPOS 1
#define DELTAY 2

#if (SSD1306_LCDHEIGHT != 64)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif


void setup() {
  // Einmaliger Aufruf
  TCCR1B = TCCR1B & 0b11111000 | 0x01; // Setzt Timer1 (Pin 9 und 10) auf 31300Hz
  Serial.begin(9600);
  //delay(3000);
  pinMode(FanPin, OUTPUT) ; //Setzt den Lüfter Pin als Ausgang
  pinMode(PotiPin, INPUT) ; //Setzt den LEDPin als Ausgang
  pinMode(TachoPin, INPUT); //Setzt den Tacho Pin als Eingang
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3D (for the 128x64)

  // Definiert die Schriftart
  display.setFont(&FreeSansBoldOblique9pt7b);

  // Bootlogo
  display.setRotation(2);
  display.display();
  delay(4000);

  // Leeren des Displays
  display.clearDisplay();
}

void loop() {
  // Mehrmaliger Aufruf

  // Liest das Potentiometer aus
  PotiVar = analogRead(PotiPin) ;
  // Verteilt den PWM Wert über den Messbereich des Potis
  FanSpeed = map(PotiVar, 50, 1023, FanMin, 255);

  // Unterer Potenziometerbereichs (0-50) = Lüfter aus
  if (PotiVar < 50) {
    FanSpeed = 0;
  }

  analogWrite(FanPin, FanSpeed); // Gibt die Variable mit PWM aus

  // Alle 2000ms pulse_stretch starten um die Drehzal auszulesen
  if ((millis() - TachoMillis) >= AbfrZeit) {
    pulse_stretch();
  }

  // Alle 1000ms pulse_stretch starten um die Drehzal auszulesen
  if ((millis() - DisplayMillis) >= DisplayAbfrZeit) {
    display_graphic();
  }

  display.display();

}


void pulse_stretch() {
  // Nur wenn PotiVar größer als 50 ist, wird die RPM ausgelesen
  if (PotiVar > 50) {
    // Den Lüfter konstant mit Strom versorgen damit das Tachosignal funktioniert
    analogWrite(FanPin, 255);
    // Abfrage der Zeit pro Puls in Mikrosekunden
    FlankenZeit = pulseIn(TachoPin, HIGH);
    // Setzt die Lüftergeschwindigkeit zurück
    analogWrite(FanPin, FanSpeed);
    // Berechnung der Zeit pro Umdrehung in Millisekunden
    UmdrZeit = ((FlankenZeit * 4) / 1000);
    // Umrechnung auf Umdrehungen pro Sekunde
    RPS = (1000 / UmdrZeit);
    // Umrechnung auf Umdrehungen pro Minute
    RPM = (RPS * 60);
    // Ausgabe der Drehzahl im Seriellen Monitor
    Serial.println(RPM);
    // Zeigt die Umdrehungen an
    display.setTextSize(2);
    display.setTextColor(WHITE);
    display.setCursor(0, 58);
    display.println(RPM);
  }
  // Wenn der Lüfter nicht angesteuert wird, schreibe Drehzahl 0
  else {
    // Drehzahl 0 in Seriellem Monitor ausgegeben
    Serial.println("0");

  }
  // Die TachoMillis werden aktualisiert um die nächsten 2000ms zählen zu können
  TachoMillis = millis();
}

// Funktion für das Display
void display_graphic() {
  // Leert das Display
  display.clearDisplay();

  // Zeigt statischen Text an
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 16);
  display.print("Drehzahl (rpm)");

  if (PotiVar > 50) {
    // Zeigt Umdrehungen an
    display.setTextSize(2);
    display.setTextColor(WHITE);
    display.setCursor(0, 58);
    display.println(RPM);
    // Entscheidung welches Symbol
    if (FanSymbol == 0) {
      //statisch
      display.drawBitmap(94, 30, fan, 32, 32, WHITE);
      FanSymbol = 1;
    } else {
      //rotiert
      display.drawBitmap(94, 30, fan_rotiert, 32, 32, WHITE);
      FanSymbol = 0;
    }
  } else {
    // Zeigt die Umdrehungen auf dem Display an
    display.setTextSize(2);
    display.setTextColor(WHITE);
    display.setCursor(0, 58);
    display.println("AUS");
    display.drawBitmap(94, 30, fan, 32, 32, WHITE);
  }
  display.display();
}

Ergebnis

Zum Schluss noch ein paar Bilder, welche die fertige Station zeigen und eigentlich bleibt mir nur zu sagen „Viel Spaß beim nachbauen!“.

Valentinstag Geschenk aus dem 3D Drucker

Ich habe zu Weihnachten ein DIY Kit für den Bau eines LED Herzes von meinem Kumpel Ossilampe bekommen. An dieser Stelle möchte ich mich noch mal dafür bedanken 🙂
Es hat viel Spaß gemacht das Kit zu löten und ein bisschen zu dokumentieren.

Damit war es dann aber nicht getan, denn ich hatte mir vorgenommen ein Gehäuse dafür zu konsturieren und dann auch entsprechen anzufertigen. Welcher Anlass bietet sich für ein LED Herz denn mehr an als der Valentinstag? Genau, keiner!

Ich begann also mit der Planung und der Konstruktion in CAD, damit ich die entsprechenden Teile drucken und auch fräsen konnte. Heraus kam folgendes Objekt und darauf bin ich sehr stolz, denn durch das Filament in Bronze Gold sowie die gefrästen Herzen aus Plexiglas, sieht das Endprodukt schon sehr edel aus.

Die Dateien und Informationen zum nachbauen findet ihr auf Thingiverse.

Neue Sicht auf den Prusa i3 MK2

Schon eine ganze Weile hat es mich gereizt meinem 3D Drucker ein Touch Display zu spendieren, aber irgendwie fand sich bis dato nichts passendes.
Bedingt dem Ableben meiner Raspberry PI V1 Kamera, welche an dem Raspberry PI 2 lief, war der Anstoß gegeben.

Es entstand also folgende Bestellung bei Amazon:

Da mittlerweile alles angekommen ist und es losgehen kann dokumentiere ich mal meine Schritte, denn es war nicht ganz so tivial, dass Display inkl. Touch Funktion sowie das TouchUI zum arbeiten zu bewegen.

Installation (ich setze gewisse Grundkenntnisse in Linux voraus, hier z.B. mal ein paar Basics)

  • Octopi installieren (z.B. mit Hilfe dieses Videos von Tom Sanladerer)
    • Expand Filesystem
    • Internationalisierung von Raspian respektive Octopi
    • Passwort des UNIX Benutzers pi neu vergeben
    • Raspberry Pi Kamera aktivieren
      • Diese vier Schritte kann man via Putty mit folgender Oberfläche anpassen
        sudo raspi-config
  • TouchUI über den Pluginmanager von Octopi installieren
  • Um den Touch Screen lauffähig zu bekommen bin ich nach folgender Anleitung vorgangen
    • Für das oben genannte Display muss das „Official Rapis Display“ in die xorg.conf eingetragen werden
    • Des Weitern musste ich den Kernel akutalisieren
    • Abschließend wurde noch der Touch Screen kalibriert
  • Damit die Kamera auch ihr volles Potenzial ausschöfpen kann habe ich mittels Putty noch folgende Schritte ausgeführt (hauptsächlich wird damit die Framerate angepasst)
    • cd /root/bin sudo nano webcamd 
    • Suche nach folgendem Inhalt: camera_raspi_options=“-fps 10″ 
    • Ich habe die Zeile wie folgt angepasst:camera_raspi_options=“-fps 30 -awb off -sh 50 -ex auto -quality 100″ 
    • Speichere die Datei mit STRG + O und dann STRG + X um nano zu beedenen
    • Reboot des Systems mit: sudo reboot 

Ich reiche die Tage noch Bilder des Aufbaus nach.

Ein Druckergehäuse für meinem Prusa i3 (Samelladrucker)

Ich möchte euch hier einen kleinen Baubericht meines neuen Druckergehäuses für den Samelladrucker zur Verfügung stellen

Anfangs habe ich mich auf dieses Gehäuse eingeschossen, aber mangels Werkzeug (keine Oberfräse im Zugriff) habe ich mich weiter umgeschaut und bin auf einen Ikeahack in Facebook gestoßen. Diese Hacks finde ich immer sehr interessant und ich steh wirklich darauf! Fragt meine Frau… Ikea lässt sich super hacken (z.B. bekam unsere Katze so ein Katzenklo, welches schön versteckt in einem Schrank untergebracht ist… aber zurück zum eigentlichen Thema!

Für den Hack benötigt ihr folgende Teile von Ikea:

Den Zusammenbau der einzelnen Schränke ist ganz Ikea like und daher gibts dazu nur ein paar Fotos.

Die erste kleine „Hürde“ war die Verbindung beider Schränke. Nach ein paar Gedanken kam ich auf die Idee zwei Multiplex-Platten zu besorgen und diese von oben bzw. unten an die Schränke zu schrauben.
Der Schritt ist auch wenig spektakulär, aber macht optisch einiges her und ich steh auf Multiplex Birke!

Um die ganze Sache dann auch noch halbwegs luftdicht zu verschließen musste ich mit etwas Silikon die einzelnen Fugen abdichten und das ganze trocknet dann bis zum nächsten Abend. Der erste „Bautag“ war somit abgeschlossen.

Am nächsten Abend durfte der Samelladrucker dann das erste Mal sein neues Heim betreten. Leider waren seine Füße etwas zu lange und so musste die Freundin Stichsäge ran.
Künftige Wartungsarbeiten sollten nicht stressig werden und daher wurden die notwendigen Kabel verlängert.

Filamentzufuhr ist das nächste Stichwort und dabei habe ich auch gleich die Türe angebracht.

Da ich die LED-Beleuchtung nicht einfach einbauen wollte wurde das erst mal getestet.

Die ganzen groben Arbeiten waren somit abgeschlossen und es ging weiter mit der Verkabelung des LCD Displays. Ich wollte dieses unbedingt aus dem Gehäuse haben! Nur so kann ich den Druckraum bei eventuell notwendigen Eingriffen geschlossen halten.
Ich bin schon etwas stolz darauf, dass gleich auf Anhieb alle Lötstellen gepasst haben, aber machen werde ich das nie wieder
Achso… gedruckt habe ich davor noch dieses schicke Gehäuse.

Es war mir wichtig eine gute Ausleuchtung im Druckraum zu haben und daher habe ich mir noch 8 Winkel ausgedruckt. Diese ermöglichen es die einzelnen LED Elemente in einem 45-Grad-Winkel in Mitte des Gehäuses abstrahlen zu können.

DAS WARS! Ich habe fertig! Hier steht jetzt mein neuer Schatz und arbeitet glücklich vor sich hin…