Elch zu Weihnachten

24. Oktober 202314. Dezember 2019 von Sören

Der Elch als Weihnachtsschmuck ist ein kleines Projekt, welches mit einem Arduino Uno oder Klone, einer LED mit Vorwiderstand und einem kleinen Servo auskommt. Die Besonderheit liegt darin, dass der Elch mit dem USB-Kabel, mit dem er über die Arduino IDE programmiert wird, mit dem PC verbunden bleibt. Dann wird das Python3-Skript Elch_1.py gestartet, welches im aktuellen Verzeichnis die Datei Elch.png benötigt. Zwischen dem PC und dem Arduino wird nun eine serielle Verbindung aufgebaut, die als Beispiel für eine fehlertolerante und besonders zuverlässige serielle Datenübertragung herangezogen werden kann.

Jetzt kann man wunderschön ein Setup für den Elch finden, welches einem besonders gefällt: Man schaltet die Automatik aus, fährt den Kopf in die gewünschte obere Position und speichert diese ab und macht dasselbe mit der unteren Position. Anschließend werden noch die Nickfrequenz des Kopfes und die Blinkfrequenz der LED eingestellt. Wer will kann auch im Stillstand einfach nur die Helligkeit der LED regeln. Wenn alles gespeichert ist, dann läuft der Elch auch ohne das Python Skript mit jeder USB-Stromversorgung oder einem Arduino Uno geeigneten Netzteil.

Damit eine serielle Verbindung zustande kommt, muss immer zuerst der Elch eingesteckt sein und dann das Python Skript gestartet werden.

Elch_Bauteile_Schaltung

weihnachtsElch.ino

#include <Servo.h>
#include <EEPROM.h>
#include <float.h>

#include "prg.h"

static Servo gelenk;
static constexpr int gelenkPin = 2, nosePin = 3, keyPin = 4;
static unsigned long lastMillis;
static struct {
  int microSecondsTop, microSecondsBottom;
} config;
static float ti;
static bool keyPulse;
static float loop2T, loop2OldGel;
static prgPos myPrgPos;
static bool autoMode;

static int servoclamp(int v)
{
  if (v < 900) return 900;
  if (v > 2100) return 2100;
  return v;
}

// v bleibt in den Schranken l1,l2 wobei egal ist ob l1<l2 oder l1>l2
static float floatclamp(float v, float l1, float l2)
{
  float klein, gross;
  if (l1 < l2) {
    klein = l1;
    gross = l2;
  } else {
    klein = l2;
    gross = l1;
  }
  if (v < klein) v = klein;
  if (v > gross) v = gross;
  return v;
}

static void help()
{
  Serial.println(F(
    "FabLab Neuenstadt - Weihnachten 2022\n"
    "SuperELCH Programmieranleitung\n"
    "k: Kill automatic (zuerst machen, sonst geht nichts manuell)\n"
    "t,b: Fahre zu Top oder Bottom\n"
    "T,B: Merke aktuelle Position als Top oder Bottom\n"
    "a,e: Servo ausschalten / Servo einschalten\n"
    "1,2,3  viel,mittel,wenig nach links fahren\n"
    "4,5,6  wenig,mittel,viel nach rechts fahren\n"
    "w: aktuelle Konfiguration im EEPROM speichern\n"
    "h: Hilfe\n"
    "v: show values\n"));
}

static void loopComm()
{
  const int c = Serial.read();
  if (c=='t') gelenk.writeMicroseconds(servoclamp(config.microSecondsTop));
  if (c=='b') gelenk.writeMicroseconds(servoclamp(config.microSecondsBottom));
  if (c=='T') config.microSecondsTop=servoclamp(gelenk.readMicroseconds());
  if (c=='B') config.microSecondsBottom=servoclamp(gelenk.readMicroseconds());
  if (c=='e') gelenk.attach(gelenkPin);
  if (c=='a') gelenk.detach();
  if (c=='1') gelenk.writeMicroseconds(servoclamp(gelenk.readMicroseconds()+100));
  if (c=='2') gelenk.writeMicroseconds(servoclamp(gelenk.readMicroseconds()+10));
  if (c=='3') gelenk.writeMicroseconds(servoclamp(gelenk.readMicroseconds()+1));
  if (c=='4') gelenk.writeMicroseconds(servoclamp(gelenk.readMicroseconds()-1));
  if (c=='5') gelenk.writeMicroseconds(servoclamp(gelenk.readMicroseconds()-10));
  if (c=='6') gelenk.writeMicroseconds(servoclamp(gelenk.readMicroseconds()-100));
  if (c=='w') EEPROM.put(0, config);
  if (c=='k') autoMode = false;
  if (c=='h') help();
  if (c=='v') {
    Serial.print("Bottom=");
    Serial.print(config.microSecondsBottom);
    Serial.print(" Top=");
    Serial.print(config.microSecondsTop);
    Serial.print(" Current=");
    Serial.print(gelenk.readMicroseconds());
    Serial.print(" Prg=");
    Serial.println(myPrgPos.getProgramNumber());
    Serial.print("loop2OldGel=");
    Serial.println(loop2OldGel);
  }
}

