Das könnte dich auch interessieren: DIY Powerbank mit Spannungsregler und Voltmeter

Liste der Komponenten

Für die Darstellung der Funktion habe ich mich für einen kleinen Testaufbau entschlossen. Für meinen Testaufbau benötige ich folgendes:

• Hohlbuchse 5,5 x 2,1 (1.0.1)
• Voltmeter (1.0.2)
• 5V Netzteil (1.0.3)
• Hohlbuchsen Halter (1.0.4)
• Hohlbuchsen Brücke (1.0.5)
• Diverse Kabel (1.0.6)

Montageanleitung für Halter und Brücke

Der erste Schritt besteht darin, den Halter (1.0.4) und die Brücke (1.0.5) mit dem 3D-Drucker zu drucken. Nach dem Säubern der Druckteile schneide ich in den Halter zwei M2-Gewinde (siehe 2.0.1). Wer lieber mit selbstschneidenden Schrauben arbeitet, kann diesen Schritt überspringen. Danach wird die Hohlbuchse in das große Loch der Brücke geschoben (2.0.2) und mit der Mutter an der Vorderseite der Brücke fest verschraubt (2.0.3). Die Montage der Brücke am Halter ist ebenfalls sehr einfach: Man schiebt die Brücke mit den Aussparungen rechts und links über die beiden Zylinderflächen am Halter (2.0.4) und befestigt sie mit M2-Schrauben (2.0.5). Halter und Brücke mit montierter Hohlbuchse bilden eine sehr stabile Einheit, die große Kräfte aufnehmen kann. Wenn alles korrekt montiert ist, sollte die Hohlbuchse nicht überstehen, sondern 0,3 bis 0,5 mm versenkt sein.

Verkabelung und Verlötung der Hohlbuchse

Kommen wir nun zum Kern dieses Artikels: dem Verkabeln beziehungsweise Verlöten der Hohlbuchse. Hierbei verwende ich vorkonfektionierte Stecker und Buchsen, die bereits verpresste Kabel und eine Zugentlastung enthalten. Die Farbmarkierung der Kabel ist ebenfalls praktisch, da rot für Plus und schwarz für Minus steht (3.0.1).

Die Hohlbuchse mit Schaltfunktion hat in der Regel drei Lötlaschen. Der Minuspol wird immer geschaltet, das heißt, im Bild 3.0.2 entspricht dies der Nummer zwei. Hier wird auch der Minuspol der primären Energieversorgung, wie z.B. Batterie oder Akkumulator, angelötet. Die Lötlasche Nummer eins ist für den gemeinsamen Pluspol vorgesehen; alle Plus-Verbindungen werden hier angelötet. Der Minuspol zu den Verbrauchern im Gerät wird an die Lötlasche Nummer drei gelötet. Im Bild 3.0.3 ist die komplette Verlötung der Hohlbuchse dargestellt.

Montage und Anschluss

Nach der erfolgreichen Verlötung kann nun mit dem restlichen Versuchsaufbau fortgefahren werden. Zuerst wird der Halter mit der verlöteten Hohlbuchse auf eine Holzplatte geschraubt (4.0.1). Anschließend werden die beiden Mini-Voltmeter auf der Holzplatte befestigt (4.0.2). Die Mini-Voltmeter sind eine Kreation von Nerd-Corner. Wer Interesse an solchen Gehäusen hat, kann unter folgendem Link den entsprechenden Artikel lesen und die STL-Dateien herunterladen.

Nun schließe ich die an der Hohlbuchse verlöteten Kabel an die Mini-Voltmeter an (siehe Bild 4.0.2, rosa Rahmen). Als nächstes verbinde ich die primäre Stromquelle mit meinem 5V-Netzteil und schalte es ein (siehe Bild 4.0.3, gelber Rahmen). Nach dem Einschalten des Netzteils liegt an beiden Mini-Voltmetern eine Spannung an: 5,35 Volt am Versorger (roter Kreis) und 5,28 Volt beim Verbraucher (grüner Kreis).

Einbindung der zweiten Stromquelle

Da der Strom sauber über die Hohlbuchse zum Verbraucher fließt, kommt jetzt die zweite Stromquelle ins Spiel. Diese betreibe ich mit 12V, um einen deutlichen Unterschied zur primären Stromversorgung zu haben. Im Bild 4.1.1 ist die zweite Stromversorgung mit 12,2 Volt dargestellt (türkiser Rahmen).

