ioBroker-Master-Kurs
Online Video-Kurs zum Thema ioBroker und Blockly, unbegrenzt abspielbar (Internerverbindung erforderlich), Zugriff über Kundenkonto, kein Download oder Offline-Verfügbarkeit, Support per Kommentarfunktion
54,00 €
Inkl. 19% Steuern
Auf Lager
SKU
1006
Lieferzeit
Sofort Ansehen
Jetzt mal unter uns: Hast Du wirklich alles im ioBroker verstanden und weißt genau, welche Adapter, Instanzen und Blockly-Bausteine Du brauchst, um eine bestimmte Aufgabenstellung zu lösen? Du kennst alle Tricks in JavaScript und Blockly ist viel zu einfach? Dann kann ich Dir gratulieren, denn dann hast Du bereits alles, was Du brauchst.
Oder brauchst Du mehrere Anläufe, probierst viele Lösungswege aus, suchst stundenlang nach Infos in Foren und Blogs, verwirfst dann doch wieder die Hälfte und testest dann doch einen ganz anderen Weg? Das muss nicht sein - mit dem nötigen Grundwissen!
Fakt ist: Alle Informationen dieses Trainings gibt es auch verstreut im Internet. Aber
- ist Dir das Suchen und der Frust beim ausprobieren Deine Zeit wirklich wert?
- sind die veröffentlichten Code-Schnipsel in Blogs und Foren immer fehlerfrei und der beste und einfachste Ansatz?
- hast Du schon einmal Code oder Scripts kopiert, welche Du gar nicht verstanden hast?
Das können wir gemeinsam ändern. Ich nehme Dich an die Hand und wir gehen von A-Z durch die Funktionen von ioBroker. Viele praktische Beispiele kannst Du direkt für Dich übernehmen und in Dein System integrieren. Und zwar so, dass Du wirklich verstehst, was dort eigentlich passiert und wie die internen Abläufe sind.
Ich war vor einigen Jahren in genau der gleichen Situation wie Du jetzt. Man möchte in die Smart Home Welt eintauchen und das Thema selbst in die Hand nehmen! Man ist motiviert und möchte durchstarten. Leider sind extrem viele Informationen im Netz verstreut, sind komplett veraltet oder ohne jeden Zusammenhang. Der Anfang ist sehr mühsam und es geht kaum voran. Es gibt einfach keinen roten Faden.
Stell Dir vor, wie Du in Deinem intelligenten Zuhause wohnst. Lichtschalter brauchst Du nicht mehr zu benutzen, die Heizung regelt sich bei Abwesenheit automatisch runter. Und das alles, ohne eine App zu starten. Denn das ist wirklich intelligent und smart! Ziel ist es, kein »App-Home« zu bauen, sondern auf Automatismen und Regeln zu setzen. Mit Apps verlagert man die Steuerungsebene nur an einen anderen Ort. Intelligent ist das längst nicht.
Das System kann wirklich jeder aufsetzen. Und, wenn Du Dich für Technik interessierst, hast Du bereits alles, was Du für diesen Kurs brauchst.
| Lieferzeit | Sofort Ansehen |
|---|---|
| Spielzeit | 11:00 h |
| Lektionen | 97 Stück |
Raspberry Pi 4 vorbereiten (64 Bit) (46:46)
Der Raspberry Pi 4 (06:23)
| 1. Komponenten (06:23) |
Vorbereitungen (11:09)
| 2. SD-Karte bespielen (Raspberry Pi Imager) (09:05) |
| 3. SD-Karte bespielen (Windows) (02:04) |
Inbetriebnahme (08:48)
| 4. Den Raspberry Pi im Netzwerk finden (04:14) |
| 5. Per SSH verbinden (Mac OS X und Windows) (04:34) |
Basiskonfiguration (10:05)
| 6. System aktualisieren (apt update/upgrade) (05:16) |
| 7. raspi-config (04:49) |
Wissenswertes (10:21)
| 8. Debian-Versionen und Namen (06:20) |
| 9. Ubuntu als Alternative? (04:01) |
ioBroker-Master-Kurs (2022) (13:06:39)
Einleitung (06:18)
| 1. Vorstellung und Vorwort (02:19) |
| 2. Wichtige Links und Ressourcen (03:59) |
Grundlagen (03:59)
| 3. Installation von ioBroker (03:59) |
Grundlagen I (26:48)
| 4. Grundkonfiguration / Ersteinrichtung (05:53) |
| 5. Tour über die Oberfläche (10:00) |
| 6. Verfügbare Adapter (06:15) |
| 7. Master-Content zu Adapter-Listen (04:40) |
Erste Adapter (25:27)
| 8. Deutsche Feiertage (11:36) |
| 9. Wetterdaten abholen (yr.no) (05:44) |
| 10. Architektur des Systems (04:32) |
| 11. Unwetterwarnungen vom DWD (03:35) |
Kommunikation (29:06)
| 12. Telegram-Adapter einrichten (Bot anlegen) (07:32) |
| 13. Erste Nachricht an Telegram senden (05:04) |
| 14. Text2Command installieren und verknüpfen (08:28) |
| 15. Mehr Regeln mit text2command (08:02) |
Grundlagen II (17:00)
| 16. Adapter-Zeitpläne (07:22) |
| 17. Adapter-Updates (02:16) |
| 18. Repositories und Versionen (07:22) |
Integrationen (Hardware) (34:02)
| 19. Vorwort (03:14) |
| 20. Philips Hue (04:49) |
| 21. Shelly-Komponenten (09:20) |
| 22. HomeMatic CCU3 (16:39) |
Grundlagen III (08:18)
| 23. Datenpunkte lesen / schreiben (04:29) |
| 24. Erste Geräte ansteuern (03:49) |
Logik-Grundlagen mit Blockly (38:36)
| 25. Der JavaScript-Adapter (04:35) |
| 26. Das erste Blockly-Script (06:44) |
| 27. Wie arbeiten Scripts? (06:23) Vorschau |
|
|
| 28. Trigger (09:46) |
| 29. Besonderheit bei HomeMatic IP (02:54) |
| 30. sendTo (05:12) |
| 31. Import und Export von Scripts (03:02) |
Logik-Grundlagen mit Blockly II (22:58)
| 32. Vergleiche (falls ...) (06:29) |
| 33. Vergleiche (... sonst) (03:26) |
| 34. Vergleiche mit true/false (06:40) |
| 35. Verschiedene Datentypen (06:23) |
Logik mit Blockly (29:39)
| 36. Licht zum Sonnenauf- und untergang schalten (11:35) |
| 37. Prüfung mit Variable (09:50) |
| 38. Zusätzliche Prüfung auf Werte (08:14) |
Logging-Grundlagen (Verwahrung) (18:48)
| 39. Der History-Adapter (06:10) |
| 40. Erste Werte protokollieren (07:06) |
| 41. Protokollierte Werte anzeigen (03:12) |
| 42. Wo werden die Daten abgelegt? (02:20) |
Backups erstellen und verwalten (30:12)
| 43. Backitup Adapter (03:12) |
| 44. USB-Stick als Backup-Ziel vorbereiten (03:03) |
| 45. USB-Stick mounten (08:21) |
| 46. Backup-Adapter konfigurieren (04:21) |
| 47. JavaScripts in das Backup aufnehmen (05:12) |
| 48. History-Backup (02:25) |
| 49. Benachrichtigungen aktivieren (03:38) |
Systempflege (11:17)
| 50. Update des js-controller (03:13) |
| 51. Update von nodejs (06:27) |
| 52. ioBroker-Fixer (01:37) |
Integrationen (Web) (23:24)
| 53. Schulferien (03:11) |
| 54. Pollenflug (06:47) |
| 55. Benzinpreise (08:39) |
| 56. Luftdaten (04:47) |
ZigBee-Grundlagen (60:00)
| 57. Vorwort (08:09) |
| 58. Wie funktioniert ZigBee? (08:46) |
| 59. Zigbee-Adapter installieren (12:04) |
| 60. Welche Geräte werden unterstützt? (05:08) |
| 61. Erste Geräte anlernen (Aqara) (11:49) |
| 62. Erste Geräte anlernen (Sonoff) (05:08) |
| 63. Erste Geräte anlernen (Osram) (03:03) |
| 64. Gerätenamen, Netzwerkkarte und Backup (05:53) |
Logik mit Blockly II (58:54)
| 65. Haustür-Überwachung mit Fensterkontakt (13:46) Vorschau |
|
|
| 66. Haustür-Überwachung - verbesserte Logik (11:52) |
| 67. Bewegungsmelder - Licht an! (12:39) |
| 68. Bewegungsmelder - sperren wenn manuell eingeschaltet (12:06) |
| 69. Viele Wege zum gleichen Ziel: Umschalten (08:31) |
Szenen (27:33)
| 70. Szenen mit Blockly vs. Adapter (04:17) |
| 71. Szenen verwalten und ansteuern (09:05) |
| 72. Szenen in Ordner sortieren (11:06) |
| 73. Szenen in anderen Szenen nutzen (03:05) |
Objekte und Zustände (53:09)
| 74. Objekt, Zustand, Datenpunkt (15:01) |
| 75. Eigene Objekte anlegen (04:33) |
| 76. Wo werden die Daten abgelegt? (04:42) |
| 77. Redis als Speicherort für Objekte und Zustände (06:37) |
| 78. Redis mit ioBroker verknüpfen (09:41) |
| 79. Redis-Feintuning (08:55) |
| 80. Locale in Redis konfigurieren (03:40) |
MQTT (53:44)
| 81. Einleitung (05:24) Vorschau |
|
|
| 82. Verschiedene Adapter im ioBroker (11:07) |
| 83. MQTT-Adapter mit Mosquitto verbinden (05:22) |
| 84. Erste Nachrichten per MQTT versenden (07:01) |
| 85. Tasmota-Geräte verknüpfen (Sonoff Basic R3) (18:02) |
| 86. Tasmota-Geräte verknüpfen (H801 LED-Controller) (06:48) |
CLI (Command Line Interface) (28:20)
| 87. Grundlagen (08:07) Vorschau |
|
|
| 88. Adaptern und Instanzen (update / upgrade) (10:20) |
| 89. Objekte und Zustände (07:24) |
| 90. Log-Meldungen anschauen (02:29) |
JSON (01:10:16)
| 91. JSON parsen und Attribute auslesen (06:09) |
| 92. JSON von Webserver (API) holen und parsen (05:54) |
| 93. JSON-Arrays - Iteration / Schleife (06:29) |
| 94. JSON-Arrays von Webserver (API) (04:16) |
| 95. Praxis: Radioaktivität über Webservice lesen (22:29) |
| 96. JSON als MQTT-Payload (11:51) |
| 97. JSONata - ein mächtiges Werkzeug (13:08) |
Alias-Datenpunkte (29:52)
| 98. Was ist ein Alias? Erstes Beispiel (08:00) |
| 99. Boolean-Werte negieren (verneinen) (04:24) |
| 100. Boolean-Werte aus numerischen Werten (03:50) |
| 101. JSON-Attribute in Alias extrahieren (06:53) |
| 102. Werte runden (01:36) |
| 103. Ternary-Operator - Boolean zu String (05:09) |
Räume / Geräte (24:45)
| 104. Definition von Räumen (05:39) |
| 105. Der Geräte-Adapter (14:28) |
| 106. Mehr Geräte anlegen (Licht) (04:38) |
IoT (17:24)
| 107. Einleitung (04:09) |
| 108. IoT-Adapter installieren (06:46) |
| 109. ioBroker.pro mit Alexa Skill verknüpfen (06:29) |
Backups wiederherstellen (restore) (34:58)
| 110. Einleitung (03:34) |
| 111. Erste Verbindung (ssh / known_hosts) (04:16) |
| 112. Neues System für Restore vorbereiten (05:44) |
| 113. Restore durchführen (13:54) |
| 114. Restore der History-Daten (05:17) |
| 115. Restore von JavaScripts (und Blockly) (02:13) |
Ende (01:52)
| 116. Ende und Schlusswort - Wünsche? (01:52) |
ioBroker-Master-Kurs (2019) (14:38:08)
Einleitung + Handbuch (02:00)
| 1. Vorwort (02:00) |
Grundlagen (28:39)
| 2. Installation von ioBroker (04:23) |
| 3. Grundkonfiguration (06:02) |
| 4. Tour über die Oberfläche (12:09) |
| 5. Upgrade von ioBroker (03:37) |
| 6. Verfügbare Adapter (02:28) |
Erste Adapter (28:39)
| 7. Wetterdaten abholen (10:48) |
| 8. Unwetterinformationen vom DWD (04:35) |
| 9. Pollenbelastung (03:55) |
| 10. Deutsche Feiertage im ioBroker (05:16) |
| 11. Zusammenfassung (04:05) |
Kommunikation (28:16)
| 12. Einrichtung von Telegram (07:00) |
| 13. Text2Command installieren und verknüpfen (06:27) |
| 14. Arbeiten mit Regeln (viele Beispiele) (14:49) |
Integrationen (25:35)
| 15. HomeMatic CCU (11:06) |
| 16. Philips Hue (02:40) |
| 17. FRITZ!Box (05:01) |
| 18. Logitech Harmony (02:43) |
| 19. Datenpunkte und deren Bedeutung (lesen, schreiben) (04:05) Vorschau |
|
|
Logik mit Blockly (56:32)
| 20. JavaScript Adapter installieren und Grundlagen (08:05) |
| 21. Erste Logik: Hue mit HomeMatic-Button steuern (11:06) |
| 22. Mit Kommentaren arbeiten (01:55) |
| 23. Objekte mit Verzögerung ansteuern und Timeouts (03:44) |
| 24. Licht zum Sonnenauf- und untergang schalten (07:44) |
| 25. Automatikmodus ein- und ausschalten können (06:09) |
| 26. Logik in Funktionen auslagern (06:49) |
| 27. Zusammenfassung von diesem Kapitel (07:35) |
| 28. Import und Export von Blöcken (03:25) |
Pollenflug-Benachrichtigung (19:19)
| 29. Info am Morgen mit Pollenbelastung (12:23) |
| 30. Pollenbelastung maximal 3x pro Tag senden (04:20) |
| 31. Info nur zwischen 8 und 20 Uhr (02:36) |
Smarte Waschmaschine/Spülmaschine DIY (28:11)
| 32. Einleitung (02:14) Vorschau |
|
|
| 33. Shelly-Adapter installieren (04:01) |
| 34. Das Blockly-Script Schritt für Schritt erstellen (10:24) |
| 35. Die Logik verfeinern (03:59) |
| 36. Datenpunkt statt Variable - wo ist der Unterschied? (07:33) |
ZigBee-Komponenten mit dem ConBee-Stick (26:34)
Logik mit Blockly II (38:07)
| 42. Steuern der Nachttischlampen mit Xiaomi-Buttons (16:32) |
| 43. Das Ergebnis der vorigen Lektion (01:01) |
| 44. Die Haustür überwachen - länger als 5 Minuten geöffnet? (07:23) |
| 45. Die Haustür überwachen - wie lange war die Tür geöffnet? (08:55) |
| 46. Die Haustür überwachen - regelmäßige Nachrichten (04:16) |
Logging mit InfluxDB (1.x) (15:32)
| 47. Installation und Vorbereitung (05:02) |
| 48. Konfiguration und Verbindung zum ioBroker (05:27) |
| 49. Erste Daten in InfluxDB schreiben (05:03) |
BONUS: SimpleAPI (28:06)
| 50. Installation des simple-api Adapters (05:45) |
| 51. Erste Werte abholen (03:51) |
| 52. Licht per Tastatur an- und ausschalten über toogle-Url (04:25) |
| 53. API-Benutzer, Gruppenrechte und ACL (06:49) |
| 54. Benutzername und Passwort (03:19) |
| 55. InfluxDB-Query über die API ausführen (03:57) |
Komponenten per MQTT anbinden (44:00)
| 56. Einleitung und Voraussetzungen (02:22) Vorschau |
|
|
| 57. ioBroker-Adapter konfigurieren (mqtt) (05:33) |
| 58. Sonoff Basic schalten (10:04) |
| 59. Blitzwolf mit Leistungsmessung einbinden (03:52) |
| 60. H801 LED-Controller einbinden (04:13) |
| 61. Tasmota-Befehle (Commands) im Detail (13:35) |
| 62. Das Ergebnis (04:21) |
Szenen / Stimmungen (24:10)
| 63. Einleitung und Installation (03:16) |
| 64. Erste Szene erstellen (08:40) |
| 65. Eine oder mehrere Szenen für an/aus (04:07) |
| 66. Fernseh-Szene automatisch starten (Blockly) (08:07) Vorschau |
|
|
Weitere Integrationen (31:23)
| 67. Luftdaten / Luftqualität draußen (07:19) |
| 68. Xiaomi Staubsauger-Roboter (04:15) |
| 69. SONOS-Integration und "TextToSpeech" mit SayIt (09:02) |
| 70. Spotify-Integration (05:46) |
| 71. Spritpreise mit Tankerkönig (05:01) |
Logik mit Blockly III (Telegram) (01:07:18)
| 72. Blockly statt Text2Command - String zerlegen (16:16) |
| 73. Per Telegram Szenen und Harmony Aktivität starten (07:04) |
| 74. Den Benutzer mitgeben (02:08) |
| 75. Ein Menu in Telegram anzeigen (15:14) |
| 76. Mit Untermenus arbeiten und Szenen aktivieren (13:41) |
| 77. Kürzere Namen im Menu verwenden - voriges Menu merken (06:56) |
| 78. Welcher Spotify-Track läuft gerade? (05:59) |
Sprachassistenten (Alexa) (29:39)
| 79. Einrichtung des iot-Adapters über iobroker.pro (05:11) |
| 80. Alexa-Skill mit ioBroker-Konto verknüpfen (03:35) |
| 81. Erstes Gerät mit Alexa ansteuern und Lizenzen (08:16) |
| 82. Weitere Beispiele (Steuerung in Prozent + Blockly) (12:37) |
Müllkalender mit iCal (28:34)
| 83. Grundlagen (06:08) |
| 84. Kalender integrieren und Ereignisse anlegen (04:54) |
| 85. Benachrichtigung, wenn der Müll abgeholt wird (10:08) Vorschau |
|
|
| 86. Benachrichtigung, welcher Müll genau abgeholt wird (07:24) |
Räume und Funktionen (25:55)
| 87. Was sind Aufzählungen? Erste Räume anlegen (01:59) |
| 88. HomeMatic Räume, Gewerke und Namen übernehmen (07:01) Vorschau |
|
|
| 89. Sind alle Fenster geschlossen? (16:55) |
Redis In-Memory Datenbank (22:16)
| 90. Worum genau geht es hier? (06:41) |
| 91. Installation von Redis (03:35) |
| 92. ioBroker auf Redis umstellen (06:11) |
| 93. Vorteile / Nachteile von Redis (05:49) |
Dashboard mit Grafana (50:41)
| 94. Einleitung und Grundlagen (04:06) |
| 95. Installation von Grafana auf dem Raspberry Pi 4 (08:23) |
| 96. Erstes Dashboard anlegen (10:04) |
| 97. Weiteres Widget für die Temperatur (03:47) |
| 98. Daten auf die andere Y-Achse legen (09:37) |
| 99. Heizleistung visualisieren (06:57) |
| 100. Aktuelle Temperatur der Räume darstellen (05:27) |
| 101. Auto-Refresh der Dashboards (02:20) |
Logik mit Blockly IV (44:25)
| 102. Adapter-Updates verfügbar? Benachrichtigung! (11:34) |
| 103. Welche Adapter-Versionen sind verfügbar (20:03) |
| 104. Es hat geklingelt (03:57) |
| 105. Es hat geklingelt - Kamerabild per Telegram (08:51) |
Arrays/Listen und JSON (01:31:10)
| 106. Unsere Spielwiese (03:24) |
| 107. Was ist ein Array (eine Liste)? (09:39) |
| 108. Minimum und Maximum aus einem Array bestimmen (06:01) |
| 109. Array aus Text - und zurück (05:26) |
| 110. Was genau ist JSON? (21:15) |
| 111. Daten extrahieren und weiterverwenden (08:26) |
| 112. Beispiel: Strompreise aus API extrahieren (21:37) |
| 113. Beispiel: Tasmota-Verbrauchswerte aus JSON extrahieren (08:05) |
| 114. Zufallselement aus Liste (07:17) |
GPIO Pins nutzen (40:43)
| 115. Einleitung - worum geht es? (03:01) |
| 116. Belegung der Pins, Raspi-Aadapter (07:00) |
| 117. LED-Ansteuern (Schaltung) (06:42) |
| 118. LED-Ansteuern (Logik) (07:12) |
| 119. Button-Ansteuern (Schaltung) (06:23) |
| 120. Button-Ansteuern (Logik) (04:04) |
| 121. 1Wire-Sensoren (DS18B20) (03:11) |
| 122. 1Wire-Sensoren auslesen (03:10) |
Alles über Datenpunkte (50:17)
| 123. Grundlagen (09:26) |
| 124. Datenpunkt anlegen (state, channel) (12:13) |
| 125. Datentypen (14:19) |
| 126. Datenpunkt per Blockly anlegen (14:19) |
Ende (02:07)
| 127. Ende und Schlusswort - Wünsche? (02:07) |