Moin,

Quote

Oder muss ich bei den Schnittstellen noch etwas beachten?

Das Pinout der DSI-Anschlüße ist unterschiedlich.

Siehe:

https://wiki.somlabs.com/index…PI-DSI_.28input.29_Pinout

https://datasheets.raspberrypi…-4-reduced-schematics.pdf

Ein ähnlicher/gleichen Fehler wird im englischen Forum auch von mehreren Benutzern beanstandet:

https://www.raspberrypi.org/fo…wtopic.php?f=108&t=283655

Moin,

mosquitto auf RPI installieren:

https://plantprogrammer.de/mqt…m-raspberry-pi-mosquitto/

wenn Du den RPI in Dein Wlan eingebunden hast oder ihn als AP (192.168.33.1) benutzt kannst Du

auf der im Shelly eingebauten Webseite die Mqtt-Einstellungen vornehmen.

Die Eigenschaften des Plugs kenn ich nicht, müßte ich auch selbst nach "googeln".

Quote

Wenn ich das richtig lese gibt es beim Shelly 1PM keine möglichkeit, das Signal selbst zu verarbeiten, oder? So wie ich das verstehe kommt der mit einer fertigen APP und Cloud Software?

Man hat mehrere Möglichkeiten, die Cloud oder eine fertige App kann man nutzen, muß man aber nicht.

Will man Clod/App nicht nutzen hat man noch die Möglichkeit den 1PM ins eigene Wlan Netz zu integrieren oder ihn als AP zu benutzen, dann kann man ihn über eine interne Webseite bedienen ohne dafür in www zu müssen.

Außerdem ist der PM1 noch Mqtt fähig und kann einen Mqtt-Server (den man auf einen Raspberrypi einrichten kann) bedienen.

Moin,

Quote

Nehme gerne auch andere Lösungen an. WLAN Steckdosen die man programmatisch abfragen kann oder so.

Schau Dir mal den Shelly 1PM an.

https://www.photovoltaikforum.…sz%C3%A4hler-f%C3%BCr-pv/

Moin,

ohne Gewähr_:

https://www.reichelt.de/de/de/…iEAQYASABEgJV2_D_BwE&&r=1

Edit: natürlich mit der Noir-Kamera von Raspberrypi :https://www.berrybase.de/raspb…r-camera-module-8mp-v2.1#

Moin,

es geht in diesem Thread nicht um den Pico, sondern um den Arduino Nano RP2040.

Siehe Link Post 1: https://www.elektormagazine.de…a37db71&mc_eid=360b949168

Moin,

Quote

was könnte ich noch probieren?was könnte ich noch probieren?

https://projects.raspberrypi.o…raspberry-pi-setting-up/2

Moin,

im englischen Forum hat jemand über ein ähnliches Problem berichtet.

https://www.raspberrypi.org/fo…wtopic.php?f=140&t=306242

Er hat den Anschluß mit Pressluft ausgeblasen, danach soll das Problem verschwunden sein.

Moin,

ich hatte auch unter Debian in Arduino 1.8.13 IDE in der Boardverwaltung

"Arduino Mbed OS RP2040 Bords" installiert, konnte aber auch nicht "uploaden".

Im englischen Forum habe ich dann folgendes gefunden:

Quote

I found this script in ~/.arduino15/packages/arduino/hardware/mbed_rp2040/2.0.0/post_install.sh

running it with sudo installs the rule then upload worked.

Habe dann als Root "./.arduino15/packages/arduino/hardware/mbed/2.0.0/post_install.sh" ausgeführt und neu gebootet (udev neu laden hätte wahrscheinlich gereicht).

Wenn man nun den Pico mit gedrückter Bootselect-Taste in die USB-Buchse steckt wird kein Port angezeigt, das "Uploaden" funktioniert jetzt aber.

Nach dem "Uploaden" verbindet sich der Pico automatisch mit /dev/ttyACM0.

Danach reicht für ein erneutes Uploaden ein Druck auf die Bootselect-Taste.

Außer "Blink" habe ich auch noch nichts getestet.

Moin,

Quote

Mir ist klar, das ich die Akkus nicht direkt an den Pico anschließen kann.

Quote

a power supply chip supporting input voltages from 1.8-5.5V. This allows you to power your Pico from a wide variety of sources, including two or three AA cells in series, or a single lithium-ion cell.

Quelle:https://www.raspberrypi.org/bl…silicon-pico-now-on-sale/

Moin,

mit den Raspberrypi und Modbus hab ich noch nicht gearbeitet nur mit Arduino/ESP8266.

Eigentlich müßte es mit Deiner Hardware aber funktionieren.

Fertige Modbussoftware für deinen Windanzeiger wird es für den Raspberrypi wahrscheinlich nicht geben.

Du könntest mit Python3 Dir aber selber etwas programmieren.

Dazu bräuchtest Du noch Python3-modbus (sudo apt install python3-pymodbus) und müßtest Dich