Nun stecke ich die zweite Stromversorgung mit 12 Volt in die Hohlbuchse (Bild 4.1.2, blauer Rahmen). Nach einer kurzen Verzögerung ändert sich der Wert am Mini-Voltmeter des Verbrauchers auf 12 Volt (grüner Rahmen). An der primären Stromversorgung hat sich nichts geändert; sie bleibt eingesteckt und eingeschaltet (roter Rahmen). Der Wert liegt weiterhin bei 5,34 Volt, was zwar 0,01 Volt niedriger ist als vor dem Einstecken der zweiten Stromversorgung, aber dies liegt an den Schwankungen des 5V-Netzteils.

Als letzten Schritt entferne ich das 5 Volt Netzteil vom primären Stromkreis um zu überprüfen, ob wirklich keine Spannung am primären Stromkreis anliegt. Am Bild 4.2.1 im gelben Rahmen bleibt es dunkel und somit war der Versuch erfolgreich!

Dateien zum Herunterladen

• Holstecker Halter und Brücke

The post Hohlbuchse als Schalter verwenden appeared first on Nerd Corner.

Das könnte dich auch interessieren: Wie man einen Lüfter mit einem Arduino steuert!

Liste der Komponenten

• Arduino IDE (Entwicklungsumgebung)
• WeMos D1 R2

Unterschiede zwischen dem WeMos D1 R2 und dem Arduino UNO R3

Ein Arduino UNO R3 ähnelt optisch sehr dem WeMos D1. Der Hauptunterschied ist, dass der D1 ein ESP2866 WIFI Modul auf seiner Platine integriert hat. Dadurch hat man die Möglichkeit den D1 mit dem Internet zu verbinden. Grob gesagt ist der D1 ein wlanfähiger Arduino!

Man sollte allerdings beachten, dass die Taktfrequenz der beiden Prozessoren unterschiedlich sind. Der Arduino besitzt einen 8 bit Atmel Prozessor und der D1 einen Wlan fähigen ESP8266 Prozessor mit 32 bit Taktfrequenz. Die Pins des D1 sind zwar ähnlich angeordnet wie bei einem Arduino UNO, aber unterscheiden sich in der Betriebsspannung. Bei einem Arduino UNO liegt die Spannung der Pins bei 5V und bei dem D1 bei 3,3V. Zusätzlich ist aber auch auf dem D1 ein 5V Ausgang vorhanden. Aufgrund der Spannungsunterschiede an den Pins sollte man nicht blindlings ein Arduino Shield auf einen D1 stecken. Es empfiehlt sich zuerst die Kompatibilität zu prüfen!

Außerdem sollte man beachten, dass der D1 im Gegensatz zum Arduino nur einen analog Pin besitzt und zusätzlich die Anzahl der digitalen Pins unterschiedlich ist. Der Arduino besitzt 20 digitale Pins und der D1 nur 16 digitale Pins. Allerdings haben die digitalen Pins des D1 mehr nützliche Zusatzfunktionen.

Bitte beachten: Auch die Bezeichnung der digitalen D1 Pins unterscheidet sich von denen des Arduino und müssen daher softwaretechnisch angepasst werden.

Als letztes noch der Hinweis, dass sich der USB Anschluss ebenfalls unterscheidet. Im Gegensatz zum Arduino besitzt der D1 den deutlich verbreiteteren Micro USB Standard.

Einrichtung des D1

Die Arduino IDE öffnen und den D1 mit dem Computer verbinden. Unter Tools > Port den entsprechenden COM Port des D1 auswählen. Sollte der D1 hier nicht erkannt werden liegt das vermutlich an einem fehlenden Treiber.

Wenn nun der passende COM Port ausgewählt wurde und man einen Beispiel sketch auf den D1 lädt wird vorraussichtlich folgende Fehlermeldung auftauchen: „An error occurred while uploading the sketch avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x2e“. Der Grund für diesen Fehler ist, dass das falsche Board ausgewählt wurde. Der Name des ausgewählten Boards taucht rechts unten in der IDE auf:

Um den D1 auswählen zu können muss der Boardmanager für den ESP8266 noch hinzugefügt werden. Hier folgenden Link in Preferences > Board Manager einfügen: http://arduino.esp8266.com/stable/package_esp8266com_index.json