void setup()
{
  Serial.begin(9600);

  pinMode(gelenkPin, OUTPUT);
  digitalWrite(gelenkPin, LOW);
  gelenk.attach(gelenkPin);
  pinMode(nosePin, OUTPUT);
  pinMode(keyPin, INPUT_PULLUP);

  EEPROM.get(0, config);
  if (config.microSecondsBottom <= 0 || config.microSecondsTop <= 0) {
    config.microSecondsBottom = servoclamp(1800);
    config.microSecondsTop = servoclamp(1600);
  }
  config.microSecondsBottom = servoclamp(config.microSecondsBottom);
  config.microSecondsTop = servoclamp(config.microSecondsTop);

  autoMode = true;

  lastMillis = millis();

  help();
}

static void gel(float p) // p=0 bottom / p=1 top
{
  p *= config.microSecondsTop - config.microSecondsBottom;
  p += config.microSecondsBottom;
  p = floatclamp(p, config.microSecondsBottom, config.microSecondsTop);
  gelenk.writeMicroseconds(p);
}

static void nos(float p) // p=0 bottom / p=1 top
{
  p *= 255;
  p = floatclamp(p, 0, 255);
  analogWrite(nosePin, p);
}

static void loopKey()
{
  static float pressed = 0;
  keyPulse = false;
  if ( ! digitalRead(keyPin)) {
    pressed += ti;
    if (pressed > 0.1) {
      keyPulse = true;
      pressed = -FLT_MAX;            
    }
  } else pressed = 0;
}

static void loopNoseServo()
{
  if (autoMode) {
    if (myPrgPos.currentAcceleration() > 0) {
      const float deltaA = ti * myPrgPos.currentAcceleration();
      loop2OldGel = deltaA * myPrgPos.currentServo() + loop2OldGel * (1.f - deltaA);
    } else {
      loop2OldGel = myPrgPos.currentServo();
    }
    gel(loop2OldGel);

    nos(myPrgPos.currentLed());

    if (loop2T > myPrgPos.currentDelay()) {
      loop2T -= myPrgPos.currentDelay();
      myPrgPos.nextCommand();
    }

    loop2T += ti;
  } else {
    nos(1);
  }
}

void loop()
{
  unsigned long nowMillis = millis();
  unsigned long diffMillis = nowMillis - lastMillis; // wraparound ergibt keinen Fehler.
  lastMillis = nowMillis;
  ti = diffMillis;
  ti /= 1000; // ti ist jetzt die Zeitdifferenz zum letzten Mal in Sekunden.

  loopKey(); // ztuerst machen, weil das keyPulse setzt.

  loopComm();

  loopNoseServo();
  
  if (keyPulse) {
    autoMode = true;
//    loop2OldGel = myPrgPos.currentServo() > 0.5 ? 0 : 1; // snap nose
    myPrgPos.nextProgram();
    loop2T = 0;
  }
}

prg.cpp

#include "prg.h"

#include <Arduino.h>
#include <float.h>

// Programme sind kodiert als Gelenk (0..1), Nase (0..1), Delay (s). Programmende mit einzelnem Eintrag FLT_MAX
// Der erste Wert jedes Programmes ist die Acceleration. negative acceleration = instant.
// Listenende mit zusätzlichen FLT_MAX Eintrag

