Basteln mit integrierten Schaltungen Teil 4 – Rechnen und Ausgabe

In Teil 3 habe ich den Aufbau eines 4-Bit-Speichers mit dem Baustein 74HC173 ausführlich beschrieben. In diesem Teil geht es nun um den Aufbau einer einfachen Einheit nach dem EVA-Prinzip (Eingabe/Verarbeitung/Ausgabe), eines grundlegenden Prinzips der Datenverarbeitung moderner Computer.

Diese Einheit soll zwei Werte aufnehmen, addieren und ausgeben – also eine Art simpler Taschenrechner (der aber nur addieren kann).

  • Die Eingabe erfolgt über zwei 4-Bit-Register A und B, z.B. aus der Schaltung aus Teil 3 mittels 4-D-Flipflop 74HC173. Die Eingabe erfolgt z.B. über Taster in Binärform (von 0000-1111) und wird über rote LEDs angezeigt.
  • Für die Verarbeitung ist der 4-Bit Volladdierer 74HC283 zuständig. Dieser nimmt die Eingabewerte aus Register A und B auf, addiert diese und gibt sie an einem 4-Bit Datenausgang wieder aus. Das binäre Ergebnis wird mit grünen LEDs angezeigt.
  • Die Ausgabe soll für Menschen lesbar in Dezimalform erfolgen. Für die Umwandlung des binären Ergebnisses des Volladdierers ins Dezimalformat ist der BCD zu 7-Segment-Dekoder 74HC4511 zuständig. Dessen Ausgabe erfolgt abschließend auf einem 7-Segment-Display.

Der Aufbau ist zur Verdeutlichung des Prinzips bewusst einfach gehalten. Aus diesem Grund erfolgt die Ausgabe auch nur auf einem einstelligen Display.

Aufbau 4 – Rechnen und Ausgabe mit 74HC283 & 74HC4511

Wenn das Grundprinzip verstanden wurde, lässt sich die Schaltung unter Verwendung weiterer Bausteine erweitern und damit z.B. eine zweistellige Digitalausgabe realisieren, indem der Übertrag (Carry) des Volladdierers 74HC283 genutzt wird. Desweiteren können z.B. anstelle einer binären Eingabe-LED-Anzeige auch weitere Dekoder 74HC4511 mit 7-Segmentanzeigen versehen werden, um die Eingabe benutzerfreundlicher darzustellen.

Hier nun Fotos meiner Versuchsaufbauten (hier auch Kombinationen früherer Aufbauten) in verschiedenen Eingabesituationen:

Viel Spaß beim Nachbau!

Taktgeber für Elektronik-Bastelprojekte

In der Welt der Elektronik geben Taktgeber elektrische Impulse in einer bestimmten Frequenz ab und sind damit im elektronischen Rechenwerk unerlässlich. Die meisten Steuerungs- und Schaltvorgänge im Rechenwerk sind taktgesteuert.

Es gibt viele Umsetzungformen, von der einfachen Blinkschaltung bis zum Schwingquarz-Oszillator, je nach erforderlichem Einsatzzweck.

Für meine vorgestellten Bastelprojekte verwende ich meinen Aufbau aus dem Beitrag „LED dimmen mit NE555 PWM“ als Taktgeber. Doch wie schon im letzten Beitrag angesprochen, möchte ich heute einen alternativen Taktgeber aus einem tollen Projekt von Ben Eater vorstellen.

Ben Eater ist in der Community bekannt für sein großartiges Project „Build an 8-bit computer from scratch“ und seine zugehörigen, sehr empfehlenswerten Tutorial-Videos auf Youtube hierzu. Er beschreibt den Aufbau eines 8-Bit-Computers auf dem Steckbrett unter Verwendung einfacher Logikbausteine mit Taktgeber, Register, Arithmetisch-logischer Einheit (ALU), RAM, Register, usw. Schaut es Euch mal an, es lohnt sich!

Ich stelle hier seinen Aufbau eines Taktgebers vor, welcher sich sehr gut für weitere Bastelprojekte eignet. Er verwendet hierbei ebenfalls den bekannten Baustein NE555 und nutzt diesen innerhalb seiner Schaltung auf drei verschiedene Arten.

Die Taktfrequenz kann stufenlos zwischen knapp einem Hertz bis auf ein paar hundert Hertz eingestellt werden. Es gibt auch die Möglichkeit zum Umschaltung in einen manuellen Modus, um jeden Taktzyklus per Tastendruck auszulösen.

Schaltplan „Clock module“ von Ben Eater https://eater.net/8bit/clock

Bitte vergesst bei den Bausteinen 74LS08, 74LS04 und 74LS32 nicht, VCC (Pin 14) und GND (Pin 7) anzuschliessen, dies ist auf dem Schaltplan nicht sofort ersichtlich.

Nachfolgend seht Ihr meinen Aufbau. Ich kann diese Schaltung nur empfehlen, gerade die feine Frequenzeinstellung und die Möglichkeit zum manuellen „Durchsteppen“ der Schaltung hat mir sehr gefallen.

Basteln mit integrierten Schaltungen Teil 3 – Speicheraufbau mit dem 74HC173

Im letzten Teil wurde ein 4-Bit-Speicher (Flipflop) aus zwei integrierten Schaltungen des Typs 74HC00 (2-fach NAND-Gatter) der 74xx Reihe aufgebaut.

In diesem dritten Teil wird der Aufbau eines 4-Bit-Speichers mittels der integrierten Schaltung 74HC173 vorgenommen, ein 4D-Flipflop mit Tri-State-Ausgang. Mit diesem Speicher lassen sich bereits 16 verschiedene Zustände (2^4) speichern. Dieser IC schaltet mit einem Taktsignal, als Taktgeber kann z.B. ein NE555 verwendet werden, wie die hier gezeigte Schaltung aus dem Beitrag LED dimmen mit NE555 PWM.