Anschließend in Tools > Board > Board Manager nach ESP8266 suchen und die neuste Version installieren:

Jetzt in Tools > Board > ESP8266 Boards > LOLIN (WEMOS D1 R2 &mini) auswählen:

Nun kann man wieder ein Beispielprojekt unter File > Examples > 01.Basics > Blink auswählen und mit einem Klick auf Upload funktioniert das Ganze. Das Beispielprojekt lässt jetzt die blaue LED auf dem ESP8266 Modul blinken.

Achtung: Dieses Setup war einmalig für die erstmalige Benutzung und muss nicht erneut wiederholt werden!

WeMos D1 mit dem Internet verbinden

Der Programmaufbau entspricht dem eines regulären Microcontrollers wie man es auch vom Arduino kennt. Es gibt eine setup() Funktion, welche nur einmal direkt zum Programmstart aufgerufen wird und eine loop() Funktion, welche nach dem setup() in Dauerschleife läuft.

Als erstes wird die ESP WiFi Bibliothek benötigt. Diese wird mittels #include <ESP8266WiFi.h> eingebunden. Sobald der ESP mit Strom versorgt wird, soll eine WLAN-Verbindung hergestellt werden. Daher wird der Code in die setup() Funktion geschrieben.

Wir brauchen den Seriellen Monitor um uns den aktuellen Stand des Verbindungsaufbaus anzeigen zu lassen. Die Baudrate kann selbst festgelegt werden. Für den D1 nehme ich 115200. Den Seriellen Monitor findet man unter Tools > Serial Monitor. Im Fenster des Seriellen Monitors kann rechts unten die Baudrate eingestellt werden. Bitte hier ebenfalls 115200 auswählen. Wählt man nicht die gleiche Baudrate wie im setup() definiert, werden einem nur unleserliche Sonderzeichen angezeigt.

Um sich mit dem Wlan zu verbinden reicht der einfache Befehl WiFi.beginn(„WlanName“, „WlanPasswort“). Es kann sehr hilfreich sein wenn man sich hier gleich die IP Adresse des D1 anzeigen lässt. Dazu nutzt man den Befehl WiFi.localIP()

#include <ESP8266WiFi.h>

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

}

void loop() {
  // put your main code here, to run repeatedly:

}

Der D1 als Webserver und DNS-Server

Nach den bisherigen Schritten ist der D1 zwar mit dem WiFi verbunden, aber selbst noch nicht über einen Browser erreichbar. Damit der D1 bequem über den Browser angesteuert werden kann braucht man die #include <ESP8266WebServer.h> Bibliothek. Anschließend wird mit dem Befehl ESP8266WebServer server(80) ein Webserver Objekt erstellt und der Port 80 festgelegt. Der Server lässt sich nun mit dem Befehl server.begin() starten. Damit der D1 zu jederzeit prüfen kann, ob Anfragen zu bearbeiten sind, wird der server.handleClient() in die loop() Funktion geschrieben.

Gibt man nun die IP Adresse des D1 in einem Browser ein, von einem Gerät, dass sich im selben WiFi befindet, ist der D1 bereits erreichbar. Es wurde nur noch nicht spezifiziert was bei einem Aufruf des D1 passieren soll.

Man kann sich hier auch vorgefertigte Funktionen anzeigen lassen. Für den Anfang beispielsweise einen Satz, wenn der Link nicht definiert wurde, oder einen Text für einen custom Link. Es können auch eigene Funktionen für bestimmte Links ausgeführt werden.

server.onNotFound([](){ 
  server.send(404, "text/plain", "Link was not found!");  
});
 
server.on("/", []() {
  server.send(200, "text/plain", "Landing page!");
});
 
server.on("/custom", []() {
  server.send(200, "text/plain", "Just a custom route!");
  ownFunction();
});

Die Webserver Einrichtung ist jetzt abgeschlossen. Da es aber meist sehr nervig ist jedesmal die IP-Adresse des D1 in den Browser einzutippen bzw. die sich auch ändern kann, macht es Sinn dem DNS des D1 einen Namen zuzuweisen. Dafür wird wieder eine Bibliothek verwendet, welche mittels #include <ESP8266mDNS.h> eingebunden wird. Der DNS wird einmalig definiert und daher in die setup() Funktion geschrieben. Um den DNS Namen festzulegen, nutzt man die Methode MDNS.begin(DNS Name), beispielsweise MDNS.begin(nerd-corner). Zusätzlich muss noch MDNS.update() in die loop Funktion geschrieben werden.

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

