Sehr schöne Anleitung.
Gut erklärt und schnell umzusetzen.

Zitat der Seite (linux-tips-and-tricks.de):

Die Dokumentation von raspiBackup ist durch Erweiterungswünsche von Benutzern mittlerweile sehr umfangreich geworden. Auf dieser Seite wird deshalb kurz und knapp Schritt für Schritt erklärt wie man in 5 Minuten raspiBackup installiert und konfiguriert und dann ein Backup der Raspberry erstellen kann. Der Restore ist dann hier für die unterschiedlichen Benutzer mit ihren jeweiligen primären Platformen (Linux, Mac oder Windows) beschrieben. Nachdem man dann sowohl den Backup als auch den Restore getestet hat und geprüft hat welche Services vor dem Backup gestoppt werden müssen lässt man dann raspiBackup automatisch im gewünschten Intervall per crontab laufen. Danach kann man in einer stillen Stunde sämtliche Möglichkeiten von raspiBackup hier nachlesen und die Konfiguration den speziellen Bedürfnissen anpassen. In jedem Falle sollte jeder sich die FAQs durchlesen.

ESP-WROOM-32

Hallo zusammen,

hier eine gute Anleitung auf deutsch, wie Ihr das MicroPhython auf dem ESP installiert und die ersten Gehversuche macht.

Ein ESP32 mit MicroPython (Video – YouTube)

Hier noch die wichtigsten Links:

https://micropython.org/download#esp32

Python 3.x.x für OS?

Hier die schnelle Übersicht zu ganz einfachen Befehlen …

Welcome to MicroPython on the ESP32!

For generic online docs please visit http://docs.micropython.org/


https://github.com/loboris/MicroPython_ESP32_psRAM_LoBo/wiki


For access to the hardware use the ‘machine’ module:

import machine                // besser: from machine import Pin (spart Speicher)

pin12 = machine.Pin(12, machine.Pin.OUT)

pin12.value(1)

pin13 = machine.Pin(13, machine.Pin.IN, machine.Pin.PULL_UP)

print(pin13.value())

i2c = machine.I2C(scl=machine.Pin(21), sda=machine.Pin(22))

i2c.scan()

i2c.writeto(addr, b'1234')

i2c.readfrom(addr, 4)

 

Basic WiFi configuration:

import network

sta_if = network.WLAN(network.STA_IF); sta_if.active(True)

sta_if.scan()                             # Scan for available access points

sta_if.connect("<AP_name>", "<password>") # Connect to an AP

sta_if.isconnected()                      # Check for successful connection

 

Control commands:

  CTRL-A        -- on a blank line, enter raw REPL mode

  CTRL-B        -- on a blank line, enter normal REPL mode

  CTRL-C        -- interrupt a running program

  CTRL-D        -- on a blank line, do a soft reset of the board

  CTRL-E        -- on a blank line, enter paste mode

For further help on a specific object, type help(obj)

For a list of available modules, type help(‘modules’)

—————————————————————————

MicroPython

Shell:

screen /dev/tty.ESPPORT 115200           // Shell starten und mit dem ESP verbinden default:115200 dann 2-3 mal "CTRL + C" drücken ...

>>>Befehl

Beispiel:

>>>print("Hallo")

——————————————————————————————

noch etwas netter ist die RShell

Aufrufen mit:

rshell --buffer-ssize=30 -p /dev/tty.ESPPORT         //(bei mir z.B.: /dev/tty.SLAB_USBtoUART)

Befehle in der RSHELL:

boards                       // zeigt Dir alle angeschlossenen Boards und die Namen

ls "boardname"          // z.B.: "ls pyboard" - listet die Dateien auf dem Board. Wenn Ihr noch //nichts gemacht habt dann findet Ihr da nur die boot.py 

                                // Die boot.py wird bei jedem Start des Boards ausgeführt. Auch nach dem aufwachen aus dem DeepSleep Modus.

                                // Euer Programm steht dann in der Regel in der main.py

edit /pyboard/boot.py            // ruft die Datei boot.py im StandartEditor auf. Exit mit :q! für nicht speichern

Etwas netter ist es wenn Ihr einen anderen Editor benutzt. Verlasst die rshell und startet sie neu mit dem Befehl:

rshell --buffer-size=30 -p /dev/tty.ESPPORT -a -e nano