Setzt man bei dieser Schaltung einen Kondensator mit größerer Kapazität ein, wird ein langsames Blinken erzeugt, was es ermöglicht, ein Einfluss des Taktgebers auf die Schaltvorgänge besser nachvollziehen zu können. Alternativ dazu stelle ich im nächsten Beitrag einen alternativen Taktgeber vor.

Nun zum Aufbau selbst. Im nachfolgenden Schaltplan zeige ich zwei Varianten auf, die Versuchsaufbauten „A“ und „B“.

Versuchsaufbau „A“ dient als einfacher, selbsthaltender Speicher, ähnlich der Schaltungen meiner bisher gezeigten Aufbauten.

Versuchsaufbau „B“ arbeitet ohne Selbsthaltung mit setzbaren Dateneingängen E1/E2 (Pin 9 und 10 „Enable Data Input“). Doch was heißt das und wo genau liegen die Unterschiede?

Vergleicht man beide Schaltpläne, erkennt man folgende Unterschiede zwischen Versuchsaufbau „A“ und „B“:

  • Bei Versuchsaufbau „A“ sind die Eingänge D0-D3 mit den Ausgängen Q0-Q3 verbunden, bei Versuchsaufbau „B“ nicht
  • Die Dateneingänge E1 und E2 wurden bei Versuchsaufbau „A“ mit GND verbunden, bei Versuchsaufbau „B“ ist dies wie CLK (Pin 7, Cp) ein weiterer Eingang
  • Bei Versuchsaufbau „B“ wurden Anschlüsse DA_0 bis DA_3 herausgeführt, um die Datenausgangsleitung zu zeigen. Dies wäre allerdings auch bei Aufbau „A“ schon möglich gewesen, die LEDs dienen ohnehin nur der Visualisierung.

Versuchsaufbau A

Die Selbsthaltung bei Versuchsaufbau „A“ besteht in der Kopplung der Ein- und Ausgänge. Die Dateneingänge E1 und E2 sind miteinander verbunden und werden zu GND geführt, das Eingangssignal ist damit LOW, der Dateneingang ist damit laut Datenblatt aktiv gesetzt. Was dies alles genau heißt, darauf gehe ich im weiteren Verlauf etwas später ein.

Zum Speichern eines Wertes muss einer der Taster SW1-4 gedrückt werden, die zugehörige LED leuchtet auf. Der Reset-Taster setzt wie gewohnt alles wieder zurück. Nachfolgend ein Bild des Aufbaus auf dem Steckbrett. Die gelbe lange Leitung nach rechts führt zum Taktgeber.

Versuchsaufbau A mit Selbsthaltung

Wenn der Taktgeber langsam z.B. im Sekundentakt blinkt, fällt auf, dass man die Taster eine Weile gedrückt halten muss, bis die entsprechende LED dauerhaft leuchtet. Dieses Verhalten hat also offenbar etwas mit dem Taktsignal zu tun. Doch was passiert da genau?

Taktzyklus

Einfach erklärt, schaltet der Taktgeber im Wechsel ein HIGH / LOW Signal in einer bestimmten Frequenz. Dies entspricht einem Wechsel zwischen An und Aus oder 1 und 0. Geschieht dieser Wechsel ohne langsam ansteigende/abschwellende Spannung über einen bestimmten Zeitraum, spricht man von einem Rechtecksignal.

PWM

Der Baustein 74HC173 reagiert auf das Taktsignal an Pin 7 wie folgt:

Ist das Eingangssignal des Taktgebers HIGH und gleichzeitig die Dateneingänge E1 und E2 LOW (also aktiv gesetzt), werden die zu diesem Zeitpunkt an den Eingängen D0-D3 anliegenden Zustände gespeichert und auf den Ausgängen Q0-Q3 ausgegeben. War einer der Eingangswerte zu diesem Zeitpunkt HIGH, leuchtet die entsprechende LED auf.

Die gespeicherten Zustände bleiben bis zum nächsten Taktzyklus erhalten. Mit dem nächsten HIGH Impuls werden sie wieder durch die zu diesem Zeitpunkt an den Eingängen anliegenden Werte ersetzt.

Möchte man dies verhindern und die gespeicherten Zustände bis auf weiteres erhalten, setzt man die Dateneingänge E1 und E2 unmittelbar bzw. innerhalb des Zeitraumes bis zur nächsten Änderung der Eingangswerte D0-D3 auf HIGH. Die Werte bleiben nun so lange gespeichert, bis E1 und E2 wieder auf LOW gesetzt werden, unabhängig davon, wie sich die Zustände bei D0-D3 verändern sollten.

Im Versuchsaufbau „A“ sind die Dateneingänge E1 und E2 immer auf LOW, also aktiv.

Damit erklärt sich auch, warum man die Tasten je nach Taktfrequenz länger gedrückt halten muss, bis die LEDs dauerhaft leuchten. Drückt man den Taster und lässt ihn los, bevor der Taktimpuls HIGH ist, wird der anschließende Eingangswert LOW (= Taster losgelassen) gespeichert – die LED erlischt wieder.

Die Selbsthaltung ergibt sich aus der Kopplung der Datenausgänge mit den Eingängen. Wurde der Zustand einmal aufgenommen, wird die Ausgabe wieder zur Eingabe.

Versuchsaufbau B