static const float pStore[] PROGMEM = {
  ////////////////////////////////// 0
  2,
  0  , 0, 1,
  0  , 1, 1,
  0  , 0, 1,
  0.1, 1, 1,
  0  , 0, 1,
  0.2, 1, 1,
  0.1, 0, 1,
  0.3, 1, 1,
  0.2, 0, 1,
  0.4, 1, 1,
  0.3, 0, 1,
  0.5, 1, 1,
  0.4, 0, 1,
  0.6, 1, 1,
  0.5, 0, 1,
  0.7, 1, 1,
  0.6, 0, 1,
  0.8, 1, 1,
  0.7, 0, 1,
  0.9, 1, 1,
  0.8, 0, 1,
  1  , 1, 1,
  0.9, 0, 1,
  1  , 1, 1,
  1  , 0, 1,
  FLT_MAX,


  ////////////////////////////////// 1
  -1,
  0.9, 0, 0.5,
  1, 1, 0.5,
  0.9, 0, 0.5,
  1, 1, 0.5,
  0.4, 0, 1,
  1, 1, 30-0.5*4-1,
  FLT_MAX,
  

  ////////////////////////////////// 2
  -1,
  0.9,1,0.25,
  0.9,0,0.25,
  0.9,0,0.25,
  0.8,0,0.25,
  0.9,1,0.25,
  0.9,0,0.25,
  1,0,0.25,
  1,0,0.25,
  1,1,0.25,
  1,0,0.25,
  0.8,0,0.25,
  0.8,0,0.25,
  1,1,0.25,
  1,0,0.25,
  1,0,0.25,
  1,0,0.25,  
  
  1  ,1,0.25,
  1  ,0,0.25,
  1  ,0,0.25,
  1  ,0,0.25,
  1  ,0,0.25,
  1  ,0,0.25,
  1,  0,0.25,
  1,  0,0.25,
  1,  1,0.25,
  1,  0,0.25,
  1  ,0,0.25,
  1  ,0,0.25,
  1,  0,0.25,
  1,  0,0.25,
  1,  0,0.25,
  1,  0,0.25,  

  1  ,1,0.25,
  1  ,1,0.25,
  1  ,0,0.25,
  1  ,0,0.25,
  1  ,1,0.25,
  1  ,1,0.25,
  1,  0,0.25,
  1,  0,0.25,
  1,  1,0.25,
  1,  1,0.25,
  1  ,0,0.25,
  1  ,0,0.25,
  1,  1,0.25,
  1,  1,0.25,
  1,  0,0.25,
  1,  0,0.25,  

  1  ,1,0.25,
  1  ,0,0.25,
  1  ,1,0.25,
  1  ,0,0.25,
  1  ,1,0.25,
  1  ,0,0.25,
  1,  1,0.25,
  1,  0,0.25,
  1,  1,0.25,
  1,  0,0.25,
  1  ,1,0.25,
  1  ,0,0.25,
  1,  1,0.25,
  1,  0,0.25,
  1,  1,0.25,
  1,  0,0.25,  
  FLT_MAX,


  ////////////////////////////////// 3
  -1,
  1  ,1,0.2,
  0.8,1,0.1,
  1  ,1,0.2,
  0.8,1,0.1,
  1  ,1,0.2,
  0.8,1,0.2,
  0  ,0,20-0.2*4-0.1*2,
  FLT_MAX,


  ////////////////////////////////// 4
  1,
  1,0,10,
  0,1,50,
  FLT_MAX,


  ////////////////////////////////// 5
  -1,
  0,1,0.5,
  1,0,0.5,
  0,1,0.5,
  1,0,0.5,
  0,1,0.25,
  1,0,0.25,
  0,1,0.25,
  1,0,0.25,
  0,1,0.25,
  1,0,0.25,
  0,1,0.25,
  1,0,60-0.25*7-0.5*4,
  FLT_MAX,


  ////////////////////////////////// 6
  10,
  1.0,0,2,  
  1.0,1,2,  
  0.9,0,2,  
  0.9,1,2,  
  0.8,0,2,  
  0.8,1,2,  
  0.7,0,2,  
  0.7,1,2,  
  0.6,0,2,  
  0.6,1,2,  
  0.5,0,2,  
  0.5,1,2,  
  0.4,0,2,  
  0.4,1,2,  
  0.3,0,2,  
  0.3,1,2,  
  0.2,0,2,  
  0.2,1,2,  
  0.1,0,2,  
  0.1,1,2,  
  0  ,0,2,  
  0  ,1,2,  
  FLT_MAX,


  -1,
  0,0,1,
  1,1,1,
  FLT_MAX,


  -1,
  0,1,0.5,
  1,0,0.5,
  0.2,1,0.5,
  0.8,0,0.5,
  0.4,1,0.5,
  0.6,0,0.5,
  FLT_MAX,
  

  0.5,
  0,0,30,
  1,1,30,
  FLT_MAX,

  ////////////////////////////////// EOF
  FLT_MAX // end of programs!
};


prgPos::prgPos()
  : p(pStore+1), pCurrentProgram(pStore), programNumber(0)
{
}