ESP8266WebServer server(80);

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

  if (MDNS.begin("nerd-corner")) {
    Serial.println("DNS started, available with: ");
    Serial.println("http://nerd-corner.local/");
  }

  server.onNotFound([](){ 
    server.send(404, "text/plain", "Link was not found!");  
  });
 
  server.on("/", []() {
    server.send(200, "text/plain", "Landing page!");
  });
 
  server.on("/custom", []() {
    server.send(200, "text/plain", "Just a custom route!");
    ownFunction();
  });

  server.begin();

}

void loop() {
  server.handleClient();
  MDNS.update();

}

void ownFunction(){ //go to "IP-Adress/custom" to call this function
  Serial.println("Own function was called");

}

Anschließend kann man im Browser http://nerd-corner.local eingeben und man erreicht den D1. Bitte beachten, dass die Endung immer „.local“ sein muss! Manche Android Geräte unterstützen mDNS nicht, dann muss weiterhin die tatsächliche IP Adresse angegeben werden. Jetzt steht der Verwendung für eigene Projekte eigentlich nichts mehr im Weg! Hier findet Ihr ein paar spannende Anwendungsbeispiele: https://makesmart.net/tag/d1-mini/

Beispielprogramm zum Ein- und Ausschalten der OnBoard LED

Zum Abschluss des Blogposts noch ein simples Beispielprogramm bei dem wir das bisher gelernte anwenden. Wir schreiben zwei zusätzliche Funktionen. Eine um die fest verbaute BuiltIn Led einzuschalten und eine Funkton zum Ausschalten. Ein kleiner Hinweis, im Gegensatz zum Arduino wird die LED mit digitalWrite(LED_BUILTIN, LOW) eingeschalten statt ausgeschalten, also genau invertiert!

Die Funktionen können über http://nerd-corner.local/on und http://nerd-corner.local/off aufgerufen werden. Anbei der vollständige Programmcode:

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

ESP8266WebServer server(80);

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

  if (MDNS.begin("nerd-corner")) {
    Serial.println("DNS started, available with: ");
    Serial.println("http://nerd-corner.local/");
  }

  server.onNotFound([](){ 
    server.send(404, "text/plain", "Link was not found!");  
  });
 
  server.on("/", []() {
    server.send(200, "text/plain", "Landing page!");
  });
 
  server.on("/on", []() {
    server.send(200, "text/plain", "Switching LED on!");
    switchLedOn();
  });

  server.on("/off", []() {
    server.send(200, "text/plain", "Switching LED off!");
    switchLedOff();
  });

  server.begin();


  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  server.handleClient();
  MDNS.update();

}

void switchLedOff(){ 
  digitalWrite(LED_BUILTIN, HIGH);   // turn the D1 LED off 
}

void switchLedOn(){ 
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED on 
}

The post WeMos D1 R2 erste Schritte und Wlan integration appeared first on Nerd Corner.

Das könnte Sie auch interessieren: Entwicklung eines Step-Down Moduls

Liste der Bauteile:

• 1x Battery Shield V3
• 6x Linsenkopfschrauben M2x8
• 1x Hohlstecker 5,5×2,1
• 6x Flachkopfschraube M2x6
• 1x LiPo Akku 18650

Untersuchung des Battery Shield V3

Nachdem das Battery Shield V3 bei mir angekommen war musste ich als erstes die Eigenschaften genau untersuchen.  Die Tests habe ich mir vorher überlegt und orientieren sich in erster Linie an meine Anwendungsfälle. Da ich natürlich kein Prüfinstitut bin habe ich die Tests so einfach wie möglich gehalten.

Zunächst habe ich die Hauptfunktion, das Aufladen eines LiPo Akkus, getestet. Der Ladevorgang am Modul wird mit Hilfe einer LED signalisiert. Rot bedeutet, dass der Akku aufgeladen wird und Grün bedeutet, dass der Ladevorgang beendet ist. Leider befinden sich die LEDs auf der Unterseite des Moduls und sind nicht gut sichtbar.

