PiPico Micropython

Für den ersten Erfolg: Blinky

1

import machine

2

l=machine.Pin(25,machine.Pin.OUT)

3

4

import utime as u

5

for i in range(100):

6

     l.value(1)

7

     u.sleep(1)

8

     l.value(0)

9

     u.sleep(1)

Als Programmierschnittstelle kann man bei Ubuntu auch einfach "minicom" 
verwenden. Aufruf mit

1

minicom -D /dev/ttyACM0

mit CTRL-E kommt man in den "paste mode" in den man den obigen LED-Code 
einfach kopieren kann. Dieser wird dann mit CTRL-D beendet und Voila .. 
die LED blinkt.

chris_ schrieb:
> und es stellt sich die interessante Frage,
> ob der PiPico gegenüber dem ESP32 Vorzüge besitzt.

Hat ein Trekker gegenüber einem Laster Vorzüge?

Da es sich um zwei völlig unterschiedliche Produkte handelt, kommt es 
doch sehr darauf an, was du damit machen willst.

OK, du will MicroPython ausführen. Das ist aber keine Anwendung, sondern 
eine Programmiersprache. Du musst musst schon konkreter werden.

Jack V. schrieb:
> Das allerdings ist ’ne Definitionssache: das MicroPython auf dem μC ist
> sehr wohl ein Programm, welches die Scripte ausführt.

Man kauft sich aber weder einen ESP32 noch einen Raspberry Pi, um Python 
Scripte auszuführen. Sondern man führt Python Scripte aus, um etwas 
bestimmtes zu erreichen. Auf dieses "etwas" kommt es an.

Die Frage, ob darauf Python läuft ist natürlich ebenso zentral, wenn man 
in Python programmieren will. Diese hast du ja schon umfangreich 
beantwortet. Dafür habe ich dir ein +1 gegeben.

Mittlerweil läuft bei mir Thonny:
Das Problem war meine Python Installation.
Ich hatte es mehrfach mit

pip3 install thonny

versucht. Aber scheinbar liegt da eine zu alte Python Version dahinter.

Mit

pip3.7 install thonny

hat es funktioniert.

In "thonny" selbst muss man dann noch bei "run" "select interpreter" 
auswählen und dort den PiPico Microphython Interpreter selektieren.

Hier gibt es ein interessantes Repository mit dem PiPico als 
Waveform-Generator:

https://github.com/romilly/pico-code/tree/master/src/pico_code/pico/experiments

( den ich noch nicht ausprobiert habe )

chris_ schrieb im Beitrag #6595875:
> Deine Klugscheisserei geht mir langsam ernsthaft auf die Nerven.

Ich habe diesen Beitrag geschrieben, weil ich dir eine zur Anwendung 
passende Antwort geben wollte.

Wenn du keine konkrete Anwendung im Sinn hast, sondern einfach nur ein 
bisschen Python ausprobieren willst, dann kannst du das einfach 
mitteilen und gut ist.

Wer hier die Helfer beschimpft, muss damit rechnen, bald keine Hilfe 
mehr zu bekommen. Oder gar verarscht zu werden - hatten wir alles schon 
oft genug.

Hier habe ich mal den Funktionsgenerator
https://github.com/romilly/pico-code/blob/master/docs/fungen.md
ausprobiert.
Das Signal auf dem Oszi ist nicht ganz so schön wie im Beispiel.
Interessanter wäre eventuell eine DDS.

Will ihm niemand mehr helfen?

Jack V. schrieb:
> Naja, es fehlt eine Frage.

chris_ schrieb:
> und es stellt sich die interessante Frage, ob der PiPico gegenüber dem
> ESP32 Vorzüge besitzt.

Jack V. schrieb:
> Ich denke, dazu bereits etwas geschrieben zu haben.

Oh sorry, ich habe dich mit jemand anderem verwechselt.

chris_
>und es stellt sich die interessante Frage, ob der PiPico gegenüber dem
>ESP32 Vorzüge besitzt.
Jack V. (jackv)
>Ansonsten hat so’n netter Schweizer das Thema mal aufgegriffen (und dazu
>noch den STM32 von den BlackPill-Boards in den Vergleich aufgenommen):
>https://www.youtube.com/watch?v=cVHCllbN3bQ

Eine sehr schöne Analyse meiner Eingangsfrage, welche das ganze auf den 
Punkt bringt. Das Video sollte man vielleicht im Hautpthread posten:

https://www.mikrocontroller.net/topic/raspberry-pi-pico-mikrocontroller-board-mit-cortex

Die Ansichten von Andreas Spiess ( "the guy with the swiss accent" ) 
sind aber ein wenig "biased".
Ich weiß, er hat den ULP des ESP32 ziemlich genau analysiert und die PIO 
des RP2040 damit verglichen. Die PIO ist, was den Befehlssatz angeht, 
weniger leistungsfähig. Allerdings wird man mit dem ULP kein DVI-Signal 
erzeugen können.
Im Vergleich wird auch gezeigt, dass der RP2040 keine I2S Schnittstelle 
hat. Aber genau die dürfte man mit der PIO gut realisieren können.
Von Pimoroni gibt's bereits ein Shield dazu:

https://shop.pimoroni.com/products/pico-audio-pack

Insofern: In einigen Aspekten ist der RP2040 deutlich weniger 
leistungsfähig als der ESP32, aber bei bestimmten Anwendungen wird der 
ESP32 nicht mithalten können, wenn die speziellen Hardwareeinheiten SIO 
und PIO benötigt werden.

Ich möchte einen I2C Peripherie Baustein an den PiPico anschließen.
Um den Baustein einfach testen zu können, will ich die Register auslesen 
und über Tastatureingaben direkt verändern können.

Es wird also eine Hexadezimal Aus- und Eingabe gebraucht.

Der Python Syntax scheint stark bezüglich der Versionsn 2.x und 3.x sehr 
unterschiedlich zu sein.

Eine HEX-Ausgabe habe ich auf diese Weise geschafft:

1

ar=[1,2,10,127,255,0xB,0xAA]

2

3

for b in ar:

4

    print("0x%02x"%b)

1

>>> %Run -c $EDITOR_CONTENT

2

0x01

3

0x02

4

0x0a

5

0x7f

6

0xff

7

0x0b

8

0xaa

3 Zeilen Code und eine halbe Stunde rumprobieren, deshalb poste ich die 
Zeilen hier.

Hat jemand einen einfachen Editor für HEX-Eingaben?

Das Board mit der MPU6050 scheint die I2C-PullUps schon integriert zu 
haben.

Ein I2C-Scan mit

1

import machine

2

sda=machine.Pin(0)

3

scl=machine.Pin(1)

4

i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)

5

print(i2c.scan())

ergibt die Adresse 104:

1

MicroPython v1.14 on 2021-02-05; Raspberry Pi Pico with RP2040

2

Type "help()" for more information.

3

>>> %Run -c $EDITOR_CONTENT

4

[104]

Hier eine Funktion für ein Registerdump einer MPU6050 über die 
I2C-Schnittstelle:

1

# read chip registers of a MPU6050

2

# and display contents as hex values

3

4

import machine

5

6

sda=machine.Pin(0)

7

scl=machine.Pin(1)

8

i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)

9

10

i2cAdr=104

11

12

# write power managment register

13

i2c.writeto(i2cAdr, bytearray([107, 0]))

14

15

for chipRegister in range(0,118):

16

17

    ar = i2c.readfrom_mem(i2cAdr, chipRegister, 1)

18

    for b in ar:

19

        print("register %2d : 0x%02x"%(chipRegister,b)),

Output:

1

>>> %Run -c $EDITOR_CONTENT

2

register  0 : 0x81

3

register  1 : 0x01

4

register  2 : 0x7e

5

register  3 : 0xb0

6

register  4 : 0xd2

7

register  5 : 0xce

8

register  6 : 0xf6

9

register  7 : 0xc0

10

...

Uwe D. (monkye)
28.02.2021 13:30
>Hier noch eine ähnliche Lösung:
>https://www.instructables.com/Arbitrary-Wave-Generator-With-the-Raspberry-Pi-Pic/

Nicht schlecht ... 125MSPs mit Python.
OK, es wird nur die DMA zusammmen mit der PIO konfiguriert, aber das 
Projekt ist ziemlich gut gemacht.
Wahrscheinlich lässt sich der Transistortester mit dem RP2040 auf eine 
ganz neue Stufe stellen.

Weiter geht's mit der PiPico Python-Sammlung:

ein SPI Test

1

import machine

2

3

#led

4

led=machine.Pin(25,machine.Pin.OUT)

5

6

#spi interface

7

ssn=machine.Pin(5,machine.Pin.OUT)

8

spi_sck=machine.Pin(2,machine.Pin.OUT)

9

spi_tx=machine.Pin(3,machine.Pin.OUT)

10

spi_rx=machine.Pin(4,machine.Pin.OUT)

11

12

# 100Hz SPI

13

spi=machine.SPI(0,baudrate=100,sck=spi_sck, mosi=spi_tx, miso=spi_rx)

14

15

import utime as u

16

17

tog=1

18

19

def outpx(data):

20

    global tog

21

    tog=not tog

22

    led.value(tog)

23

24

    ssn.low()

25

    spi.write(data)

26

    ssn.high()

27

28

for i in range(10000):

29

    outpx(bytes([i]))

30

    u.sleep(0.1)

Bei Python scheint mir die Byteverarbeitung deutlich komplizierter als 
in C.

Ich habe eine Funktion zum Schreiben von 3 Bytes an einen externen 
SPI-Baustein erstellt. Der Code funktioniert, gefällt mir aber nicht. Es 
muss eine elegantere Möglichkeit in MicroPython geben.

Hat jemand einen Tipp?

Hier der aktuelle Code:

1

import struct

2

3

tog=1

4

5

def spiWrite(data):

6

    global tog

7

    tog=not tog

8

    led.value(tog)

9

10

    ssn.low()

11

    spi.write(data)

12

    ssn.high()

13

14

def sendCommand(command,param):

15

    data=bytearray(3)

16

    d=struct.pack( "<H", param)

17

    data[0]=d[1]

18

    data[1]=d[0]

19

    dd=struct.pack( "b", command)

20

    data[2]=dd[0]

21

    print(data)

22

    spiWrite(data)

Zum Senden von Bytes:

1

spi.write(b'\x01\x23\x45\x67')

Zum Senden von Integern:

1

(1024).to_bytes(2, byteorder='big')

Ich finde MicroPython ist das beste Betriebssystem für Mikrocontroller, 
weil es so viel Spaß macht!

Apropos ... mittlerweile gibt es MicroPython auf dem RP2040 im WOKWI 
simulator:

https://wokwi.com/

Wirklich erstaunlich, was man mit Webinterfaces heutzutage machen kann.
Ich habe die Schaltung von oben mit dem MPU6050 mal ins WOKWI übertragen 
und nach dem Start

1

print(i2c.scan())

ins Befehlsfenster getippt.

Hier noch die Anleitung:
https://docs.wokwi.com/guides/micropython