So nützlich die Selbsthaltung hier in Verbindung mit den Tastern erscheint (einmalige Impulse werden dauerhaft gespeichert), so ist diese Form als Speicher in Computersystemen eher unpraktisch. Sinnvoller wäre es doch, im Bedarfsfall zu entscheiden, ob und wie lange Zustände gespeichert werden sollen. Genau dies erfolgt beim folgenden Versuchsaufbau „B“

Versuchsaufbau B mit setzbaren Dateneingängen

In diesem Versuchsaufbau kann der Zustand der Dateneingänge E1 und E2 umgeschaltet werden (LOW: Eingang ein, HIGH: Eingang aus). Im obigen Steckbrettaufbau erfolgt dies einfach mittels Umstecken des gelben Kabels in der Mitte nach VCC oder GND (hier im Foto in GND eingesteckt). Alles weitere funktioniert so, wie bereits im Abschnitt „Taktzyklus“ beschrieben. Zudem könnte man bei dieser Schaltung auf den Reset-Taster verzichten, sofern man selbst keinen generellen „Master-Reset“ benötigt.

Für welchen Schaltungsaufbau man sich entscheidet, hängt letztendlich vom geplanten Einsatzszenario ab. In den nächsten Teilen wird es um die weitere Verarbeitung gespeicherter Zustände gehen.

Basteln mit integrierten Schaltungen Teil 2 – Speicheraufbau mit dem 74HC00

Im letzten Teil habe ich den Aufbau eines 1-Bit Speichers (Flipflop) aus diskreten Bauelementen (Transistoren, Widerstände, etc.) dargestellt. In diesem Teil geht es um die erste Realisierung eines solchen Aufbaus mit einer integrierten Schaltung.

Zum Einsatz kommt hier eine integrierte Schaltung aus der 74xx-Familie, dessen Geschichte bis in die 1970er-Jahre zurückreicht. Genauer geht es hier um die Schaltung 74xx00, ein 2-fach NAND-Gatter. Zum Einsatz kommt die High speed CMOS-Version mit der Kennung „HC“, also der Baustein „74HC00“. Dieser kann mit einer Versorgungsspannung von 2-6 V betrieben werden.

Der folgende Schaltplan zeigt den Aufbau eines 2-Bit Speichers mit diesem Baustein. Ähnlich wie schon beim Aufbau aus dem ersten Teil werden die jeweiligen Zustände mittels verschiedenfarbiger LEDs dargestellt. Die erste Speicherstelle (Register 1) wird durch eine rote LED, die zweite (Register 2) durch eine grüne LED repräsentiert. Der jeweils zweite stabile Zustand („Reset“) wird wie zuvor durch eine gelbe LED angezeigt. Auch hier werden die jeweiligen Zustände mittels der Taster „Set“ und „Reset“ umgeschaltet.

Schaltplan 2-Bit Speicher mit 74HC00

Den Aufbau auf dem Steckbrett habe ich direkt mit zwei Bausteinen vorgenommen, um direkt einen 4-Bit Speicher für die folgenden Aufbauten zur Verfügung zu haben. Wie man jetzt schon gut erkennen kann, wäre der Aufbau dieser Schaltung nur mit diskreten Bauelementen allein bereits jetzt schon sehr umfangreich. Im nächsten Teil wird der (Einzelteil-) Umfang noch weiter reduziert.

Basteln mit integrierten Schaltungen Teil 1 – Speicher

Dies ist Teil 1 meiner neuen Reihe, welche sich künftig rund um das Basteln mit integrierten Schaltungen dreht.

Zu Beginn geht es um den Aufbau einer sogenannten bistabilen Kippstufe, das Flipflop. Diese Schaltung kann die Datenmenge von einem Bit über eine unbegrenzte Zeit speichern und ist ein unverzichtbares Bauelement innerhalb von Schaltungen der Digitaltechnik von der Quarzuhr bis hin zum Mikroprozessor. Im Besonderen ist dieser elementare 1-Bit-Speicher das Grundelement der statischen Speicherbausteine (SRAM) im Computer.

In diesem Artikel erfolgt der Aufbau zum besseren Verständnis mittels diskreten Bauelementen.

Schaltplan NAND-Flipflop aus diskreten Bauteilen

Im wesentlichen besteht die Schaltung aus zwei NAND-Gattern, dessen Eingabezustände über zwei Taster (Set und Reset) mittels Transistoren angesteuert werden. Die Ausgabe erfolgt über zwei LEDs. Der erste stabile Zustand des Ausgangssignals wird mit der roten LED, der zweite mit der gelben LED dargestellt. Wird die Taster „Set“ gedrückt, leuchtet die rote LED auf (die gelbe LED verlischt). Beim Drücken der Taste „Reset“ verlischt die rote LED (und die gelbe LED leuchtet auf).

Auf dem Steckbrett habe ich noch eine 7-Segment-Anzeige ergänzt, welche eine „1“ beim ersten Ausgabezustand und ein „-“ beim zweiten Ausgabezustand anzeigt.

Im nächsten Teil wird für diesen Aufbau eine integrierte Schaltung zum Einsatz kommen.

LED dimmen mit NE555 PWM

Heute mal wieder ein Bastelthema, der letzte Blogeinrag ist nun doch eine ganze Weile her.

Mein letzter Blogeintrag handelte von dem Thema Dimmer für LED-Lichterkette bauen.

Realisiert habe ich dies seinerzeit per Pulsweitenmodulation (PWM) mittels einem Arduino. Heute möchte ich noch eine weitere Möglichkeit vorstellen, welche als rein elektronische Schaltung mit wenigen Elementen realisiert werden kann. Hierbei kommt der universelle Timerbaustein NE555 zum Einsatz. Die finale Schaltung lässt sich für vielerlei Zwecke einsetzen, nicht nur zum reinen Dimmen von LEDs.