Laut den Angaben des Herstellers bzw. des online Händlers beträgt die Ladespannung 4,2 V und der Ladestrom 500 mA. Um diese Werte zu überprüfen, habe ich den Ladezustand des eingesetzten Akkus gemessen und notiert. Der Ladezustand war ungefähr bei 1100 mAh. Die gesamte Kapazität des Akkus beträgt 3000 mAh. Daraus folgt, dass die Differenz zwischen vollständig geladen und teilgeladen 1900 mAh beträgt. Um die vorraussichtliche Ladedauer zu erhalten, wird dieser Wert durch die vom Hersteller angegebenen 500 mA geteilt. Die berechnete Ladedauer ergab somit 4 h. Als Netzteil wird ein Standard Netzteil mit 5V und 1A Ladestrom verwendet. In der Realität betrug die Dauer des Ladens 4 h und 15 min. Das ist nahe an der Theorie und somit in Ordnung. 

Bitte beachten: Für diesen Test nie einen ganz neuen LiPo Akku verwenden, sondern einen der schon einige Ladezyklen hinter sich hat. Ansonsten ist das Ergebnis nicht sehr aussagekräftig. 

Untersuchung der Modul Spannungen

Im zweiten Test wurden die unterschiedlichen Spannungen untersucht, welche das Modul zur Verfügung stellt. Diesen Test habe ich in zwei Phasen unterteilt. In der ersten Phase (Bild Test 2_1) wird das Modul ohne LiPo Akku verwendet. Anschließend wird in der zweiten Phase ein LiPo Akku eingesetzt.

Wichtig ist hierbei natürlich die richtige Auswahl der Verbraucher, um den Test so realitätsnah wie möglich durchzuführen. Für den USB-A Anschluss habe ich sowohl einen Lastwiderstand mit 1 A als auch mit 2 A ausgewählt. Dieser keramische Lastwiderstand ist ideal, da eine USB Schnittstelle vorhanden ist und die LED grün leuchtet wenn 5 Watt verbraucht werden. Bei 10 Watt leuchtet die LED rot.

Für die 3 x 5 V Ausgänge habe ich an zwei Ausgängen 5V LED Streifen gelötet und am dritten 5V Ausgang hängt ein von mir konstruiertes Step-Down Modul LM2596S, das auf 2V eingestellt ist, um eine 10 mm RGB Led zu versorgen. An die 3 x 3 V Ausgängen wurden jeweils 3 V LEDs gelötet. Für diesen Test wurde ein 5 V (18 Watt) Netzteil verwendet.

Das Modul im Netzbetrieb ohne LiPo Akku

Es passierte eigentlich nach dem Anschließen der Verbraucher und den Netzteil nicht sonderlich viel. Es leuchtete nur die modulinterne LED rot. Erst als ich den Keramik-Lastwiderstand deaktiviert habe leuchtete einer der 5 V LED Streifen und die mit dem Step-Down verbundene RGB Diode (Gelb markiert in Bild Test2_1).

Bei der anschließenden Messung der Ausgänge wurden folgende Werte festgestellt: Bei den 5 V Ausgängen wurde eine Spannung von 3,24 V gemessen und bei den 3 V Ausgängen 2,28 V. Die gesamte Strombereitstellung des Moduls ohne eingesetzten LiPo Akku liegt bei ca. 11 mA. Das sollte für eine kleine LED ausreichen.

Das Modul mit LiPo Akku

Für die Phase 2 wurden alle Verbraucher entfernt und ein LiPo Akku (SAMSUNG INR18650-35E SDI KL59) in das Modul eingesetzt. Wie auf den Bildern zu erkennen ist wurden Steckverbindungen angebracht. Das liegt daran, dass dieses Modul keinen Schalter für den LiPo Akku besitzt und somit die Last sofort auf den LiPo Akku angelegt wird. Es ist einfach unangenehm einen Akku oder jegliche Batterie unter Last einzulegen bzw. einzustecken.

Alle Verbraucher sind in Phase 2 im Vollmodus und funktionieren einwandfrei. Zusätzlich wird sogar noch der LiPo Akku aufgeladen. Zweifel sind an den 5 V Ausgängen bezüglich der Ampereangaben (4 A) angebracht. Angesichts der Ampere Zahlen des LiPo Akkus ist das zwar möglich, aber es erscheint mir sehr hoch für eine USB Micro Versorgung. Meine Empfehlung ist das Modul mit weniger als 4 Ampere zu beanspruchen.

