Wettervorhersage Lampe

Viele von uns überprüfen vor dem Verlassen des Hauses die Wettervorhersage für den kommenden Tag. Ich habe dafür immer mein Smartphone benutzt und eines Tages überlegte ich, warum ich diesen Vorgang nicht einfacher und bequemer machen sollte. So kam die Idee auf, eine Raumlampe zu schaffen, die die Wettervorhersage in meiner Umgebung anzeigen und vor möglichen Niederschlägen und Windgeschwindigkeiten warnen kann.



In der Zwischensequenz zeigen Videos und Bilder die Funktionsweise dieser Lampe und detaillierte Anweisungen zu ihrer Erstellung.

Arbeitsdemonstration


Die Lampe kann die Wettervorhersage für 14 Stunden im Voraus anzeigen. Technisch befinden sich 14 horizontale Ebenen in der Lampe (RGB-LED-Streifen mit jeweils 20 LEDs). Die erste Stufe darunter ist das Wetter, das zu Beginn der nächsten Stunde sein wird. Jedes nächste Level ist plus 1 Stunde. Die horizontale Bewegung auf jeder Ebene ist die Geschwindigkeit des Windes. Es gibt auch einen Regeneffekt - die Teile am Anfang und Ende jedes Levels blinken sanft in allen Farben.

Hier ist zu beachten, dass alle Fotos und Videos in diesem Artikel durch lange Qualen entstanden sind, da die Lampe sehr stark leuchtet und ich kein sehr erfahrener Fotograf bin und meine DSLR einfach nicht so fotografieren wollte, wie es wirklich ist. Ich habe ehrlich gesagt oft versucht, aber nie das gleiche Bild wie in der Realität erreicht.



Sie können ein weiteres Video der Lampe ohne Abdeckung und ein Video ansehen, das die Anzeige des Niederschlags zeigt (die Ränder der Streifen leuchten in allen Farben).

Anforderungen und Design


Versuchen wir zunächst, die Anforderungen zu formulieren:

  • Permanente Internetverbindung. Wir benötigen eine Wettervorhersage aus dem Internet
  • Autonomie. Die Lampe sollte nicht von anderen Geräten abhängig sein
  • Die Fähigkeit, verschiedene Wetterdaten (Temperatur, Regen, Gewitter, Wind) anzuzeigen

Nach einigem Überlegen entschied ich mich für eine rechteckige Lampe, in der es 12 horizontale Ebenen mit jeweils 20 LEDs geben wird. Auf diese Weise können wir die Wettervorhersage für 12 Stunden im Voraus anzeigen. Die Farbe jeder Stufe hängt zu diesem Zeitpunkt von der Lufttemperatur ab. Gleichzeitig verfügt jede Ebene über eine ausreichende Anzahl von LEDs, um verschiedene Effekte wie Regen, Wind oder Donner anzuzeigen. Später wurde die Anzahl der Ebenen auf 14 erhöht, da zusätzliche LEDs vorhanden waren.

Eisen


Zunächst müssen Sie sich für die Plattform entscheiden: einen Echtzeit-Mikrocontroller wie Arduino oder einen vollwertigen Computer wie den Raspberry Pi mit dem Betriebssystem an Bord. Jede dieser Optionen hat ihre Vor- und Nachteile. Auf den ersten Blick ist Arduino ideal für dieses Projekt, schon allein deshalb, weil wir nicht 10 Sekunden warten müssen, bis das Betriebssystem auf dem Raspberry Pi geladen ist. Aber selbst wenn Sie Arduino verwenden, funktioniert ein sofortiger Kaltstart nicht - die Initialisierung des WLAN-Schutzschilds und die Abfrage des Wetters auf dem Server verzögern sich. Ich war auch ein wenig verwirrt über die Frage nach dem gleichzeitigen Betrieb des WLAN-Schutzes (bei der Anforderung einer Prognose für den Server) und dem Betrieb des LED-Streifens.