Achtung: Anzumerken ist, das die PWM nach dieser Schaltung einen Bereich von ca. 5-10% bis etwa 90% abdeckt, d.h. die LEDs können nicht auf völlige Verdunklung gedimmt werden.

Anmerkungen zum Schaltplan

Ich habe eine CMOS-Version namens LMC555 verwendet, welche mit geringeren Spannungen ab 1,5 V arbeiten kann. Die Schaltung eignet sich für Spannungen bis zu 15 V, die Widerstände R1 (für die Status-LED, optional) und R4 (für den Transistor) müssen entsprechend angepasst werden.

Die Frequenz wird mit dem Kondensator C3 an Pin 6 bestimmt. Je höher die Kapazität, desto niedriger die Frequenz. Für den hörbaren Bereich ab etwa 220 pF aufwärts (tiefere Töne bei höherer Kapazität), für den sichtbaren Bereich (Dimmen, Blinker, Blitzer, etc.) ab 100 nF. Mit > 500 µF sind Intervalle bis zu mehreren Minuten einstellbar.

Als Transistor habe ich den aus meinem letzten Aufbau bekannten BC337/25TA Transistor mit 800 mA Kollektorstrom verwendet. Für höhere Lasten kann ein entsprechender MOSFET mit Kühlung verwendet werden.

Schaltplan PWM-Dimmer mittels LMC555/NE555

Versuchsaufbau

Den Grundaufbau habe ich zunächst auf einem Steckbrett vorgenommen:

Aufbau auf Lochrasterplatine

In Anschluss habe ich diese auf eine Lochrasterplatine übertragen. Hier habe ich ein paar Optimierungen vorgenommen und beispielsweise eine Sockelleiste eingelötet, um eine einfache Frequenzanpassung durch Wechseln des Kondensators zu ermöglichen. Zwecks leichterem Austausch empfehle ich, eine IC-Fassung einzulöten.

Ich wünsche viel Spaß beim Nachbau!

Projekt: Dimmer für LED-Lichterkette bauen

Für unseren Balkon haben wir eine LED-Lichterkette gekauft, genauer gesagt folgende:

6M LED Lichterkette, 4,5W 125er LEDs, Warmweiß, erhältlich z.B. bei Amazon.

Toll wäre eine Möglichkeit, die Helligkeit nachjustieren zu können, also sollte ein LED-Dimmer her.

Ein Blick in die technischen Daten und auf das Netzteil überraschte, die Lichterkette wird mit nur 3 Volt und 800 mA betrieben:

„Fertige“ Lösungen oder Bausätze beziehen sich oftmals auf wesentlich höhere Spannungen, oft 12-24 V. Also entschied ich mich für einen Selbstbau mit einem Mikrocontrollerboard, genauer einem Arduino UNO R3.

Vorweg – ich sehe den Selbstbau als reines Übungsprojekt – ich bin kein Elektotechniker und übernehme keine Gewähr dafür, sollte sich jemand dazu entschließen, meinen hier geschilderten Aufbau umzusetzen 😉 Aber ich bin sehr an Feedback interessiert, vielleicht hat der ein oder andere noch weitere Ideen oder Optimierungsvorschläge oder verdreht gänzlich die Augen aufgrund meiner Umsetzung 😉

Doch warum ein Mikrokontrollerboard? Zunächst stellte sich heraus, daß das Dimmen von LEDs alles andere als trivial ist. Hierzu wird eine Technik angewendet, welche sich Pulsweitenmodulation (PWM) nennt:

PWM

Vorbereitung:

Nach den ersten Überlegungen stellte sich folgende Konstellation heraus:

Die Spannungsversorgung sollte über ein 9 Volt 1500 mA Netzteil erfolgen, welches den Arduino versorgt. Das gleiche Netzteil versorgt auch die Lichterkette, hier wird über einen Schaltregler die Spannung auf die Versorgungsspannung der Lichterkette reduziert, genauer 3,5 V (direkt am Original-Netzteil ermittelt). Die Ausgangsspannung lässt sich mittels einer kleinen Stellschraube am Schaltregler und einem Multimeter exakt einstellen. Ich habe ein 1500 mA Netzteil gewählt, um 800 mA für die Lichterkette und den Rest für den Arduino bereitzustellen – genug Reserve also.

In den Versorgungsstromkreis der Lichterkette wird ein NPN-Transistor eingebunden, welcher über den Arduino geschaltet wird und somit die Lichterkette ein-/ausschaltet. Die Pulsweitenmodulation wird also durch den Mikrocontroller vorgenommen.

Die Regelung des PWM-Intervalls erfolgt über ein Drehpotentiometer, welches an den Arduino angeschlossen wird.

Mit Hilfe der Fritzing Software habe ich den geplanten Aufbau skizziert und einen groben Schaltplan erstellt – erfahrene Elektrotechniker mögen über diesen bitte wohlwollend hinwegsehen 😉

In diesen Skizzen ist kein Ein-/Ausschalter berücksichtigt, dieser wurde nachträglich implementiert.

Nachtrag 09.08.2017: Als Basiswiderstand B2 habe ich anstelle 220 Ω einen 140 Ω Widerstand gewählt, siehe auch Abschnitt „Anfänger-Stolpersteine – bitte beachten!“

Benötigte Materialien und Kosten:

1x Arduino UNO R3 (ATmega328) – ca. 12,- EUR, z.B. hier, oder hier.
1x Platine ohne Cu-Auflage 100 mm x 50 mm, Rastermaß 2,54 mm – ca. 0,79 EUR
1x LM2596 Schaltreglermodul, DC-DC, verstellbarer Abwärtswandler – ca. 2,- EUR
1x Lüsterklemme – ca. 0,95 EUR
1x 9V-Netzteil oder Universal Netzteil 1500 mA – ca. 13,- EUR
1x Adapterkabel mit Netzgerätebuchse 5,5/2,1 mm – ca. 1,85 EUR
1x rote LED 3mm – ca. 0,10 EUR
1x Metallschicht-Widerstand 220 Ω – (für LED-Versuchsaufbau) ca. 0,08 EUR
1x Metallschicht-Widerstand 140 Ω – (Basiswiderstand für Transistor) ca. 0,08 EUR
1x NPN Transistor BC337/25TA TO-92-3 – ca. 0,20 EUR
1x Leitplastik-Potentiometer Mono 10 kΩ – ca. 1,10 EUR
1x Drehknopf schwarz – ca. 1,80 EUR
1x Kippschalter – ca. 2,70 EUR
1x Gehäuse 150 x 80 x 50 – ca. 3,- EUR
1x Jumper Kabel 20 cm männlich/männlich – ca. 4,- EUR

Gesamtkosten (ohne Kabel): ca. 44,- EUR – wobei die beiden teuersten Komponenten, Arduino und Netzteil insgesamt schon 25,- EUR ausmachen – sollten diese bereits vorhanden sein, sind die Gesamtkosten durchaus im Rahmen dessen, was fertige Lösungen im Verkauf kosten würden. Wer die Komponenten günstiger beschaffen kann, kriegt den gesamten Aufbau vielleicht schon für die Hälfte hin.

Weitere Komponenten:

  • Kabel 0,5/0,75 mm^2 (ca. 0,50 EUR/m)
  • Bohrmaschine + Bohrer
  • Lötkolben incl. Zubehör
  • Heißklebepistole
  • Isolierband
  • Multimeter
  • Schraubendreher
  • Maulschlüssel

Versuchsaufbau

Hier kann man das Grundprinzip nachvollziehen. Die rote LED zeigt den Status (an/aus), die grüne LED dient als Platzhalter für die spätere Lichterkette. Den Aufbau des Arduino Quelltexts für die Pulsweitenmodulation (PWM) sowie die Verwendung des Potentiometers konnte ich dank der vielen sehr guten Tutorials im Web erlernen und nachvollziehen.

Ich habe noch ein paar Optimierungen vorgenommen:

  1. Der analoge Eingang mit dem angeschlossenen Potentiometer wird mehrfach abgefragt und ein Mittelwert berechnet, um evtl. Ausreißer durch Schwankungen zu vermeiden.
  2. Implementierung eines Schwellenwertes für die min/max Aussteuerung
// LED dimmen via PWM und Poti

const int numReadings = 10;
const int analogInPin = A1; // Input-Pin fuer Potentiometer (0-1023)
const int analogOutPin = 3; // Pin fuer LED (0-255)

int readings[numReadings]; // the readings from the analog input
int readIndex = 0;         // the index of the current reading
int total = 0;             // the running total
int average = 0;           // the average

int inputPin = analogInPin;

int sensorValue = 0; // Berechneter Mittelwert von Poti
int outputValue = 0; // Wert fuer PWM-Output

void setup() {
//  Serial.begin(9600); // For Bugfixing
  // initialize all the readings to 0:
  for (int thisReading = 0; thisReading < numReadings; thisReading++) {
    readings[thisReading] = 0;
  }
  pinMode(inputPin, INPUT);
  digitalWrite(inputPin, HIGH);
}

void loop() {
  // subtract the last reading:
  total = total - readings[readIndex];
  // read from the sensor:
  readings[readIndex] = analogRead(inputPin);
  // add the reading to the total:
  total = total + readings[readIndex];
  // advance to the next position in the array:
  readIndex = readIndex + 1;

  // if we're at the end of the array...
  if (readIndex >= numReadings) {
    // ...wrap around to the beginning:
    readIndex = 0;
  }

  // calculate the average:
  average = total / numReadings;
  // send it to the computer as ASCII digits

  sensorValue = average;

  // Werte in Bereich des Analog-Out mappen:
  outputValue = map(sensorValue, 0, 1023, 0, 255);

  if (outputValue < 6) {
    outputValue = 0;
  }
  else if (outputValue > 250) {
    outputValue = 255;
  }


  // Wert ausgeben
  analogWrite(analogOutPin, outputValue);

  // For Bugfixing
/*  
  Serial.print("sensor = ");
  Serial.print(sensorValue);
  Serial.print("\t output = ");
  Serial.println(outputValue);
*/ 
  delay(2);        // delay in between reads for stability
}

Aufbau der Platine

Anschließend habe ich die Komponenten auf eine Platine gesetzt und miteinander verbunden. Spannungsregler und Lüsterklemmen wurden mittels Heißkleber fixiert. Beim Einbau das Transistors bitte die Pinbelegung gemäß Datenblatt heranziehen (Emitter, Basis und Kollektor).

Anfänger-Stolpersteine – bitte beachten!

Wie man ersehen kann, habe ich die ersten Versuchsaufbauten mit kleinen LEDs vorgenommen und für die Verkabelung Jumperkabel verwendet. Zudem hatte ich zunächst einen zu kleinen Transistor (2N3904TA) und die Basis mit einen 10 kOhm Widerstand verbunden. Für den Versuchsaufbau stellte dies alles kein Problem dar, doch bei der finalen Umsetzung zeigten sich hierbei mehrere Probleme – die Lichterkette leuchtete nur noch mit 50% Leuchtstärke.