Tiefenentladeschutz

Der dritte und letzte Test ist eher trivial. Um den Tiefenentladeschutz zu prüfen wurde nur der Keramik Lastwiderstand mit 5 Watt aktiviert und keine Netzversorgung angeschlossen. Dadurch wird der LiPo Akku entladen und wenn der Tiefenentladeschutz des Moduls den Entladeprozess eigenständig beendet ist der Test erfolgreich. Das war der Fall. Es war genügend Restkapazität vorhanden. Allerdings sollten solche Stresssituationen für den LiPo Akku trotzdem vermieden werden. 

Gehäuse für das Battery Shield V3

Natürlich konnte ich es nicht lassen noch ein Gehäuse für das Battery Shield V3 Modul zu konstruieren. Neben dem normalen 5 V USB Ausgang, der über einen extra Schalter ein- und ausgeschalten werden kann, habe ich zusätzlich noch einen konstanten 3V Ausgang mit einer 5,5 x 2,1 Buchse  in das Gehäuse konstruiert.

Das Gehäuse kann am Ende des Blogbeitrags im STL-Format heruntergeladen werden.

Kleiner Nachteil

Der On/OFF Schalter schaltet nur den USB Port. Die 3 x 3 V und 3 x 5 V Lötstellen können nicht über diesen Schalter ein und ausgeschaltet werden.

Für meine Elektronik Projekte ist dieser Nachteil nicht wirklich dramatisch, da ich in erster Linie den USB Port nutze. Außerdem können an die Lötstellen auch zusätzliche Schalter eingelötet werden.

Dateien zum Herunterladen:

• Datenblatt Battery Shield V3 (von AZ Delivery)
• 3D Druck Gehäuse

The post Review Battery Shield V3 – Die DIY Powerbank mit LiPo Akku 18650 appeared first on Nerd Corner.

In diesem Beitrag zeigen wir dir wie sich die Drehzahl des Lüfters über die Spannung steuern lässt. Hierfür benötigt man lediglich die + und – Anschlüsse des Lüfters. Auch wenn es sich bei deinem Lüfter um einen Computerlüfter mit 3 oder 4 Anschlüssen handelt, brauchst du nur die + und – Anschlüsse.

Da wir hier mit einem 12V Lüfter arbeiten und der Arduino maximal 5V Ausgangsspannung leisten kann, ist eine externe Stromversorgung notwendig. Solltest du mit einem 5V Lüfter arbeiten, dann reicht natürlich die Ausgangsspannung des Arduino.

Das könnte Dich auch interessieren: Arduino per Bluetooth App steuern.

Liste der Bauteile

• Arduino Mega
• Steckbrett
• 12V Spannungsversorgung
• 12V Lüfter
• Jumper Kabel
• 220 Ohm Widerstand
• NPN Transistor

Verkabelung der Arduino Lüfter Steuerung

Für die Verkabelung gehen wir entsprechend der Skizze vor. Die 12V Spannungsversorgung wird an das Breadboard angeschlossen. Wir verbinden das – des Breadboards mit GND des Arduinos (kurze blaue Kabelverbindung im Bild). Anschließend wird das + des Breadboards mit Vin des Arduino Megas verbunden (rotes Kabel zwischen Arduino und Breadboard).

Würden wir unsere 12V Spannungsversorgung in die Steckdose stecken. Dann wäre unser Arduino jetzt bereits mit Strom versorgt. Es ist keine zusätzliche Stromversorgung für den Arduino notwendig. Der Vin Eingang reguliert die 12V automatisch auf die notwendigen 5V für den Arduino.

Ins Breadboard stecken wir jetzt unseren NPN Transistor. Die Basis (B) verbinden wir mit dem 220 Ohm Widerstand und anschließend auf den Pin 13 (gelbe Verbindung im Bild). Den Kollector (C) des Transistors verbinden wir direkt mit dem negativen Anschluss des Lüfters (schwarzes Lüfter Kabel). Der positive Lüfteranschluss wird mit dem + des Breadboards verbunden. Den Emitter (E) des Transistors verbinden wir mit dem – des Breadboards. Jetzt fehlt nur noch der Arduino Code.

Der Code für die Arduino Lüfter Steuerung

