Giusto, che sciocco, troppi write su Arduino....

Intanto Python2 o 3?

Su un file binario si scrivono byte.
In Python2 i byte sono le stringhe "standard":

.write(chr(int("FF", 16)))

In Python3 i byte sono gli oggetti bytes:

.write(bytes([int("FF", 16)]))

--- Ultima modifica di Claudio_F in data 2018-09-06 17:44:23 ---

Un file binario è composto da byte.

Ogni byte contiene un valore da zero a duecentocinquantacinque.

Questo valore, mettiamo duecentocinquantacinque, può essere rappresentato a video in diversi modi: esadecimale 'FF', binario '11111111', decimale '255' ecc.

Ma non esiste un "valore esadecimale" in sè stesso.

L'utente può certamente inserire la stringa di caratteri FF (che rappresentano il valore duecentocinquantacinque espresso in esadecimale), ma nel file non si devono scrivere i due byte della codifica ASCII dei caratteri 'F', si deve scrivere un solo byte di valore duecentocinquantacinque.

Quindi:

open('nomefile', 'wb').write(int(stringa_esa, 16))

--- Ultima modifica di Claudio_F in data 2018-09-06 17:42:05 ---

Direi che è il contrario, sei tu a tenere bloccato Tkinter monopolizzando il tempo, e quindi congelando la GUI.

Come detto nell'altro thread con il metodo 'configure' dei widget cambi le proprietà, ma poi bisogna anche permettere a Tkinter di aggiornare la grafica, e i modi sono due, o si chiama il metodo 'update' del singolo widget, o si chiama il metodo 'update_idletasks' della root, che permette la gestione degli eventi accumulati in coda.

Altrimenti bisogna riscrivere la propria logica in modo non bloccante.

C'è qualcosa che non quadra.

O il programma è strutturato tramite due o più thread/processi indipendenti, e allora può esserci qualcuno che vuole qualcosa dall'altro in modo asincrono... oppure l'unico processo in corso è il mainloop della GUI, e in tal caso è la GUI che deve controllare periodicamente la periferica e agire di conseguenza. Per i compiti periodici si può usare il metodo after:

try:
    import Tkinter as tk
except:
    import tkinter as tk

#-------------------------------------------------------------
def recall(msg):
    msg = msg[1:] + msg[:1]
    lab.configure(text=msg[:16])
    root.after(100, recall, msg)

#-------------------------------------------------------------
root = tk.Tk()
root.resizable(False, False)

frame = tk.Frame(root, relief=tk.RAISED, border=1, bg='black')
frame.pack(padx=16, pady=16)

lab = tk.Label(
    frame, relief=tk.SUNKEN, border=1,
    bg='#0D7FFF', fg='white', width=18, height=1,
    font=('monospace', 14, 'normal')
    )
lab.pack(pady=8, padx=8, ipady=4)

recall('               '
       'THE  QUICK  BROWN  FOX  JUMPS  OVER  THE  LAZY  DOG')

root.mainloop()

Naturalmente tutte le altre funzioni/metodi non devono bloccare il mainloop congelando la GUI, altrimenti anche 'recall' non viene chiamata.

In un programma con GUI il mainloop comanda sempre, tutte le altre funzioni devono solo gestire nel più breve tempo possibile gli eventi che la GUI ha rilevato.

Se ci sono attività cicliche che richiedono molto tempo, la loro esecuzione va scomposta in molti passaggi veloci chiamati dal mainloop.


--- Ultima modifica di Claudio_F in data 2017-11-26 10:14:14 ---

Vuol dire che l5 identifica un oggetto None (che non ha il metodo configure) invece dell' oggetto Label che ti aspetteresti, quindi c'è un assegnamento errato a I5.


--- Ultima modifica di Claudio_F in data 2017-11-04 23:45:35 ---

iltuowidget.configure(text='....')
iltuowidget.update()

--- Ultima modifica di Claudio_F in data 2017-11-04 17:25:07 ---

L'interfaccia normalmente si aggiorna quando è finita l'esecuzione di ogni funzione/metodo (e quindi quando il controllo torna al mainloop della GUI).

Per forzare l'aggiornamento di un widget bisogna chiamarne il metodo update.

Nel primo caso non funziona perché il parametro 'command' vuole il nome di una funzione da chiamare, non il risultato della chiamata di una funzione (a meno che il risultato sia a sua volta una funzione, ma non è questo il caso).

Nel secondo caso funziona perché 'lambda' crea e restituisce una funzione (senza nome, ma che viene assegnata al parametro 'command'), che quando chiamata a sua volta chiama la funzione che hai specificato.

L'uso delle funzioni come oggetti da passare/ritornare, e non solo come subroutine da chiamare, è comunque una caratteristica "avanzata", ma fa parte del modo estremamente generale di Python di trattare qualsiasi cosa come un generico oggetto (dai dati elementari ai moduli).


--- Ultima modifica di Claudio_F in data 2017-10-30 20:50:52 ---

Ah, interessante. Mi accodo alla domanda.
Questo scherzo lo fa solo con py3, mentre in py2 i risultati sono quelli che ci si aspetterebbe.

>>> round(6.5)
6
>>> round(6.500000000000001)
7

Il codice normalmente si incolla come testo (usando l'apposito tag ).

Comunque il None deriva da questo:

>>> def f():
...     pass
... 
>>> print f()
None
>>> 

print f() stampa quanto viene restituito dalla funzione.

In questo esempio la funzione 'f' non compie nessuna operazione e non restituisce al chiamante nessun "valore" esplicito, perciò per default restituisce None (dato o oggetto nullo) che viene stampato da print.


--- Ultima modifica di Claudio_F in data 2017-09-27 11:47:16 ---