Meine Idee, Jumperkabel an ein Potentiometer zu löten, war in vielerlei Hinsicht eine schlechte Idee: Der Drahtquerschnitt war so gering, das die Verbindung alles andere als stabil war und zu stark schwankenden Eingangswerten führte. Ich habe diese durch Drähte mit 0.5 mm^2 Querschnitt ersetzt und diese an Stiftbrücken gelötet, um die Verbindung mit dem Arduino herzustellen.

Anschließend war der gewählte Transistor zwar für LEDs ausreichend, doch mit 200 mA Kollektorstrom bewirkte dieser nur ein schwaches Leuchten der Lichterkette. Nach der Umrüstung auf einen BC337/25TA Transistor mit 800 mA Kollektorstrom war dann auch dieses Problem gelöst.

Danach stellte sich heraus, das ein 10 kOhm Widerstand an der Basis des Transistors viel zu hoch bemessen war – ich habe diesen durch einen 140 Ohm Widerstand ersetzt.

Berechnung Basiswiderstand

Als Nachtrag vom 09.08.2017 füge ich die Berechnung des Basiswiderstandes für den Transistor bei. Ich habe mich dabei nach dem Artikel Basiswiderstand auf mikrocontroller.net orientiert.

Folgende Werte habe ich hierbei berücksichtigt:

\(U_{E}=5V\) Steuerspannung
\(I_{C}=800 mA\) für den Verbraucher, also die Lichterkette
\(h_{FE}= 100\) DC Current Gain des Transistors laut Datenblatt bei \(V_{CE}=1V, I_{C}=100mA\)

Zunächst die Abschätzung der Stromverstärkung in Sättigung für die weitere Berechnung:\(h_{FE}=\frac{h_{FE}}{3,7}=\frac{100}{3,7}\approx 27\)

Berechnung des Basisstroms: \(I_{b}=\frac{I_{C}}{h_{FE}}=\frac{800mA}{27}\approx 30mA\)

Berechnung des Basiswiderstands: \(R_{b}=\frac{U_{E}-0,7V}{I_{B}}=\frac{5V-0,7V}{0,030 A}\approx 143 \Omega\)
Anmerkung: 0,7 V werden von der Steuerspannung abgezogen, da diese an der Basis-Emitter Strecke des Transistors abfallen.

Nach dieser Auslegung habe ich einen 140 Ohm Basiswiderstand gewählt.

Einbau in das Gehäuse


Das Gehäuse habe ich nach den Gegebenheiten meines Aufbaus ausgewählt, es geht sicherlich auch deutlich kompakter 🙂

Wie man ersehen kann, habe ich den Arduino mittels M3 Schrauben und Muttern mit dem Gehäuse verschraubt und in den Deckel des Gehäuses die Bohrungen für Schalter, Potentiometer und Status LED eingebracht.

Die Buchse für die Stromversorgung wird seitlich herausgeführt und wurde im Gehäuse mit Heißkleber fixiert.

Die Zugentlastung des nach außen geführten Kabels für die Lichterkette erfolgt mittels eines Kabelbinders. Die offenen Kabelenden an Schalter, Potentiometer und Status LED wurden mit Isolierband versehen.

Wir haben das Gehäuse mittels eines Nagels an der Wand befestigt.

Der Praxistest:

Auch wenn das Gerät sehr „Retro“-lastig erscheint, erfüllt es seinen Zweck und ist – hey – immerhin selbstgebaut.

Nach dem Einschalten lässt sich die Leuchtstärke der LED-Lichterkette stufenlos mit dem Drehregler einstellen und sorgt so stets für die gewünschte Beleuchtung. Ich habe ein paar Fotos in den Einstellungen maximal, mittel und gering beigefügt. Man möge die schlechte Aufnahmequalität in der Nacht verzeihen, doch erkennt man gut den Effekt.

macOS: dd-Status überprüfen

Das vielseitig nutzbare Tool „dd“ (DiskDump) gibt während des Programmlaufs normalerweise keinerlei Statusmeldungen aus. Um zu überprüfen, wieviele Bytes bereits verarbeitet wurden, kann unter Linux der folgende Befehl genutzt werden: kill -USR1 prozessnummer. Unter macOS führte dieser Befehl (zumindest bei mir) zum Abbruch des gesamten Vorganges, was gerade beim Schreiben eines Images auf einen Datenträger fatal ist.

Nach ein wenig Recherche fand ich folgende Möglichkeit: killall -INFO dd oder alternativ die Tastenkombination [Strg] + [T]. Hierbei handelt es sich um ein BSD-Feature, welches ein SIGINFO an den Prozess sendet und zur gewünschten Ausgabe führt.

ssh als SOCKS-Proxy unter OS X nutzen

TUX-Avatar-350In dieser Anleitung möchte ich vorstellen, wie sich ssh als SOCKS-Proxy unter OS X nutzen lässt. Kurz vorweg, diese Anleitung lässt sich selbstverständlich auch auf andere Systeme wie z.B. BSD oder Linux übertragen, auf welchen eine Installation des ssh-Clients vorliegt.

Voraussetzung hierzu ist das Vorhandensein eines Root- oder V-Servers mit Zugriff auf einen installierten und konfigurierten SSH-Server, zu dem man eine Verbindung aufbauen kann.

Ziel ist, mittels SSH einen Tunnel einzurichten, der sich wie ein SOCKS-Proxy verhält, welcher zwischen dem anfragendem Webbrowser und dem Webserver steht. Anfragen werden nun über den verbundenen Root- bzw. V-Server geleitet. Der angefragte Webserver „sieht“ hier nur die IP-Adresse des Root- bzw. V-Servers, nicht die tatsächliche IP-Adresse des Clienten. Die tatsächliche IP-Adresse bleibt somit dem Kommunikationspartner verborgen.