void prgPos::nextProgram()
{
  while (pgm_read_float(p) != FLT_MAX) p+=3;
  if (pgm_read_float(++p) == FLT_MAX) {
    p = pStore + 1;
    pCurrentProgram = pStore;
    programNumber = 0;
  } else {
    ++programNumber;
    pCurrentProgram = p++;
  }
}

void prgPos::nextCommand()
{
  p+=3;
  if (pgm_read_float(p) == FLT_MAX) p = pCurrentProgram + 1;
}

float prgPos::currentLed()
{
  return pgm_read_float(p+1);
}

float prgPos::currentServo()
{
  return pgm_read_float(p);
}

float prgPos::currentDelay()
{
  return pgm_read_float(p+2);
}

float prgPos::currentAcceleration()
{
  return pgm_read_float(pCurrentProgram);
}

int prgPos::getProgramNumber()
{
  return programNumber;
}

prg.h

#ifndef __PRG_H
#define __PRG_H

class prgPos {
public:
  prgPos();
  void nextProgram();
  void nextCommand(); // auto wrap around
  float currentLed();
  float currentServo();
  float currentDelay();
  float currentAcceleration();
  int getProgramNumber();
private:
  const float *p, *pCurrentProgram;
  int programNumber;
};

#endif

Weihnachtsmarkt Neuenstadt am 07. und 08. Dezember 2019

5. Dezember 20192. Dezember 2019 von Sören

Wir sind am kommenden Wochenende zum erstem Mal auf dem Weihnachtsmarkt in Neuenstadt am Kocher!

Bei uns gibt es leckere Rosenküchle und ganz besonderen Weihnachtsbaumschmuck.

Das FabLab bleibt deswegen am Samstag leider geschlossen 🙁

Schaut gerne an unserem Stand vorbei und lasst euch überraschen, was es tolles gibt.

Brückedächle e.V. Mitgliederversammlung 2019

14. November 2019 von Sören

Der Jugendförderverein Brückedächle e.V. lädt alle Mitglieder und Interessierten recht herzlich zur satzungsgemäßen jährlichen Mitgliedervollversammlung und anschließender Weihnachtsfeier am 30. November 2019 um 19.00 Uhr im Jugendhaus, Öhringer Str. 24 in Neuenstadt, ein.

Tagesordnung:
1. Feststellung der Beschlussfähigkeit
2. Entgegennahme des Jahresberichtes des Vorstandes
3. Feststellung der Jahresrechnung
4. Entgegennahme des Prüfungsberichts der Kassenprüfer
5. Wahl der Kassenprüfer (2 Posten)
6. Entlastung des Vorstandes
7. Weihnachtsmarkt Neuenstadt
8. Informationen Jugendhaus
9. Budget für den Kauf einer CNC Fräse
10. Spaßfabrik TSV
11. Ausblick 2020
12. Sonstiges

Nicht vergessen, anschließend laden wir noch zur Weihnachtsfeier im Jugendhaus ein.
BYOK! Bring your own Kekse! Wir freuen uns auf euch!

Spielenachmittag im Jugendhaus Neuenstadt am 24. November 2019

13. November 2019 von Sören

Am 24. November 2019 veranstaltet der Jugendförderverein Brückedächle e.V. im Jugendhaus Neuenstadt, Öhringer Straße 24, 2. OG einen Spielenachmittag.

Es sind viele Brett- und Kartenspiele vörrätig! Gerne können die Besucher auch eigene Spiele mitbringen und auch der Tischkicker, das Tischtennis und Billard stehen selbstverständlich zur Verfügung.

Der Jugendförderverein Brückedächle e.V. freut sich über deinen Besuch!

Herzliche Einladung zur Codeweek

25. September 2019 von Sören

Jetzt im Oktober ist es wieder soweit, ganz Europa macht sich bereit für die Code Week! Eine Woche lang dreht sich in hunderten Projekten von Initiativen, Privatpersonen, Firmen und Schulen alles um die spielerische Vermittlung von Code. Kinder und Jugendliche werden auf diese Weise an die Welt der Technik herangeführt und können schon früh herausfinden, dass Programmieren Spaß macht.

Wir vom FabLab Neuenstadt haben aus diesem Anlass drei Angebote für Jugendliche und junge Erwachsene erstellt, falls Sie jemanden kennen der Lust hat, etwas neues auzuprobieren, hiermit die herzliche Einladung!

Das Angebot ist kostenlos und kann auch ohne Programmierkenntnisse besucht werden!