Der Arduino Code ist absolut simpel und lässt sich ohne großen Aufwand in jedes bestehende Arduino Programm integrieren. Da wir die Basis des Transistors mit Pin 13 verbunden haben, definieren wir diesen als „motorPin“. Über die Variable „speed“ lässt sich dann die Drehzahl des Lüfters steuern. Für die Drehzahl kann ein Wert zwischen 0 und 255 gewählt werden. Je nach Lüfter Modell ist aber eine Mindestdrehzahl notwendig, damit der Lüfter anläuft.

The post Arduino Lüfter Steuerung appeared first on Nerd Corner.

Das könnte Dich auch interessieren: Wie man eine Arduino Lüftersteuerung programmiert.

Liste der Bauteile

• Arduino Mega
• Steckbrett
• 12V Spannungsversorgung
• 12V Lüfter
• Jumper Kabel
• 220 Ohm Widerstand
• NPN Transistor
• Bluetooth Modul HC-05 oder HC-06

Verkabelung

Für die Verkabelung gehen wir analog zu unserem ersten Beitrag zur Lüfter Steuerung vor. 12V Spannungsversorgung wird an das Breadboard angeschlossen. Wir verbinden das – des Breadboards mit GND des Arduinos (kurze blaue Kabelverbindung im Bild). Anschließend wird das + des Breadboards mit Vin des Arduino Megas verbunden (rotes Kabel zwischen Arduino und Breadboard).

Würden wir unsere 12V Spannungsversorgung in die Steckdose stecken. Dann wäre unser Arduino jetzt bereits mit Strom versorgt. Es ist keine zusätzliche Stromversorgung für den Arduino notwendig. Der Vin Eingang reguliert die 12V automatisch auf die notwendigen 5V für den Arduino.

Ins Breadboard stecken wir jetzt unseren NPN Transistor. Die Basis (B) verbinden wir mit dem 220 Ohm Widerstand und anschließend auf den Pin 13 (gelbe Verbindung im Bild). Den Kollector (C) des Transistors verbinden wir direkt mit dem negativen Anschluss des Lüfters (schwarzes Lüfter Kabel). Der positive Lüfteranschluss wird mit dem + des Breadboards verbunden. Den Emitter (E) des Transistors verbinden wir mit dem – des Breadboards.

Zusätzlich zu diesen bereits bekannten Schritten nehmen wir das Bluetooth Modul und verbinden Ground des Moduls mit Ground vom Arduino (schwarze Verbindung). VCC des Moduls wird mit 3,3V des Arduinos Verbunden (rote Verbindung). Falls kein 3,3V Anschluss vorhanden ist, kann auch der 5V Anschluss benutzt werden. TX des Bluetooth Moduls muss mit RX des Arduinos verbunden werden (oranges Kabel). RX des Moduls muss mit TX des Arduinos verbunden werden (lilanes Kabel). Also TX zu RX und RX zu TX. Also immer zum Pendant.

Wichtig: Während der Arduino Code auf den Arduino geflasht wird muss man RX und TX abstecken. Ansonsten funktioniert der Flashvorgang nicht!

Programmierung der Android Bluetooth Classic App für den Arduino

Wir programmieren eine reine Android App mit einem HC-05 oder alternativ HC-06 Bluetooth Modul. Es handelt sich dabei um Bluetooth Classic Module. Sie können kein Bluetooth 4.0 auch Bluetooth Low Energy (BLE) genannt. Für BLE würde unser Code ganz anders aussehen. Nachfolgend die Anleitung zur Programmierung. Alle wichtigen Dateien werden ebenfalls hochgeladen.

Als Entwicklungsumgebung für die Bluetooth App Arduino Steuerung nutzen wir Visual Studio (kostenlos) für eine Xamarin.Android App. In AndroidStudio ist der Ablauf analog, allerdings ist der Code dann in Java und nicht in C#.

Auf „Neues Projekt erstellen“ klicken und „Android-App (Xamarin)“ auswählen. Zunächst ergänzen wir die Bluetooth Berechtigungen zur „AndroidManifest.xml“ Datei:

<uses-permission android: name = "android.permission.BLUETOOTH" />
<uses-permission android: name = "android.permission.BLUETOOTH_ADMIN" />