einlesen. Zu Python-modbus und Raspberrypi /Modbus findet man im Internet viele Artikel.

Helfen kann ich Dir dabei auch nicht, müßte mich auch erst einlesen.

Moin,

ein Datenblatt ist ja leider nicht im Netz zu finden.

Es sieht aber so aus als wenn diese Anzeiger mit dem Modbus-Protokoll arbeiten.

Die Daten beim Modbus werden im Gerät in Registern gespeichert.

Zum auslesen der Daten benötigt man die Adressen der Register, die weiß wiederum nur der Hersteller.

Ein Datenblatt ist dazu unbedingt nötigt.

Im folgenden Link versucht jemand ein ähnliches/eventuell gleiches Gerät auszulesen, dort allerdings mit einem Arduino.

https://forum.arduino.cc/index.php?topic=636373.0

NACHTRAG: Eventuell passt diese Anleitung ja zu Deinem Gerät.

Hierdrin sind Registeradressen aufgeführt.

Wind_Transmitter_UG_485Type_v1.0.pdf

Bei mir funktioniert es an sowohl an GP0/1 als auch an GP4/5. Vor dem Wechsel muß der Pico stromlos gemacht werden.

Library

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces

from micropython import const
import framebuf


# register definitions
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xA4)
SET_NORM_INV = const(0xA6)
SET_DISP = const(0xAE)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xA0)
SET_MUX_RATIO = const(0xA8)
SET_COM_OUT_DIR = const(0xC0)
SET_DISP_OFFSET = const(0xD3)
SET_COM_PIN_CFG = const(0xDA)
SET_DISP_CLK_DIV = const(0xD5)
SET_PRECHARGE = const(0xD9)
SET_VCOM_DESEL = const(0xDB)
SET_CHARGE_PUMP = const(0x8D)

# Subclassing FrameBuffer provides support for graphics primitives
# http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
class SSD1306(framebuf.FrameBuffer):
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        self.buffer = bytearray(self.pages * self.width)
        super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
        self.init_display()

    def init_display(self):
        for cmd in (
            SET_DISP | 0x00,  # off
            # address setting
            SET_MEM_ADDR,
            0x00,  # horizontal
            # resolution and layout
            SET_DISP_START_LINE | 0x00,
            SET_SEG_REMAP | 0x01,  # column addr 127 mapped to SEG0
            SET_MUX_RATIO,
            self.height - 1,
            SET_COM_OUT_DIR | 0x08,  # scan from COM[N] to COM0
            SET_DISP_OFFSET,
            0x00,
            SET_COM_PIN_CFG,
            0x02 if self.width > 2 * self.height else 0x12,
            # timing and driving scheme
            SET_DISP_CLK_DIV,
            0x80,
            SET_PRECHARGE,
            0x22 if self.external_vcc else 0xF1,
            SET_VCOM_DESEL,
            0x30,  # 0.83*Vcc
            # display
            SET_CONTRAST,
            0xFF,  # maximum
            SET_ENTIRE_ON,  # output follows RAM contents
            SET_NORM_INV,  # not inverted
            # charge pump
            SET_CHARGE_PUMP,
            0x10 if self.external_vcc else 0x14,
            SET_DISP | 0x01,
        ):  # on
            self.write_cmd(cmd)
        self.fill(0)
        self.show()

    def poweroff(self):
        self.write_cmd(SET_DISP | 0x00)

    def poweron(self):
        self.write_cmd(SET_DISP | 0x01)

    def contrast(self, contrast):
        self.write_cmd(SET_CONTRAST)
        self.write_cmd(contrast)

    def invert(self, invert):
        self.write_cmd(SET_NORM_INV | (invert & 1))

    def show(self):
        x0 = 0
        x1 = self.width - 1
        if self.width == 64:
            # displays with width of 64 pixels are shifted by 32
            x0 += 32
            x1 += 32
        self.write_cmd(SET_COL_ADDR)
        self.write_cmd(x0)
        self.write_cmd(x1)
        self.write_cmd(SET_PAGE_ADDR)
        self.write_cmd(0)
        self.write_cmd(self.pages - 1)
        self.write_data(self.buffer)


class SSD1306_I2C(SSD1306):
    def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
        self.i2c = i2c
        self.addr = addr
        self.temp = bytearray(2)
        self.write_list = [b"\x40", None]  # Co=0, D/C#=1
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.temp[0] = 0x80  # Co=1, D/C#=0
        self.temp[1] = cmd
        self.i2c.writeto(self.addr, self.temp)

    def write_data(self, buf):
        self.write_list[1] = buf
        self.i2c.writevto(self.addr, self.write_list)


class SSD1306_SPI(SSD1306):
    def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
        self.rate = 10 * 1024 * 1024
        dc.init(dc.OUT, value=0)
        res.init(res.OUT, value=0)
        cs.init(cs.OUT, value=1)
        self.spi = spi
        self.dc = dc
        self.res = res
        self.cs = cs
        import time

        self.res(1)
        time.sleep_ms(1)
        self.res(0)
        time.sleep_ms(10)
        self.res(1)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(0)
        self.cs(0)
        self.spi.write(bytearray([cmd]))
        self.cs(1)

    def write_data(self, buf):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(buf)
        self.cs(1)

Testdatei

from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
from time import sleep


WIDTH  = 128                                            # oled display width
HEIGHT = 32                                             # oled display height

i2c = I2C(0,scl=Pin(1), sda=Pin(0))                                            # Init I2C using I2C0 defaults, SCL=Pin(GP9), SDA=Pin(GP8), freq=400000
print("I2C Address      : "+hex(i2c.scan()[0]).upper()) # Display device address
print("I2C Configuration: "+str(i2c))                   # Display I2C config


oled = SSD1306_I2C(WIDTH, HEIGHT, i2c)                  # Init oled display
# Clear the oled display in case it has junk on it.
oled.fill(0)
# Add some text
oled.text("Raspberry Pi",5,5)
oled.text("Pico",5,15)
oled.text("Sommer",5,25)
oled.contrast(0xff)  #0x00 bis 0xff
oled.show()
sleep(3)
oled.invert(1)

sleep(1)
oled.invert(0)
sleep(1)

Moin,

obwohl JAR schrieb

Quote

also der Preis sollte einem nicht gleich zum Kauf anmieren, vorher nochmal zu überdenken ist immer von Vorteil, ich kenne das auch HABENWOLLEN und wenn der Preis lockt klickt man zu früh auf kaufen!

war das HABENWOLLEN doch stärker.

Ja, er hat nur zwei Kanäle, verbinde ich den Trigger-Ausgang des DS1102Z-E mit meinen alten Tektronik TDS210 hab ich auch 4 Kanäle.

Die Lösung ist zwar nicht sehr elegant, funktioniert aber.

Im Gegensatz zu meinem alten Scope hat der Rigol USB und Lan-Anschluß.

Mit der Software DSRemote (https://www.teuniz.net/DSRemote/) kann ich den Rigol fernbedienen.

Die Software läuft bei mir auf meinem PC mit Debian als auch auf dem Raspi 3B und 4.

Auf dem Raspi 4 allerdings nur über Lan weil in der Rigol Firmware ein Bug ist und sie nicht mit dem USB-Controller

des RPI 4 läuft.

Quote

Unfortunately, there's a bug in the firmware of the scope that causes connection problems

when your computer uses an xHCI host controller (USBv3.x).

Bei dem RPI 3B geht auch USB.

Schön finde ich dass das Scope auch RS323, I2C und SPI decodieren kann, dadurch fällt für mich das Abzählen der Takte an meinem alten Tektonix weg.

Moin,

in https://raspberrypi.stackexcha…ght-of-a-3-5-inch-display

wurde auch danach gefragt.

Scheinbar ist es nicht möglich bei dem Display die Helligkeit per Software zu ändern.

NACHTRAG: in dem Oben genanten Link bezog sich der Anwortende auf das XPT2046, das ist allerdings nur der

Touch-Controller.

Der LCD-Controller ist aber bei vielen 3,5" Displays der ILI9486. Dieser Controller benötigt eine zusätzliche Hardware die bei den meisten billigen 3,4" Displays nicht vorhanden sein dürfte.

Siehe dazu auch :

https://www.mikrocontroller.net/topic/448181

Moin,

nur so eine Idde:

Hast Du eventuell in der config.txt die Pulldowns aktiviert?

siehe: https://www.raspberrypi.org/do…ration/config-txt/gpio.md

NACHTRAG: Hab nochmal nachgeschaut: Die internen Pulldowns haben ca. 65 KOhm, dürften die Spannung also nicht

auf 2 Volt runterziehen wenn Du 10KOhm als Pullup benutzt. Dann ist es wohl doch ein anderer Fehler.

Moin,

Pinbelegung ist nicht gleich.

Den L298 (ohne Dioden) gibt es bei Reichelt.

https://www.reichelt.de/vollbr…e&trstct=pos_0&nbc=1&&r=1

Die Dioden müßtes Du extern beschalten.

Im Datenblatt (kannst Du auch bei Reichelt runterladen) ist beschrieben wie sie beschaltet werden.

Datasheets L293/293D im Anhang, L298D ebenso

L298N hat keine Freilaufdioden

Moin

Quote

So wie dass aussieht, gehen die GPIO´s direkt auf den Chip.

Wovon ich dann nicht von großer Leistung der Anschlüsse ausgehe.

Zitat aus:

https://datasheets.raspberrypi…2040/rp2040_datasheet.pdf

unter

2.19.4. Pads

Quote

Pad electrical behaviour can be adjusted to meet the requirements of the external

circuitry. The following adjustments are available:

• Output drive strength can be set to 2mA, 4mA, 8mA or 12mA