Anmeldung unter: https://anmeldung.fablab-neuenstadt.de

5.10.2019: Workshop Linienfolgeroboter

In diesem Workshop werden wir gemeinsam einen Robotor
programmieren, der über optische Sensoren eine Linie
erkennt und ihr selbstständig folgt. Dafür werden wir die
Programmiersprache C++ in Kombination mit der Arduino
IDE verwenden.
Das Herzstück der Platine ist ein STM32 Mikrocontroller.
Der Robotor ist kostenlos und darf im Anschluss mit
nach Hause genommen werden. Wenn Du magst, kannst
Du ihn dann auch noch selbstständig erweitern: Wie wäre es
zum Beispiel mit einem Ultraschallsensor, um Gegenstände zu
erkennen?
Ab 14 Jahren.
Grundlegende Englischkenntnisse von Vorteil.
Wenn möglich eigenes Laptop mitbringen.
Beginn: 14:00 Uhr, Ende: 19:00 Uhr
Jugendhaus / FabLab Neuenstadt
Öhringer Str. 24, 2. OG, 74196 Neuenstadt
Anmeldung unter: https://anmeldung.fablab-neuenstadt.de

6.10.2019: Workshop TicTacToe

Wolltest Du schon immer einmal dein eigenes Computerspiel
erstellen? Dann ist dieser Workshop genau das Richtige für
Dich. Zusammen wollen wir den Einstieg in die Welt der
Programmierung wagen. Wir werden sehen was es mit
Variablen, Verzweigungen und Schleifen auf sich hat und
damit das Spiel TicTacToe in der Programmiersprache C#
implementieren.
Gespielt wird später 1 gegen 1 auf der Kommandozeile.
Auch dieses kleine Einstiegsprojekt ist nach dem Workshop
noch lange nicht fertig: Erweitere es doch beispielsweise
selbstständig um ein Fenster basiertes User Interface oder
einen Computergegner.
Ab 14 Jahren.
Grundlegende Englischkenntnisse von Vorteil.
Wenn möglich eigenes Laptop mitbringen.
Beginn: 14:00 Uhr, Ende: 18:00 Uhr
Jugendhaus / FabLab Neuenstadt
Öhringer Str. 24, 2. OG, 74196 Neuenstadt
Anmeldung unter: https://anmeldung.fablab-neuenstadt.de

19.10.2019: Hackathon Thema :Environment

Der Hack Marathon!
Wie nehmen wir unsere Umwelt und Umgebung wahr?
Wie können wir interessante Daten sammeln und nutzen?
Bleibt der Regenschirm zuhause oder müssen die Blumen
am Abend nicht gegossen werden? Wie ist der Niederschlag
in der Umgebung verteilt und kann der fallende Regen
besser genutzt werden? Wie wirkt sich Errosion auf die
Landwirtschaft aus?
Diese Themen können beim Hackathon technisch bearbeitet
werden. Aber auch eigene Themen und Ideen sind gern
gesehen. Egal ob technisch affin oder totaler Einsteiger.
Zusammen wollen wir uns mit den verschiedenen
Problemen auseinandersetzen, Lösungen programmieren
und erarbeiten. Dazu werden Sensoren und Hardware wie
Arduinos bereitgestellt. Unterstützt von Mentoren wird
von den Besuchenden an einem Thema gearbeitet und am
Abend die Ergebnisse präsentiert.
Ein Hackathon ist ein offenes Format, bei dem die
Teilnehmenden selbst definierte Problemstellungen mit
selbst programmierten Lösungen angehen.
Ab 14 Jahren.
Grundlegende Englischkenntnisse von Vorteil.
Wenn möglich eigenes Laptop mitbringen.
Beginn: 11:00 Uhr, Ende: 21:00 Uhr
Jugendhaus / FabLab Neuenstadt
Öhringer Str. 24, 2. OG, 74196 Neuenstadt

Anmeldung unter: https://anmeldung.fablab-neuenstadt.de

Lasercutting

16. September 2018 von Sören

Der Lasercutter ist nun schon länger im FabLab vorhanden und in reger Benutzung.

Daher konnte er schon in mehreren Projekten seine Nützlichkeit unter Beweis stellen.

Generell ist der Lasercutter für die Bearbeitung flacher Materialien

(wie Sperrholz oder Acrylglas) geeignet, welche sich durch geschickte Kombination

dann auch in die dritte Dimension erweitern lassen.

Beispiele für solche Werkstücke sind z.B. Kisten zum Verstauen diverser Kleinteile,