Anschließend gestalten wir das Layout der Bluetooth App Arduino Steuerung in der „activity_main.xml“ Datei. Wir brauchen 2 Buttons für „Connect“ und „Disconnect“ und einen Slider für die Drehzahlregulierung. Für den Slider setzen wir den Maximalwert auf 255 (android:max=“255″).

In der „MainActivity.cs“ fügen wir „using Android.Bluetooth“ hinzu, legen eine „BluetoothConnection“ Klasse an und setzen unsere „activity_main.xml“ Datei als Startseite. Es wird ein Bluetooth Socket kreiert für die Verbindung zum Arduino. Den exakten Code am besten aus der beigefügten Datei entnehmen. Im Wesentlichen senden wir immer ein Byte zum Arduino. Das bedeutet wir können so Zahlen zwischen 0 und 255 senden. Für die Lüfter Steuerung nehmen wir den Bereich von 0 bis 127. Der Arduino verdoppelt diesen Wert und reguliert so den Lüfter der ebenfalls in einem Bereich zwischen 0 und 255 läuft. Der restliche Bereich zwischen 128 und 255 kann für weitere Funktionen genutzt werden. Jetzt nur noch die App kompilieren und schon haben wir sie auf unserem Handy.

Der Code für die App basiert übrigens auf diesem Projekt hier: https://www.instructables.com/id/3-LED-Backlight-Xamarin-and-Arduino-With-HC05/

Arduino Code

#define motorPin 13
int received; //for the received Byte
int fanSpeed = 127; //initial speed - must be a number between 0 and 255
void setup() {
  Serial.begin(9600); //for communication with the app
  delay(3000); // small delay
  pinMode(motorPin, OUTPUT); //define motor pin as output
  analogWrite(motorPin,fanSpeed); //set the initial speed of the fan
}
void loop() {  
  while(Serial.available()) 
  {
     received = Serial.read(); //received Byte    
     Serial.println(received); //if the arduino is connected to the PC, than you can check the received Byte
     switch (received)  //you can easily add new cases to customize your arduino
     {
        case 200:
            Serial.println("RESTARTED");
            break;
        default:
            if(received >0 && received <=127)
            {
              fanSpeed = (received*2); //app sends value between 0 and 127 - so we need to double it for the fan range between 0 and 255
              delay(10);
            }
            break;
     }  
  }
  analogWrite(motorPin,fanSpeed); //set the speed of the fan
}

Bitte nicht vergessen vor dem Flashen des Arduino die RX und TX Verbindung abzuziehen und danach wieder richtig zu verbinden (RX zu TX und TX zu RX)!

Da wir die Basis des Transistors mit Pin 13 verbunden haben, definieren wir diesen als „motorPin“. Über die Variable „fanSpeed“ lässt sich dann die Drehzahl des Lüfters steuern. Zu Beginn setzen wir „fanSpeed“ auf die halbe Geschwindigkeit, also 127. (Je nach Lüfter Modell ist eine gewisse Mindestdrehzahl notwendig, damit der Lüfter anläuft.)

Wir definieren uns eine Variable „received“ in der wir das von der App gesendete Byte speichern. In der setup-Funktion starten wir die Kommunikation mit „Serial.begin“ und setzen die Baudrate auf 9600. Anschließend programmieren wir eine while-Schleife in der loop-Funktion. Die while-Schleife wird aktiv immer wenn ein Byte empfangen wird. Sollte der Wert des Bytes zwischen 0 und 127 liegen, dann verdoppeln wir diesen und definieren ihn als unsere neue Lüfter Drehzahl „fanSpeed“. Sobald die while-Schleife beendet ist wird die neue Geschwindigkeit für den Lüfter eingestellt mit „analogWrite(motorPin,fanSpeed);“

Screenshots der Bluetooth App Arduino Steuerung

Bitte beachten, man muss sich zuerst in den Einstellungen mit dem Bluetooth Modul verbinden für die Bluetooth App Arduino Steuerung. Erst danach kann man sich in der App mit dem Arduino verbinden!

Download files

• Source Code Android App "FanControllerBluetooth"
• Arduino Code for the "FanControllerBluetooth" app
• Only MainActivity.cs AndroidMainfest.xml and activity_main.xml of the "FanControllerBluetooth" app

The post Android Bluetooth classic App zur Arduino Steuerung (Lüfter) appeared first on Nerd Corner.