Wenn Sie den Raspberry Pi verwenden, haben wir wiederum nur einen Nachteil - die Startzeit.

Es wurde beschlossen, den Raspberry Pi mit einem WiFi-USB-Dongle EdiMax zu verwenden. Dieser Dongle wurde von mir in anderen Projekten verwendet und hat sich recht gut bewährt.

Als nächstes müssen Sie geeignete Lichtquellen finden. Grob geschätzt benötigen wir mindestens 240 LEDs (12 Stufen mit jeweils 20 LEDs). Die Möglichkeit, dass sie alle einzeln verlötet werden müssen, wurde nicht einmal in Betracht gezogen. Unsere Wahl ist nicht groß: entweder LED-Panels oder LED-Streifen. Die Paneele sind perfekt für diejenigen, die eine kleine Lampe ohne verschiedene Krümmungen auf der Oberfläche wünschen. Ich habe mich für den LED-Streifen entschieden, weil ich eine mittelgroße Lampe bauen wollte.

So wurde ein 2 Meter langer RGB-LED-Streifen mit einer Pixeldichte von 144 Stück pro Meter bestellt. Dieses Band verfügt über adressierbare LEDs (digital adressierbarer LED-Streifentyp). Dies bedeutet, dass wir ein Signal so erzeugen können, dass jede LED ihre eigenen Daten empfängt und die Farbe anzeigt, die sie haben soll. Verantwortlich dafür ist der WS2811-Chip, der sich in jeder LED auf dem Band befindet. Da das Band insgesamt 288 LEDs enthält, wurde beschlossen, diese maximal zu verwenden und 14 Pegel von 20 LEDs zu erzeugen.

Es ist zu beachten, dass der Raspberry Pi an seinen GPIO-Ports nur 3,3 Volt abgibt, für das Band jedoch ein 5-Volt-Steuersignal benötigt . Wir brauchen also einen Spannungswandler (Pegelwandler-Chip). Ich habe 74AHCT125 verwendet.

Anschlussplan (wurde entnommen ausAdafruit Tutorial ):



Eine Spenderlampe mit den Maßen 60 x 20 cm wurde in einem nahegelegenen Geschäft mit der Erwartung gepflegt und gekauft, dass wir dort ein Netzteil für den LED-Streifen platzieren müssten. Da wir 280 RGB-LEDs + Raspberry Pi erhielten, wurde ein 5-Volt-10-Ampere-Block in einem recht kompakten Paket bestellt.

Es ist an der Zeit, all dies in eine Lampe zu stecken. Mit dem Netzteil war der Raspberry Pi alles klar. Sie können nicht sagen, wie 14 Segmente mit LEDs befestigt werden sollen, die zuvor zusammengelötet werden mussten. Die LEDs sollten einen gewissen Abstand von der matten Abdeckung haben, da sie sonst sichtbar sind und das Licht zu stark ist.

Die ursprüngliche Idee war, Aluminiumstreifen zu verwenden und Klebebandstücke daran zu kleben. Aber nachdem ich einen Frame gemacht hatte, wurde mir schnell klar, dass es zu lange dauern würde. Danach habe ich mich entschieden, Frames auf einem 3D-Drucker zu drucken. Wenn Sie Zugang zu einem Lasergravierer haben, erledigen Sie dies noch schneller. Im Extremfall können Sie alles von Hand erledigen - durch Ausschneiden von Holz oder Pappe (danach mehrmals kleben).

Rahmen Druck:



Die ersten Tests des Bandes auf dem Rahmen:



Wir bekamen alle notwendigen Komponenten und die Montage war an der Reihe. Der LED-Streifen wurde in Stücke von 20 LEDs geschnitten. Die Teile wurden zusammengelötet und an die Rahmen geklebt. Rahmen wurden wiederum an die Karosserie geklebt. Das Netzteil, die gesamte Verkabelung und der Raspberry Pi befanden sich zwischen den Rahmen und dem Chassis.