Warum nutze ich diese Möglichkeit?

Kurz vorweg: Nicht aus Anonymisierungsgründen 😉 – da der verwendete Root-Server ohnehin von mir betrieben wird. Mir ging es um einen anderen Fall: Die gängige Praxis der Bandbreitenbeschränkung über ganze IP-Adressbereiche, vorzugsweise für private IP-Adressen. utilities-system-monitorIch habe Verständnis für Load-Balancing in einem vernünftigen (!) Rahmen, aber keinerlei Verständnis dafür, das Software-Updates in Größenordnungen von mehreren hundert Megabyte mit z.B. 60 KB/s durch die Leitung tröpfeln und ein Download somit mehrere Stunden dauern soll. Ein Login auf dem Root mit anschließendem manuellem Download via curl oder wget ergab dann oft Gewissheit: In diesem IP-Adressbereich sind Datenraten mit voller Bandbreite kein Thema.

Anfänglich fiel mir das nur bei wenigen Diensten auf, doch scheint es mittlerweile in Mode gekommen zu sein – und es nervt, ich bezeichne das als technischen Rückschritt und Gängelei der Endbenutzer. Ich erwarte nicht, das Serverbetreiber für tausende Nutzer zugleich pro Download-Slot 100 MB/s anbieten – aber Datenraten in Bereichen von ISDN und weniger sind ein definitives NoGo und eine Zumutung in der heutigen Zeit.

quasselWie schon beschrieben, umgehe ich diese Beschränkungen mittles manuellen Downloads via Server-Konsole, dies ist allerdings recht unkomfortabel. Die Alternative ist die Einrichtung eines „richtigen“ Proxy-Servers wie z.B. Squid. Diese ist allerdings nicht ganz trivial und entsprechend gegen missbräuchliche Nutzung abzusichern – was man als Serverbetreiber durchaus ernst nehmen sollte.

Mir ging es allerdings nicht um eine dauerhafte Proxy-Nutzung, weshalb ich mich für die Realisierung mittels eines ssh-Tunnels entschlossen habe.

Einrichtung

1) Start des ssh-Clients

Im OS X – Terminal hierzu folgenden Befehl absetzen:

ssh -D 8080 -C -N user@server.tld

user@server.tld ist natürlich durch eigene Angaben zu ersetzen. Das Terminal-Fenster bitte geöffnet lassen! Die Verbindung kann mittels der Tastenkombination Strg + C beendet werden.

2) Konfiguration des SOCKS-Proxys unter OS X

Hierzu wird im Bereich Systemeinstellung/Netzwerk eine separate Umgebung eingrichtet, um bequem zwischen normalem Netzwerkprofil und SSH-Lösung umschalten zu können.

Im Apfel-Menü den Punkt „Systemeinstellungen“ öffnen und das Icon „Netzwerk“ anklicken:

Bildschirmfoto 2016-04-10 um 17.09.51

„Umgebungen bearbeiten“ selektieren. Nun das Zahnrad-Symbol wählen und „Umgebung duplizieren“ wählen:

Bildschirmfoto 2016-04-10 um 17.11.04

Bildschirmfoto 2016-04-10 um 17.11.58

Einen Namen für die neue Umgebung wählen, z.B. SSH-Proxy und mit „Fertig“ abschließen:

Bildschirmfoto 2016-04-10 um 17.14.56

Anschließend auf „Weitere Optionen“ klicken und den Reiter „Proxies“ wählen:

Bildschirmfoto 2016-04-10 um 17.17.59

Nun den Eintrag „SOCKS-Proxy“ auswählen und als Server localhost und Port 8080 eintragen:

Bildschirmfoto 2016-04-10 um 17.24.42

Mit „Ok“ abschließen und mit „Anwenden“ aktivieren.

Fertig! Ob alles funktioniert, lässt sich z.B. in Safari / Firefox / Chrome über https://www.whatismyip.com testen. Hier sollte nun die IP-Adresse des Servers aufgelistet werden.

3) Wechsel zur regulären Konfiguration

Um wieder mit den normalen Einstellungen ohne SSH-Proxy zu surfen, einfach im Bereich Systemeinstellungen / Netzwerk auf die Umgebung „Automatisch“ schalten und mit „Anwenden“ bestätigen. Der ssh-Tunnel im Terminal kann nun via Strg + C beendet werden.

Programmierprojekt: WoW-Addon-Updater

WoW-Addon-Updater-Logo

Sorry für die lange „Durststrecke“ im Blog, ich komme leider nur recht sporadisch zum Schreiben. Heute möchte ich für die Interessierten mein kleines Programmierprojekt vorstellen.

Vorweg: Wer mich kennt, sei es nun von meinem Blog oder persönlich, weiß das ich seit jeher Spaß am Programmieren habe. Meine ersten Gehversuche erfolgten bereits in den 90er-Jahren mit QBASIC unter DOS und VisualBasic unter Windows; ich hatte viel Spaß daran, die ersten eigenen kleinen Programme zu schreiben. Über die Jahre habe ich in diverse Programmiersprachen und deren Dialekte hinein geschnuppert, neben C/C++ sagt mir (Free-) Pascal am meisten zu, insbesondere in Verbindung mit der IDE Lazarus, dessen Plattformunabhängigkeit mir sehr gefällt und die ich zu schätzen gelernt habe.

Als erstes „größeres Projekt“ ist daraus mein „WoW-Addon-Updater“ entstanden, welchen ich an dieser Stelle gerne vorstellen möchte. Das Projekt ist auf GitHub zu finden, dort existiert auch eine Seite mit Screenshots und Binarys zum Download:

