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
59,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 | 15:54 h |
| Lektionen | 158 Stück |
Raspberry Pi 4/5 vorbereiten (64 Bit) (29:56) - Bonus!
Raspberry Pi 4 oder 5 (15:55)
| 1. Welche Komponenten sind nötig? (05:55) |
| 2. SD-Karte bespielen (Raspberry Pi Imager) (07:07) |
| 3. Zusammenbau und erster Start (02:53) |
Inbetriebnahme (07:59)
| 4. Raspberry Pi im Netzwerk finden (03:27) |
| 5. SSH-Verbindung unter Mac OS (02:57) |
| 6. SSH-Verbindung unter Windows (11) (01:35) |
Erste Schritte (06:02)
| 7. System aktualisieren (06:02) |
Mini-PC vorbereiten (Debian 64 Bit) (18:36) - Bonus!
Einleitung (02:55)
| 1. Warum ein Mini PC? (02:55) |
Debian-Installation (12:53)
| 2. USB-Stick vorbereiten (Debian 12) (04:11) |
| 3. Debian installieren (08:42) |
Inbetriebnahme (02:48)
| 4. SSH-Verbindung (02:48) |
Linux-Grundlagen von A-Z (Debian) (04:09:21) - Bonus!
Einleitung (03:10)
| 1. Vorwort (03:10) |
Distributionen (19:51)
| 2. Der Linux-Kernel (08:01) |
| 3. Distribution vs. Kernel (11:50) |
Dateisystem (47:53)
| 4. Grundstruktur (05:53) |
| 5. Verzeichnisse anlegen und löschen (09:00) |
| 6. Verzeichnis-Inhalt anzeigen (05:57) |
| 7. Dateien bearbeiten und löschen (09:07) |
| 8. Berechtigungskonzept (r, w, x) (10:06) |
| 9. Berechtigungskonzept (Verzeichnisse) (04:22) |
| 10. Berechtigungskonzept (Besitzer / Gruppe ändern) (03:28) |
Benutzer und Gruppen (23:17)
| 11. root vs. sudo (04:42) |
| 12. Neue Benutzer anlegen (03:58) |
| 13. Die sudoers (08:26) |
| 14. sudo-Rechte einschränken (06:11) |
Paketmanager (apt) (28:58)
| 15. Was ist ein Paketmanager? (04:59) |
| 16. Paketlisten (Repositories) (11:16) |
| 17. Zusätzliche Paketlisten (z.B. nodejs, InfluxDB, ...) (03:18) |
| 18. Pakete aktualsieren / entfernen (04:16) |
| 19. Pakete "pinnen" (05:09) |
Benutzer und Authentisierung (26:00)
| 20. Welche Benutzer gibt es? (06:05) |
| 21. Fingerprints (und known_hosts) (05:20) Vorschau |
|
|
| 22. Anmelden ohne Passwort (10:55) |
| 23. Noch schneller anmelden mit ssh_config (03:40) |
Dateisystem II (31:33)
| 24. Größe von Dateien und Ordnern (07:36) |
| 25. Wie voll sind die Festplatten? (04:00) |
| 26. Symlinks vs. Hardlinks (09:11) |
| 27. Wann sollte man mehrere Hardlinks verwenden? (04:28) |
| 28. Große Dateien finden / wer belegt viel Platz? (02:52) |
| 29. Wer hat welche Datei / welchen Port geöffnet? (lsof) (03:26) |
Bash (15:03)
| 30. History (09:42) |
| 31. Umgebungsvariablen ($PATH) (05:21) |
Netzwerkumgebung (27:48)
| 32. Interfaces (05:30) |
| 33. Statische IP-Adresse konfigurieren (Network Manager) (09:33) |
| 34. Statische IP-Adresse konfigurieren (ohne Network Manager) (05:23) |
| 35. Welcher Dienst nutzt welchen Port? (07:22) |
Dienste (Services) (25:48)
| 36. Was sind Dienste? (08:19) |
| 37. Starten / Stoppen / Neustart (05:17) |
| 38. systemctl oder service (02:46) |
| 39. ntp-Service (09:26) |
ioBroker-Master-Kurs (16:03:52)
Einleitung (06:47)
| 1. Vorstellung und Vorwort (03:45) |
| 2. Wichtige Links und Ressourcen (03:02) |
Installation (11:46)
| 3. Installation von ioBroker (06:01) |
| 4. Grundkonfiguration / Ersteinrichtung (05:45) |
Grundlagen I (46:56)
| 5. Tour über die Oberfläche (08:43) |
| 6. Adapter und Instanzen (05:56) |
| 7. Adapter-Listen (Repositories) (05:08) |
| 8. Adapter-Updates (05:07) |
| 9. Was sind Objekte und Zustände (12:13) |
| 10. Kern des Systems: Der js-controller (02:54) |
| 11. Architektur des ioBroker-Systems (04:29) |
| 12. Update des js-controller (02:26) |
Kommunikation per Chat (28:24)
| 13. Einrichtung von Telegram und Bot (08:37) |
| 14. Erste Nachricht empfangen (05:36) |
| 15. Das Konzept hinter ioBroker (03:22) |
| 16. Erste Regeln anlegen / Antworten zusammenbauen (10:49) |
Hardware-Integrationen (43:33)
| 17. Vorwort (01:47) |
| 18. Philips Hue (03:57) |
| 19. HomeMatic CCU3 (15:50) |
| 20. HomeMatic CCU3 - Struktur der Datenpunkte (03:20) |
| 21. HomeMatic CCU3 - Sonderlocke (Dummy-Programme) (02:53) |
| 22. Shelly - kurzes Intro (04:44) |
| 23. Shelly - Ersteinrichtung (03:39) |
| 24. Shelly - ioBroker-Adapter / Integration (07:23) |
Logik-Grundlagen I (37:43)
| 25. Grundlagen (13:06) |
| 26. Datenpunkt ansteuern (03:52) |
| 27. Trigger nutzen (06:25) |
| 28. Weitere Bedingungen (04:51) |
| 29. Externe/Interne Eingänge und Blöcke deaktivieren (03:04) |
| 30. Zeit-Trigger (06:25) |
Backup des Systems (17:59)
| 31. Backup per Adapter (03:41) |
| 32. USB-Stick vorbereiten (02:33) |
| 33. USB-Stick einrichten (mount) (06:08) |
| 34. Backup-Ziel konfigurieren (04:06) |
| 35. Benachrichtigung per Telegram (01:31) |
Logging-Grundlagen (History) (15:39)
| 36. Speichern per History-Adapter (06:00) |
| 37. Gespeicherte Daten anzeigen (03:33) |
| 38. Wo liegen die Daten im Dateisystem? (02:47) |
| 39. History-Daten in das Backup aufnehmen (03:19) |
Logik-Grundlagen II (58:39)
| 40. Eigenschaften von States (Zuständen) (03:59) |
| 41. Bestätigt / Unbestätigt (aktualisiere / steuere) (11:14) |
| 42. Eigene Datenpunkte (05:36) |
| 43. Objekt-Metadaten (Einheit, Rolle, ...) (05:42) |
| 44. Datentypen (08:28) |
| 45. Ein Beispiel aus der Praxis (15:35) |
| 46. Beispiel optimieren (Funktion) (05:24) |
| 47. Beispiel optimieren (neuer Bestätige-Baustein) (02:41) |
Adapter und Versionen (54:01)
| 48. Versionen von GitHub und npm (stable, beta) (09:27) |
| 49. Adapter manuell von npm installieren (beta) (05:51) |
| 50. Wie sind Versionsnummern aufgebaut? (04:40) |
| 51. Downgrade auf ältere Adapter-Version (06:16) |
| 52. Kostenpflichtige Adapter (04:22) |
| 53. Adapter bewerten (04:40) |
| 54. Automatische Adapter-Updates (07:31) |
| 55. Verwaiste Adapter finden und vermeiden (11:14) |
Redis statt jsonl (25:55)
| 56. Vorwort (04:14) |
| 57. Installation (per apt) (04:44) |
| 58. ioBroker mit Redis verknüpfen (07:41) |
| 59. Konfiguration von Redis anpassen (09:16) |
Alternative Logik-Adapter (21:03)
| 60. Bessere Lösung? Szenen-Adapter! (09:19) |
| 61. Details zum Szenen-Adapter (05:29) |
| 62. Über Kalender-Ansicht steuern (06:15) |
Alias-Datenpunkte (18:42)
| 63. Die Problematik (03:40) |
| 64. Ein Beispiel (06:39) |
| 65. Der Geräte-Adapter (08:23) |
Grundlagen II (18:23)
| 66. Rollen von Datenpunkten (07:06) Vorschau |
|
|
| 67. Auswahlmöglichkeiten (Enum) (03:18) |
| 68. Adapter-Typen (daemon, schedule) (07:59) |
Zigbee-Integration (40:11)
| 69. Einleitung (04:04) |
| 70. Stick in das System einbinden (07:38) |
| 71. Erste Zigbee-Geräte anlernen (07:37) |
| 72. Geräte-Namen und Objekte (+ Alias) (09:49) |
| 73. LAN-Coordinator statt USB - gute Alternative? (04:55) |
| 74. LAN-Coordinator konfigurieren (06:08) |
Logik-Grundlagen III (20:55)
| 75. Fenster offen - Meldung per Telegram (04:56) |
| 76. Meldung mit Timeout verzögern (04:47) |
| 77. An weitere Bedingungen knüpfen (05:55) |
| 78. Erneute Nachrichten verhindern (05:17) |
MQTT (41:16)
| 79. Grundlagen und erste Nachrichten (11:05) |
| 80. Erste Nachricht publishen (06:20) |
| 81. Beispiel mit Tasmota (08:21) |
| 82. Alias-Funktionen zum Konvertieren (08:38) Vorschau |
|
|
| 83. Weitere Einstellungen der Instanz (Feintuning) (02:14) |
| 84. Nachricht per Blockly versenden (04:38) |
JSON (allgemein) (55:17)
| 85. Grundlagen / Begriffe (05:12) Vorschau |
|
|
| 86. Attribut von Objekt (03:44) |
| 87. JSON in Datenpunkt schreiben (Typ string vs. object) (08:31) |
| 88. JSON aus HTTP-Request (21:45) |
| 89. JSON-Attribut zu Alias-Datenpunkt (09:03) |
| 90. JSON aus HTTP-Request (Bitcoin-Kurs) (07:02) |
Systempflege (19:00)
| 91. Update des Systems und nodejs (05:57) |
| 92. Hinweise auf System-Updates (ab js-controller 6.x) (04:17) |
| 93. Major-Update von nodejs (06:42) |
| 94. nodejs direkt im Admin aktualisieren (02:04) |
Objekte (39:30)
| 95. Alles ist als Objekt gespeichert (07:13) |
| 96. Zugriff auf Objekte mit Blockly (08:21) |
| 97. Neue Objekte mit Blockly erstellen (07:49) |
| 98. Arbeiten mit Arrays (Listen) (10:59) |
| 99. Summe aus Liste und Durchschnitt (05:08) |
Dateien (42:18)
| 100. Das Dateien-Tab und Meta-Objekte (07:35) |
| 101. Wo liegen die Daten im Dateisystem? (04:59) |
| 102. Upload von Adaptern - was passiert? (.admin meta-Objekte) (05:33) |
| 103. Datei mit Blockly schreiben + Datei-Trigger (04:13) |
| 104. Kamera-Bild per HTTP holen und speichern (07:56) Vorschau |
|
|
| 105. Kamera-Bild per Telegram versenden (Datei-Trigger) (08:46) |
| 106. Kamera-Bild per Telegram versenden (ohne Speichern) (03:16) |
Protokolle (Logs) (37:32)
| 107. Das Protokoll-Tab und Filter (05:11) |
| 108. Die verschiedenen Log-Level (01:53) |
| 109. Log-Level von Instanzen anpassen (05:32) |
| 110. Log-Ausgaben in Blockly (debug) (03:01) |
| 111. Mit Trigger auf Log reagieren (07:29) |
| 112. Der "Verbose-Mode" in Blockly / JavaScript (06:31) |
| 113. Sentry-Plugin (was ist das?) (05:03) |
| 114. Weitere Log-Arten hinzufügen (02:52) |
Logging-Grundlagen (InfluxDB 2.x) (53:08)
| 115. Grundlagen und Gedanken (06:19) |
| 116. Installation unter Linux (per apt) (08:16) |
| 117. Ersteinrichtung der Datenbank (Benutzer + Bucket) (04:54) |
| 118. Verbindung mit dem ioBroker (03:27) |
| 119. InfluxDB-Token nachträglich herausfinden (01:52) |
| 120. Erste Daten protokollieren (03:45) |
| 121. Werden schon Daten abgelegt? (03:32) |
| 122. Daten von History migrieren (06:07) |
| 123. Backup der Datenbank (03:40) |
| 124. Token Typen (Operator-Token, All access token, ...) (08:02) |
| 125. Separates Token mit weniger Rechten für ioBroker (03:14) |
Termine immer im Blick (59:17)
| 126. iCal-Kalender mit Terminen/Ereignissen (10:38) |
| 127. Müllabfuhr-Plan - etwas mehr Komfort (12:49) |
| 128. Benachrichtigung bei Müll-Abholung (07:13) |
| 129. Keine Müll-Termine gefunden? (19:32) |
| 130. Geburtstage verwalten (09:05) |
Mehr Daten in das System holen (08:36)
| 131. Benzinpreise (Tankerkönig) (08:36) |
Alles über Trigger (19:00)
| 132. Trigger immer auf Objekt-IDs (04:33) |
| 133. Liste (Array) mit Objekt-IDs (06:53) |
| 134. ID-Selektor ($) (07:34) |
CLI (Command Line Interface) (33:02)
| 135. Welche Befehle gibt es? (03:30) |
| 136. Mit Zuständen arbeiten (05:02) |
| 137. Helfer bei Problemen (Instanzen starten) (02:59) Vorschau |
|
|
| 138. Dateien schreiben (04:22) |
| 139. Protokoll (Log) ansehen und filtern (03:17) |
| 140. Passwort zurücksetzen (02:15) |
| 141. Adapter-Updates ohne Admin (04:29) |
| 142. ioBroker Fixer (03:13) |
| 143. So arbeiten die CLI-Scripts (03:55) Vorschau |
|
|
sendTo - Nachricht an andere Instanz (36:25)
| 144. Was ist sendTo? (03:54) |
| 145. Der generische sendTo-Block (04:23) |
| 146. Beispiel: Adresse der günstigsten Tankstelle per Telegram (06:43) |
| 147. Nachricht an anderes Script (Logiken auslagern) (09:20) |
| 148. Nachricht an anderes Script - Erweiterung (12:05) |
Benachrichtigungen (Notifications) (15:08)
| 149. Was genau ist das? (02:33) |
| 150. Der Notification-Manager (06:36) |
| 151. Eigene Benachrichtigungen erstellen (03:19) |
| 152. Benachrichtigungen unterdrücken (02:40) |
eCharts (11:48)
| 153. Adapter installieren und erste Graphen (05:35) |
| 154. Graphen per Telegram versenden (06:13) |
Compact Mode (Ressourcen sparen) (13:36)
| 155. Compact Mode aktivieren und verstehen (06:20) |
| 156. Kompakt-Gruppen zuweisen und verwalten (04:01) |
| 157. Hintergrundwissen zu Kompakt-Gruppen (03:15) |
MQTT im Detail (09:14)
| 158. mqtt vs. mqtt-client Adapter (09:14) |
Ende (03:09)
| 159. Die nächsten Schritte - Wünsche? (03:09) |