Lampenmontageprozess:



Ergebnis ( höhere Auflösung ):



Dienst zum Abrufen einer Wettervorhersage


Damit die Lampe funktioniert, ist ein Service erforderlich, um eine Wettervorhersage zu erhalten. Hierfür gibt es eine Vielzahl von kostenlosen und Shareware-Diensten. Zum Beispiel openweathermap.org oder forecast.io . Alle von ihnen haben ihre eigenen Einschränkungen oder einige Besonderheiten.

Eines meiner Hauptkriterien war die Möglichkeit, stündliche Wettervorhersagen für die nächsten 12+ Stunden zu erhalten. Leider kann openweathermap im kostenlosen Modus nur Wettervorhersagen für 3 Stunden zurückgeben. Ich mochte die Geschwindigkeit dieses Dienstes auch nicht, obwohl es überhaupt nicht kritisch war, da wir die Wettervorhersage nicht mehr als einmal alle halbe Stunde aktualisieren werden.

Gleichzeitig ist die Prognose nicht ganz kostenlos. Ich bin mit der Arbeitsgeschwindigkeit und der Granularität der Daten zufrieden. Es ermöglichte mir, alle Daten, die ich benötigte (Temperatur, Windgeschwindigkeit und Niederschlag), 12 Stunden im Voraus abzurufen und noch mehr mit einer Anfrage. Die Anzahl der Anfragen, die Sie stellen können, ist in einem kostenlosen Modus auf 1000 pro Tag begrenzt, dies entspricht jedoch voll und ganz meinen Anforderungen. Am Ende habe ich mich ehrlich gesagt für diese Ressource entschieden und mich nur auf meine Intuition verlassen.

Es musste entschieden werden, wie wir die Daten erhalten: über eine Zwischenressource oder direkt von forecast.io. Die vom Dienst "forecast.io" zurückgegebene JSON-Datei hat für meinen Standort ungefähr 40 Kilobyte zurückgegeben, was für mich redundant zu sein schien. Ich brauchte nur 3 Werte für jede von 12 Stunden. Aus diesem Grund habe ich mich aus zwei Gründen für meinen eigenen kleinen Dienst entschieden: um die an die Lampe gesendete Datenmenge zu minimieren und die zukünftige Erweiterbarkeit sicherzustellen, wenn ich die Datenquelle oder den Anbieter in Zukunft ändern muss. Da wir für jede Stunde nur 3 Werte (Temperatur, Windgeschwindigkeit und Niederschlag) benötigen, sind insgesamt 168 Bytes erforderlich (14 * 3 * Größe int = 4). Außerdem können Sie mit meinem Service die Koordinaten des Geländes sowie die minimalen und maximalen Temperaturen für ein bestimmtes Gelände einstellen.

Ich habe ein Java-Servlet für die Arbeit mit forecast.io geschrieben, das Werte zwischen Anforderungen zwischenspeichern kann und bei zu häufigen Anforderungen einen Wert aus dem Cache zurückgibt (um das Limit von 1000 freien Anforderungen pro Tag nicht zu überschreiten). Wir fordern nur alle 5 Minuten eine neue Vorhersage an. Die Geländekoordinaten sowie der API-Schlüssel für "forecast.io" werden vom Systemservlet übernommen. Wenn wir also das Gelände ändern müssen, können wir dies von außerhalb der Webanwendung tun.