// damit macht Ihr für die aktuelle Sitzung den Editor "nano" zum StandartEditor

——————————————————————————————–

Aufrufen einer KomandoOberfläche (REPL):

REPL                              // hier könnt Ihr wieder direkt Befehle ausführen

ESP-WROOM-32

Der neue MicroShip der von der Firma Espressif Systems entwickelt wurde, ist seit einigen Monaten am Markt und bringt eine Menge neue Futures mit.
Eine der angenehmeren Möglichkeiten mit dem [wiki]ESP32[/wiki] ein Projekt umzusetzen, ist das verwenden von “MicroPython”. In Verbindung mit dem “Atom” Editor und dem “pymakr” PlugIn.

ESP32

Snippets

WeMos D1 R32 Uno mit 2.6″/2.8″TFT LCD Shield

SD-Card (SPI / on Shield)

SS – CS – 05
SCK – CLK – 18
DO – MISO – 19
DI – MOSI – 23

LCD_TFT (2.6″/2.8″TFT LCD Shield)

LCD_RST – LCD_Reset – 36
LCD_CS – ChipSelect – 34
LCD_RS – (RegisterSelect) – 35
LCD_WR – (WRite data) – 04
LCD_RD – (ReaD data) – 02

LCD_D0 – 12
LCD_D1 – 13

LCD_D2 – 26
LCD_D3 – 25
LCD_D4 – 17
LCD_D5 – 16
LCD_D6 – 27
LCD_D7 – 14

WiKi / Infos zum Shield: 2.6″ / 2.8″ TFT_LCD

>>> import gc

>>> gc.collect()

>>> gc.mem_free()

90208

>>> import uos

>> uos.uname()

(sysname=‘esp32’, nodename=‘esp32’, release=‘1.9.3’, version=‘v1.9.3-240-ga275cb0f on 2018-01-27’, machine=‘ESP32 module with ESP32’)

>>>

SPI / ESP32 / MicroPython
Serial Peripheral Interface

… ist ein Protokoll um zwischen 2 Geräten Daten in beide Richtungen zu senden.
Als Beispiel: Ein LED-Controller bekommt Informationen/Daten gesendet um zu wissen was er tun soll. Hingegen ein Temperatursensor schickt Daten an den Microkontroller.

Und so läuft das Spiel:


Der SPI Master:

Im SPI Protokoll gibt es einen wesentlichen Unterschied zwischen dem Master, der die Verbindung kontrolliert und steuert, und dem Slave der Daten von und zum Master sendet und empfängt.
In allen Fällen ist der Microkontroller der Master und steuert die SPI Verbindung.
In dem folgenden Beispiel wollen wir einmal ausprobieren wie der ESP32 mit Hilfe von MicroPython die SPI Verbindung mit anderen Geräten steuert.
 
In den meisten Fällen braucht eine SPI Verbindung mindestens 4 Leitungen um sich zu verbinden.
 
  • Clock, das SPI Master Gerät schaltet diese Leitung auf “I oder 0” um der Gegenstelle (Slave) zu sagen wann sie senden und wann sie empfangen soll/darf.
  • MOSI (master output, slave input), über diese Leitung werden Daten vom Master an ein Slave-Gerät gesendet. Das ist quasi der Datenausgang vom Master-Gerät.
  • MISO (master input, slave output), Über diese Leitung senden die Slave-Geräte ihre Daten an den Master (Microkontroller). Also der wenn man so will ist das der Daten-Ausgang der Slave-Geräte.
  • Chip Select (CS), auch wenn es nicht nötig ist, haben die meistern SPI Geräte eine CS-Leitung. Über diese Leitung kann der Master (mit I oder 0) den angeschlossenen Slave-Geräten mitteilen ob sie gerade auf SPI-Befehle hören sollen oder nicht. So lange alle angeschlossenen SPI-Geräte an eine SC Leitung angeschlossen sind, können sie sich die anderen Leitungen (Clock, MOSI und MISO) teilen. So kann jedes Gerät einzeln angesprochen werden.
Allerdings solltest Du dir bewusst sein, dass bei den unterschiedlichen Boards(Controllern), auf denen MicroPythen läuft, die SPI API beim erstellen des Master Mode unterschiedliche Wege kennt.