http://arndtb.github.io/WoW-Addon-Updater

Bevor es in die Details geht: Warum ausgerechnet „nur“ ein Addon-Updater für ein Spiel und keine Bildbearbeitung, Tabellenkalkulation oder Berechnungsprogramm für elliptische Satellitenbahnen? 😀

Nun, nachdem ich viele Tutorials und Übungen aus Delphi-Büchern durch hatte, musste etwas praktisches mit überschaubarer Komplexität her. Wer Über mich gelesen hat, weiß das ich zwischendurch gerne mit meiner Frau das MMORPG World of Warcraft spiele.

Die Entwickler erlauben die Anpassung des Spiele-Interfaces mittels einer LUA-API an eigene Bedürfnisse – mittlerweile gibt es kaum überschaubare Anzahl praktischer Interface-Anpassungen und Erweiterungen, hauptsächlich zu finden auf Curse.com. Die Entwickler dieser Erweiterungen sind sehr aktiv und arbeiten fleißig an Ihren Erweiterungen, was ein regelmäßiges Aktualisieren notwendig macht. Dies kann man entweder manuell über Websites oder auch via einer Software von Curse erledigen – welche leider ausschließlich für Windows zur Verfügung steht. Wer nicht unter Windows spielt, sondern wie ich unter OS X oder unter GNU/Linux hat leider Pech – hier gibt es keinen praktischen Updater. 🙁

Die Idee war also geboren – es sollte ein plattformunabhängiger Addon-Updater werden, der unter OS X, Linux und Windows läuft. Für dieses Vorhaben boten sich, wie Eingangs schon beschrieben, meine favorisierte Programmiersprache FreePascal und die Entwicklungsumgebung Lazarus an.

Nach einigen Wochen Entwicklungszeit, in welcher ich eine Menge dazugelernt habe und mich auch in Dinge wie Versionsverwaltung mittels Git ein wenig einarbeiten konnte, freue ich mich nun, Euch die Version 1.0.0 zu präsentieren. Ich stelle das Programm und dessen Sourcecode als Freie Software unter den Bedingungen der GNU General Public License (GPL) Version 3 zur Verfügung.

WAU_1.0.0_OSX-2

WoW-Addon-Updater 1.0 (Vivienna)
Copyright (C) 2016 Arndt Braier – dev@braier.net

Der WoW-Addon-Updater dient zur Installation und Aktualisierung von Interface-Erweiterungen (= Addons) des MMORPGs World of Warcraft. Dieses Programm dient als Alternative zur Applikation „Curse Client“, welche derzeit nur unter Microsoft Windows zur Verfügung steht.

Die Idee entstand als Hobby aus dem Wunsch heraus, eine plattformunabhängige grafische Lösung zur Aktualisierung eines Addon-Bestandes zu entwickeln, welche unter Microsoft Windows, GNU/Linux und Mac OS X lauffähig ist. Das Resultat wurde unter den 64 Bit-Versionen von Windows 7, Ubuntu 14.04 (LTS) „Trusty Tahr“, Kubuntu 15.10 „Wily Werewolf“, Arch Linux und Mac OS X El Capitan 10.11 erfolgreich getestet.

Das Programm unterstützt derzeit zwei Sprachen: Deutsch und Englisch.

Der Addon-Bestand wird in einer tabellarischen Übersicht verwaltet und in einer XML-basierten Textdatei neben den individuellen Einstellungen des Programms gespeichert. Von der Addon-Datenbank werden automatisch Backups erzeugt, um im Fehlerfall eine spätere Wiederherstellung zu ermöglichen.

Addon-Einträge können komfortabel hinzugefügt und entfernt werden. Bei der Überprüfung auf neue Versionen werden die neuen oder geänderten Versionen farblich hervorgehoben. Diese können im Anschluß installiert bzw. aktualisiert werden, einzelne Addons können zuvor per Selektion aus- oder abgewählt werden. Der Fortschritt einzelner Programmoperationen wird mittels einer Statuszeile angezeigt.

Ich hoffe, das Ihnen das Programm gefällt und Sie dieses nützlich finden. Für Ihre Vorschläge, Lob und Kritik sowie jeglicher Art von Feedback bin ich stets offen, bitte schreiben Sie mir einfach eine Email unter

Dieses Programm wurde in FreePascal 2.6.4 (http://www.freepascal.org) mit Unterstützung der Entwicklungsumgebung Lazarus 1.4.4 (http://www.lazarus-ide.org/) geschrieben und verwendet das Package „Internet Tools“ (http://www.benibela.de/sources_en.html#internettools) von Benito van der Zander.

Das Programm WoW-Addon-Updater ist freie Software. Sie können es unter den Bedingungen der GNU General Public License, wie von der Free Software Foundation veröffentlicht, weitergeben und/oder modifizieren, entweder gemäß Version 3 der Lizenz oder (nach Ihrer Option) jeder späteren Version.

Die Veröffentlichung dieses Programms erfolgt in der Hoffnung, daß es Ihnen von Nutzen sein wird, aber OHNE IRGENDEINE GARANTIE, sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT FÜR EINEN BESTIMMTEN ZWECK. Details finden Sie in der GNU General Public License.

Sie sollten ein Exemplar der GNU General Public License zusammen mit diesem Programm erhalten haben. Falls nicht, siehe .

Curse Client und curse.com sind Warenzeichen von Curse Inc.

World of Warcraft, Warcraft und Blizzard Entertainment sind Marken oder eingetragene Marken von Blizzard Entertainment, Inc. in den USA und/oder in anderen Ländern.

Vielleicht habt Ihr Lust, Euch das Ganze mal anzuschauen – über Feedback würde ich mich freuen 🙂