Gehäuse für Elektronik-Komponenten oder auch gravierte Acrylglas-Scheiben

für stylisierte Lampen oder ähnliche Projekte.

Natürlich ist nicht nur das Werkzeug im FabLab vorhanden, sondern auch das nötige Wissen, welches gerne geteilt wird.

Jeder mit genügend Kreativität und Eigeninitiative ist daher herzlich willkommen uns zu unseren regulären Öffnungszeiten

(jeden Dienstag von 18.30 Uhr – 21.00 Uhr und in ungeraden Wochen Samstag von 15:00 Uhr – 19.00 Uhr) zu besuchen und dabei seine mitgebrachten Projekte voranzubringen oder auch bei den offiziellen Projekten des FabLabs mitzuwirken.

Erweiterung um eine Textilwerkstatt

7. September 20187. September 2018 von Sören

Unser Hauptziel ist es, Kindern und Jugendlichen den Zugang zu einer gut und modern ausgestatteten Werkstatt zu bieten, ihr Interesse für technische und naturwissenschaftliche Themenbereiche zu wecken und dabei einen sozialen Raum zu schaffen, in welchem Wissen konzentriert und weitergegeben wird.

Wir haben unser aktuelles Angebot um das Arbeiten mit Textilien erweitert und können ab sofort unseren hauptsächlich jugendlichen Besuchern die Möglichkeit bieten, mitgebrachte T-Shirts, Pullover, Caps, Taschen oder Turnbeutel selbst zu gestalten und zu bedrucken.

Durch die Unterstützung der Jugendstiftung Baden-Württemberg, die unser Projekt mit 4000 € fördert und das Promedent Jugendförderkonzept welches uns mit 300 € unterstützt, konnte die Textilwerkstatt mit einem Schneidplotter Roland CAMM-1 GS-24, einer Transferpresse Secabo TC5 SMART, einer Stickmaschine Brother Innov-is V3 (bestellt) und einem Siebdruck-Set ausgestattet werden. Ein herzliches Danke!

Mit dem Schneidplotter können Motive aus einer Klebefolie ausgeschnitten und diese dann durch das Thermotransferverfahren auf Stoffen angebracht werden.

Die Stickmaschine ermöglicht es, selbst erstellte Motive oder Sprüche zum Beispiel auf einen Turnbeutel zu nähen.

Mit der Erweiterung um das Arbeiten mit Textilien, möchten wir gleichermaßen Jungen wie Mädchen ab 12 Jahren ansprechen und ihnen den Einstieg in die Welt der Technik erleichtern.

Wir freuen uns auf Ihren Besuch zu unseren Öffnungszeiten jeden Dienstag von 18.30 Uhr – 21.00 Uhr und in ungeraden Wochen Samstags von 15:00 Uhr – 19.00 Uhr.

Heißer Draht

24. März 202231. Juli 2018 von Sören

kleiner heißer Draht (Kinderferienprogramm)

Für den leichteren Zusammenbau haben wir eine kleine Bauanleitung als PDF erstellt.

Benötigte Bauteile:

Platine oder Lochplatine nach Vorlage
Zwei Schalter
9V Clip
Zwei 470 Ω Widerstände
Einen 220 Ω Widerstand
Summer
LED rot
LED grün
Bei Lochplatine Silberdraht
Holzbrett
4 mm² Kupferkabel für den heißen Draht.
Schweißdraht (Stahl) für den Ösenhandgriff
Klingeldraht
Kabelkanal als Batterieclip
Schrauben zur Platinenbefestigung
Bügelperlen als Abstandshalter 😀

Benötigte Werkzeuge:

Lötkolben
Lötzinn
Dritte Hand
Pinzette
Seitenschneider
Schraubendreher

Zur Info FabLab Öffnungszeiten

5. April 202216. März 2018 von Sören

Das FabLab Neuenstadt kann zu nachfolgenden Zeiten besucht werden:
Die Öffnungszeiten des FabLab-Reparatur-Café finden sie hier.

Unsere derzeitigen Öffnungszeiten:

Dienstags 18.30 Uhr – 21.00 Uhr

Zu diesen Terminen sind immer Menschen anwesend, die sich mit der Bedienung der Geräte auskennen und gegebenenfalls entsprechende Einweisungen und Hilfestellungen geben können.

Am 17.02.2018 ausnahmsweise geschlossen

17. Februar 2018 von Sören

Heute, am 17.02.2018, muss das FabLab leider ausnahmsweise geschlossen bleiben.