Servlet-Code
public class ForecastServlet extends HttpServlet {
    private static final String API_KEY = System.getenv("AL_API_KEY");
    private static final int REQUEST_PERIOD = 5 * 60 * 1000;
    private static final int START_HOUR = 0;
    private static final int END_HOUR = 14;
    private static final int DATA_SIZE = 3 * 4 * (END_HOUR - START_HOUR);
    private static final int TEMP_MULTIPLY = 100;
    private static final int WIND_MULTIPLY = 100;
    private static final int PRECIP_MULTIPLY = 1000;
    private final String mutex = "";
    private final ByteArrayOutputStream data = new ByteArrayOutputStream(DATA_SIZE);
    private long lastRequestTime;
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse response) throws ServletException, IOException {
        synchronized (mutex) {
            if ((System.currentTimeMillis() - lastRequestTime) > REQUEST_PERIOD) {
                try {
                    updateForecast();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            response.setHeader("Content-Type", "application/octet-stream");
            response.setHeader("Content-Length", "" + data.size());
            response.getOutputStream().write(data.toByteArray());
            response.getOutputStream().flush();
            response.getOutputStream().close();
            lastRequestTime = System.currentTimeMillis();
        }
    }
    private void updateForecast() throws IOException {
        int maxTemp = Integer.valueOf(System.getenv("AL_MAX_TEMP")) * TEMP_MULTIPLY;
        int minTemp = Integer.valueOf(System.getenv("AL_MIN_TEMP")) * TEMP_MULTIPLY;
        BufferedReader reader = null;
        try {
            String urlTemplate = "https://api.forecast.io/forecast/%s/%s,%s";
            URL url = new URL(String.format(urlTemplate, API_KEY, System.getenv("AL_LAT"), System.getenv("AL_LON")));
            InputStreamReader streamReader = new InputStreamReader(url.openStream());
            reader = new BufferedReader(streamReader);
            JSONParser jsonParser = new JSONParser();
            try {
                JSONObject jsonObject = (JSONObject) jsonParser.parse(reader);
                JSONArray hourly = (JSONArray) ((JSONObject) jsonObject.get("hourly")).get("data");
                for (int i = START_HOUR; i < END_HOUR; i++) {
                    JSONObject hour = (JSONObject) hourly.get(i);
                    int temperature = safeIntFromJson(hour, "apparentTemperature", TEMP_MULTIPLY);
                    if (temperature > maxTemp) {
                        temperature = maxTemp;
                    } else if (temperature < minTemp) {
                        temperature = minTemp;
                    } else {
                        float tempFloat = (float) 100 / (maxTemp - minTemp) * (temperature - minTemp);
                        temperature = (int) (tempFloat * TEMP_MULTIPLY);
                    }
                    int wind = safeIntFromJson(hour, "windSpeed", WIND_MULTIPLY);
                    int precip = safeIntFromJson(hour, "precipIntensity", PRECIP_MULTIPLY);
                    data.write(intToBytes(temperature));
                    data.write(intToBytes(wind));
                    data.write(intToBytes(precip));
                }
            } catch (ParseException e) {
                e.printStackTrace();
            }
        } finally {
            try {
                if (reader != null) reader.close();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
    }
    private byte[] intToBytes(int value) {
        return ByteBuffer.allocate(4).putInt(value).array();
    }
    private int safeIntFromJson(final JSONObject data,
                                final String dataKey,
                                final int multiply) throws IOException {
        Object jsonAttrValue = data.get(dataKey);
        if (jsonAttrValue instanceof Long) {
            return (int) ((Long) jsonAttrValue * multiply);
        } else {
            return (int) ((Double) jsonAttrValue * multiply);
        }
    }
}

Es muss erklärt werden, was 5 Eigenschaften bedeuten, deren Werte wir zur Laufzeit

abfragen : AL_API_KEY - Geheimer Schlüssel der Entwicklervorhersage.io
AL_LAT, AL_LON - Koordinaten des Bereichs
AL_MAX_TEMP, AL_MIN_TEMP - Die Werte der minimalen und maximalen Temperaturen für diesen Bereich. Dies ist notwendig, um einige Bereiche des verwendeten Farbbereichs nicht zu verschwenden: Zum Beispiel in meiner Region (Texas, USA) - die Temperatur fällt nie unter Null, und ich möchte, dass die violette Farbe (die niedrigste in unserer Palette) angezeigt wird 0 und nicht -25, wie man für Moskau einstellen könnte. Daher gibt unser Service nicht die tatsächliche Temperatur zurück - er gibt ein Hundertstel Prozent zwischen AL_MIN_TEMP und AL_MAX_TEMP zurück.

Der Quellcode der Webanwendung sowie die Maven-Assembly-Datei sind im Repository github.com/manusovich/aladdin-service verfügbar.

Als Nächstes benötigen wir ein Hosting für unsere Java-Webanwendung. Ich habe mein Lieblings- Heroku ausgenutzt , aber du kannst jedes andere benutzen. Das Repository enthält bereits die zum Ausführen der Anwendung in der Heroku-Umgebung erforderliche Datei mit dem Namen Procfile.

Wenn wir also Heroku verwenden, müssen wir nur Folgendes tun:

  • Erstellen Sie eine neue Anwendung
  • Definieren Sie 3 neue Systemeigenschaften
  • Verlinken Sie es mit unserem Git-Repository
  • Erweitern Sie die Anwendung. Dazu müssen Sie Manual Deploy ausführen, während der gesamte Code automatisch aus dem Github-Repository heruntergeladen, kompiliert und gestartet wird

Jetzt kann unser Servlet ausgeführt werden, indem Sie den Link https://aladdin-service.herokuapp.com/forecast im Browser öffnen . In diesem Fall wird eine Wettervorhersagedatei (168 Byte groß) für ein bestimmtes Gebiet zurückgegeben (Eigenschaft für die Anwendung in Heroku).

Lampenseite Software


Zunächst müssen Sie entscheiden, wie wir ein Signal an unseren LED-Streifen senden. Das Band verwendet den WS2811-Chip, um die LED zu steuern. Nach einer kurzen Suche stieß ich auf ein Tutorial von Adafruit - learn.adafruit.com/neopixels-on-raspberry-pi , in dem die Bibliothek rpi_ws281x erwähnt wurde , mit der Sie lediglich ein Signal für ein Band auf der Basis von WS281x-Chips generieren können.

Ich gabelte die Bibliothek in mein Repository und fügte den erforderlichen Code zu main.c hinzu (siehe unten im Abschnitt zur Lampensteuerung), um die Entwicklung auf ein Minimum zu vereinfachen.

Ein kleiner Exkurs sollte gemacht werden und wie ich normalerweise Code für meine Projekte entwickle, die auf Raspberry Pi basieren. Ich fand die Codebearbeitung über ssh überhaupt nicht bequem. Kopieren Sie den Code auch permanent über ssh. Also erstelle ich einfach ein GitHub-Repository, lade den gesamten Code dort hoch und verwende meine Lieblings-IDE für die Entwicklung. Auf der Seite von Raspberry Pi erstelle ich ein Shell-Skript, das alle 10 Sekunden versucht, Änderungen aus dem Repository abzurufen. Wenn dies der Fall ist, stoppt das Skript das Programm, lädt Updates herunter, kompiliert alles und führt das Programm aus. Das Skript hängt beim Start. Auf diese Weise können Sie Code aus der Ferne entwickeln und gleichzeitig die Überprüfung auf Änderungen am Gerät beschleunigen. Gleichzeitig wird das WLAN-Netzwerk geladen. Wenn die Softwareentwicklung abgeschlossen ist,

Der Algorithmus ist in diesem Fall wie folgt:

  • Fordern Sie Änderungen in Git
  • Wenn es Änderungen im Repository gibt, dann
    • Code aktualisieren
    • Code kompilieren
    • Wenn die Kompilierung erfolgreich ist, dann
      • Beenden Sie die Ausführung der Anwendung
      • Neue Anwendung starten

Konfigurieren Sie RaspberryPi


  • Zunächst müssen Sie Wifi konfigurieren
  • Danach müssen wir das Repository in das Verzeichnis / home / pi / rpi_ws281x klonen (im Verzeichnis / home / pi ausführen):

    git clone https://github.com/manusovich/rpi_ws281x

    Das Shell-Skript /home/pi/rpi_ws281x/forecast.sh sollte zum Startup /etc/rc.local hinzugefügt werden:

    sudo sh /home/pi/rpi_ws281x/forecast.sh >> /home/pi/ws281.log &

Dieses Skript aktualisiert die Vorhersage, startet die Anwendung sowie die Wettervorhersage alle 10 Minuten und überprüft das Projekt-Repository alle 60 Minuten auf Änderungen. Wenn es Änderungen gibt, werden sie aus dem Repository übernommen, kompiliert und gestartet.

Skriptcode

#!/bin/bash
echo "Read forecast"
curl https://aladdin-service.herokuapp.com/forecast > /home/pi/rpi_ws281x/forecast
echo "Kill old instance..."
pkill test
echo "Run new instance..."
exec /home/pi/rpi_ws281x/test &
echo "Start pooling for changes"
C=0
while true; do
    C=$((C+1))
    # once per 10 minutes
    if [ $((C%60)) -eq 0 ]
    then
        echo "Update forecast... "
        curl https://aladdin-service.herokuapp.com/forecast > /home/pi/rpi_ws281x/forecast
    fi
    # once per one hour
    if [ $((C%360)) -eq 0 ]
    then
        echo "Check repository... "
        cd /home/pi/rpi_ws281x
        git fetch > build_log.txt 2>&1
        if [ -s build_log.txt ]
        then
            echo "Application code has been changed. Getting changes..."
            cd /home/pi/rpi_ws281x
            git pull
            echo "Bulding application..."
            scons
            echo "Kill old application..."
            pkill test
            echo "Launch new application..."
            exec /home/pi/rpi_ws281x/test &
            echo "Done"
        else
            echo "No changes in the repository ($N)"
        fi
    fi
   sleep 10s
done

Einige Punkte sollten geklärt werden:

  1. Absolute Pfade - Dieses Skript wird automatisch gestartet, und wir müssen alle Pfade angeben. Daher stellt sich heraus, dass unser Repository auf Raspberry Pi in das Verzeichnis / home / pi / rpi_ws281x geklont werden sollte. Wenn Sie einen anderen Pfad haben, müssen Sie dieses Shell-Skript aktualisieren
  2. Dieses Skript muss als Administrator ausgeführt werden, da der Bandverwaltungscode direkten Speicherzugriff verwendet und als Administrator ausgeführt werden muss

Lampensteuerung


Betrachten wir nun den Code zum Steuern von LEDs auf einem LED-Streifen. Dieser Code befindet sich in der Datei main.c und ist eine Endlosschleife sowie eine Reihe von Verfahren zum Ändern der Farbe von LEDs.

Die Hauptmethode des Programms enthält die Initialisierung der Bibliothek rpi_ws281x für das Arbeiten mit LED-Streifen und startet eine Endlosschleife zum Rendern von Zuständen:

Hauptmethodencode
int main(int argc, char *argv[]) {
    int frames_per_second = 30;
    int ret = 0;
    setup_handlers();
    if (ws2811_init(&ledstring)) {
        return -1;
    }
    long c = 0;
    update_forecast();
    matrix_render_forecast();
    while (1) {
        matrix_fade();
        matrix_render_wind();
        matrix_render_precip(c);
        matrix_render();
        if (ws2811_render(&ledstring)) {
            ret = -1;
            break;
        }
        usleep((useconds_t) (1000000 / frames_per_second));
        c++;
        if (c % (frames_per_second * 60 * 5) == 0) {
            // each 5 minutes update forecast
            update_forecast();
        }
    }
    ws2811_fini(&ledstring);
    return ret;
}

Die update_forecast-Methode liest die aktuelle Wettervorhersage aus der Datei / home / pi / rpi_ws281x / forecast.

Die matrix_render_forecast-Methode füllt die Matrix mit den aktuellen Wettervorhersagewerten. Dabei verwenden wir eine Palette von 23 Farben aus paletton.com :

ws2811_led_t dotcolors[] = {
        0x882D61, 0x6F256F, 0x582A72, 0x4B2D73, 0x403075, 0x343477, 0x2E4272, 0x29506D, 0x226666,
        0x277553, 0x2D882D, 0x609732, 0x7B9F35, 0x91A437, 0xAAAA39, 0xAAA039, 0xAA9739, 0xAA8E39,
        0xAA8439, 0xAA7939, 0xAA6C39, 0xAA5939, 0xAA3939
};

Die matrix_fade-Methode dämpft Farbschwankungen gegenüber der vorhergesagten Temperatur.

Die matrix_render_wind-Methode zeichnet eine Anregung, die sich horizontal vorwärts und rückwärts mit einer Geschwindigkeit bewegt, die der Windgeschwindigkeit * um einen Faktor entspricht.

Die matrix_render_precip-Methode zeichnet Niederschläge entlang der Ränder der Ebenen. Er benötigt einen gemeinsamen Zähler, da die Bildwiederholfrequenz insgesamt 30 Bilder pro Sekunde beträgt und es sich sehr schnell herausstellte, um die Farben zu ändern. Deshalb machen wir das nur 15 mal pro Sekunde.

Das gesamte Rendern erfolgt in der XRGB-Matrix [WIDTH] [HEIGHT]. Wir benötigen die XRGB-Struktur, um Gleitkommazahlen anstelle von Ganzzahlen für Farben zu speichern. Auf diese Weise können wir die Glätte von Übergängen erhöhen und direkt in RGB konvertieren, was wir mit der matrix_render-Methode tun

Beim Start zeigt das Programm den aktuellen Prognosewert (Temperatur, Wind und Niederschlag) in der Konsole an. Es ist zu beachten, dass der Temperaturwert der Basispunkt ist (ein Hundertstel Prozent).


pi@raspberrypi ~/rpi_ws281x $ sudo ./test
Temp: 5978, Wind: 953, Precip: 0
Temp: 5847, Wind: 1099, Precip: 0
Temp: 5744, Wind: 1157, Precip: 0
Temp: 5657, Wind: 1267, Precip: 0
Temp: 5612, Wind: 1249, Precip: 1
Temp: 5534, Wind: 1357, Precip: 1
Temp: 5548, Wind: 1359, Precip: 0
Temp: 5605, Wind: 1378, Precip: 0
Temp: 5617, Wind: 1319, Precip: 0
Temp: 5597, Wind: 1281, Precip: 0
Temp: 5644, Wind: 1246, Precip: 0
Temp: 5667, Wind: 1277, Precip: 0

Alternative Betriebsarten


Sie können das resultierende Produkt als Plattform für die Anzeige von allem betrachten. Zu Ihrer Verfügung stehen ca. 300 unabhängige LEDs und Sie entscheiden, was dort angezeigt werden soll. Sie können beispielsweise die Anzeige der Baugruppenzustände auf einem Continuous Integration Server organisieren oder einfach eine ungewöhnliche Lampe erstellen, die wie im nächsten Video mit Regenbogenfarben spielt.



Schätzung und Abschluss


Netzteil 5 Volt 10 Ampere - 25 $
2 Meter RGB-Band (144 LEDs pro Meter) - 78 $
Raspberry Pi - 30 $
Edimax Wifi USB - 8 $
3D-Rahmendruck für LED-Streifen - 15 $ pro PLA-Kunststoffspenderlampe
- 35 $

Insgesamt beliefen sich die Gesamtkosten des Produkts auf etwa 200 US-Dollar für die Herstellung zu Hause.
Ich hoffe, dieser Artikel wird Ihnen von Nutzen sein. Wenn Sie Fragen haben, können Sie diese gerne in den Kommentaren stellen.

Jetzt auch beliebt: