micropython écriture marche pas Fermé

Question

bonjour, j'ai un petit soucil, j'ai un raspberry pi pico sur micropython et je suis en train de faire un OS de console desus.

Dans un fichier main.py, il y'a un code qui par rapport au chiffre qu'il y'a dans le fichier whatdo.txt ouvre un fichier python précis.

Tout fonctionne très bien, lors que je met par exemple le chiffre 3 dans whatdo.txt il ouvre g3.py, lors que je met 2 dans whatdo.txt il ouvre g2.py etc...

Mais quand je modifie la donnée de whatdo.txt via le fichier g1.py (ce qui est le cas), il change pas la valeur de whatdo.txt et me retourne 1 dans le terminal. pourquoi ?

Main.py:

print("test")
game = open("whatdo.txt", "r")
gamen = game.read()
gamestr = str(gamen)
gameint = int(gamestr)
print(gameint)
if gameint == 0:
    print("menu!")
    import menu
if gameint == 1:
    print("ok")
    from games import g1
if gameint == 2:
    from games import g2
if gameint == 3:
    from games import g3

g1.py:

f = open("whatdo.txt", "w")
f.write("0")
f.close()
#===== SECUR ZONE ======
pass1 = "X"
pass2 = "B"
pass3 = "Y"
pass4 = "B"
randoms = 0
times = 0
timeinsec = 0
gameover = False
playerx = 0
playery = 0

#===== START CONFIG ZONE ======
from machine import Pin,SPI,PWM
import framebuf
import time
import os
import gc
import machine
#== autre import
import random
import math
import sys

BL = 13
DC = 8
RST = 12
MOSI = 11
SCK = 10
CS = 9

class LCD_1inch3(framebuf.FrameBuffer):
    def __init__(self):
        self.width = 240
        self.height = 240
        
        self.cs = Pin(CS,Pin.OUT)
        self.rst = Pin(RST,Pin.OUT)
        
        self.cs(1)
        self.spi = SPI(1)
        self.spi = SPI(1,1000_000)
        self.spi = SPI(1,100000_000,polarity=0, phase=0,sck=Pin(SCK),mosi=Pin(MOSI),miso=None)
        self.dc = Pin(DC,Pin.OUT)
        self.dc(1)
        self.buffer = bytearray(self.height * self.width * 2)
        super().__init__(self.buffer, self.width, self.height, framebuf.RGB565)
        self.init_display()

self.cyan =   0x0f0f
        self.black =   0x0000
        self.red   =   0x07E0
        self.green =   0x001f
        self.blue  =   0xf800
        self.white =   0xffff
        self.yellow  =   0x07FF
        
    def write_cmd(self, cmd):
        self.cs(1)
        self.dc(0)
        self.cs(0)
        self.spi.write(bytearray([cmd]))
        self.cs(1)

def write_data(self, buf):
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(bytearray([buf]))
        self.cs(1)

def init_display(self):
        """Initialize dispaly"""  
        self.rst(1)
        self.rst(0)
        self.rst(1)
        
        self.write_cmd(0x36)
        self.write_data(0x70)

self.write_cmd(0x3A) 
        self.write_data(0x05)

self.write_cmd(0xB2)
        self.write_data(0x0C)
        self.write_data(0x0C)
        self.write_data(0x00)
        self.write_data(0x33)
        self.write_data(0x33)

self.write_cmd(0xB7)
        self.write_data(0x35)

self.write_cmd(0xBB)
        self.write_data(0x19)

self.write_cmd(0xC0)
        self.write_data(0x2C)

self.write_cmd(0xC2)
        self.write_data(0x01)

self.write_cmd(0xC3)
        self.write_data(0x12)

self.write_cmd(0xC4)
        self.write_data(0x20)

self.write_cmd(0xC6)
        self.write_data(0x0F)

self.write_cmd(0xD0)
        self.write_data(0xA4)
        self.write_data(0xA1)

self.write_cmd(0xE0)
        self.write_data(0xD0)
        self.write_data(0x04)
        self.write_data(0x0D)
        self.write_data(0x11)
        self.write_data(0x13)
        self.write_data(0x2B)
        self.write_data(0x3F)
        self.write_data(0x54)
        self.write_data(0x4C)
        self.write_data(0x18)
        self.write_data(0x0D)
        self.write_data(0x0B)
        self.write_data(0x1F)
        self.write_data(0x23)

self.write_cmd(0xE1)
        self.write_data(0xD0)
        self.write_data(0x04)
        self.write_data(0x0C)
        self.write_data(0x11)
        self.write_data(0x13)
        self.write_data(0x2C)
        self.write_data(0x3F)
        self.write_data(0x44)
        self.write_data(0x51)
        self.write_data(0x2F)
        self.write_data(0x1F)
        self.write_data(0x1F)
        self.write_data(0x20)
        self.write_data(0x23)
        
        self.write_cmd(0x21)

self.write_cmd(0x11)

self.write_cmd(0x29)

def show(self):
        self.write_cmd(0x2A)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0xef)
        
        self.write_cmd(0x2B)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0xEF)
        
        self.write_cmd(0x2C)
        
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(self.buffer)
        self.cs(1)

if True:
    pwm = PWM(Pin(BL))
    pwm.freq(1000)
    pwm.duty_u16(32768)#max 65535

LCD = LCD_1inch3()
    #color BRG
    
    def circle(x,y,r,c):
        LCD.hline(x-r,y,r*2,c)
        for i in range(1,r):
            a = int(math.sqrt(r*r-i*i)) # Pythagoras!
            LCD.hline(x-a,y+i,a*2,c) # Lower half
            LCD.hline(x-a,y-i,a*2,c) # Upper half
    
    def ring(x,y,r,c):
        LCD.pixel(x-r,y,c)
        LCD.pixel(x+r,y,c)
        LCD.pixel(x,y-r,c)
        LCD.pixel(x,y+r,c)
    
    LCD.show()
    
    keyA = Pin(15,Pin.IN,Pin.PULL_UP)
    keyB = Pin(17,Pin.IN,Pin.PULL_UP)
    keyX = Pin(19 ,Pin.IN,Pin.PULL_UP)
    keyY= Pin(21 ,Pin.IN,Pin.PULL_UP)
    
    up = Pin(2,Pin.IN,Pin.PULL_UP)
    dowm = Pin(18,Pin.IN,Pin.PULL_UP)
    left = Pin(16,Pin.IN,Pin.PULL_UP)
    right = Pin(20,Pin.IN,Pin.PULL_UP)
    ctrl = Pin(3,Pin.IN,Pin.PULL_UP)
    
    #===== END CONFIG ZONE ======
while True:
    if(keyA.value() == 0):
        f = open("whatdo.txt", "w")
        f.write("0")
        f.close()
        machine.reset()

Pouriez vous m'aider SVP ?

mamiemando · Answer

Bonjour,

Je n'ai pas trop compris l'intérêt de maintenir dans whatdo.txt ce que tu pourrais faire en ayant simplement cet entier (quitte à l'initialiser à partir de whatdo.txt et à rafraîchir whatdo.txt quand tu quittes).

De plus, il est un peu étrange de faire des imports conditionnés par le contenu du fichier. Normalement, chacun de tes fichiers g1, g2, g3 devraient avoir un point d'entrée (c'est à dire une fonction qui correspond au programme principal, disons main)

Enfin, il serait plus propre de lire ton fichier avec le context manager with.

g1.py

def main():
    print("G1")

g2.py

def main():
    print("G1")

g3.py

def main():
    print("G3")

main.py

from g1 import main as main_g1
from g2 import main as main_g2
from g3 import main as main_g3

# Charger i à partir de "whatdo.txt" s'il existe
i = None
try:
    with open("whatdo.txt", "r") as f:
        i = int(f.read())
    print(f"i = {i} chargé à partir de whatdo.txt")
except:
    pass

while True:
    while i is None:
        i = int(input("Saisir i [1=g1, 2=g2, 3=g4, 0=quit]: "))
    if i == 0:
        break
    elif i == 1:
        main_g1()
    elif i == 2:
        main_g2()
    elif i == 3:
        main_g3()
    # Sauver i dans "whatdo.txt"
    with open("whatdo.txt", "w") as f:
        print(i, file=f)
    i = None

Exemple :

(mando@silk) (~) $ python3 main.py 
Saisir i [1=g1, 2=g2, 3=g4, 0=quit]: 1
G1
Saisir i [1=g1, 2=g2, 3=g4, 0=quit]: 2
G2
Saisir i [1=g1, 2=g2, 3=g4, 0=quit]: 3
G3
Saisir i [1=g1, 2=g2, 3=g4, 0=quit]: 4
Saisir i [1=g1, 2=g2, 3=g4, 0=quit]: 0

Bonne chance

Micropython écriture marche pas

1 réponse

Discussions similaires