Bonjour

Pardon pour ce titre trompeur mais je sais que la boucle est un sujet sérieux avec Python

> J'ai un code qui fait fonctionner un écran LCD avec Raspberry Pi

> A l'intérieur de ce code, on affiche des phrases et grace à vous j'ai approché ce que je souhaite faire avec ces phrases : faire apparaitre des phrases lentement. (conversation ici)

Mais je n'arrive pas à boucler cette partie du code qui affiche les phrases. Le code fait à la fois fonctionner les GPIO et le LCD et envoie du texte

avant de l'efface.

Je voudrais que ce texte reste. Toutes mes tentatives avec while True : ont râté je ne sais pas où je dois le mettre pour simplement répéter l'apparition des phrases

J'espère être clair.

MERCI

Soit le code :

#!/usr/bin/python
#
# HD44780 20x4 LCD Test Script for
# Raspberry Pi
#
# Author : Matt Hawkins
# Site   : http://www.raspberrypi-spy.co.uk/
# 
# Date   : 09/08/2012
#

# The wiring for the LCD is as follows:
# 1 : GND
# 2 : 5V
# 3 : Contrast (0-5V)*
# 4 : RS (Register Select)
# 5 : R/W (Read Write)       - GROUND THIS PIN
# 6 : Enable or Strobe
# 7 : Data Bit 0             - NOT USED
# 8 : Data Bit 1             - NOT USED
# 9 : Data Bit 2             - NOT USED
# 10: Data Bit 3             - NOT USED
# 11: Data Bit 4
# 12: Data Bit 5
# 13: Data Bit 6
# 14: Data Bit 7
# 15: LCD Backlight +5V**
# 16: LCD Backlight GND

#import
import RPi.GPIO as GPIO
import time
import os
import sys


# Define GPIO to LCD mapping
LCD_RS = 7
LCD_E  = 8
LCD_D4 = 25 
LCD_D5 = 24
LCD_D6 = 23
LCD_D7 = 18
LED_ON = 15

# Define some device constants
LCD_WIDTH = 20    # Maximum characters per line
LCD_CHR = True
LCD_CMD = False

LCD_LINE_1 = 0x80 # LCD RAM address for the 1st line
LCD_LINE_2 = 0xC0 # LCD RAM address for the 2nd line
LCD_LINE_3 = 0x94 # LCD RAM address for the 3rd line
LCD_LINE_4 = 0xD4 # LCD RAM address for the 4th line 

# Timing constants
E_PULSE = 0.00005
E_DELAY = 0.00005

def main():
  # Main program block

  GPIO.setmode(GPIO.BCM)       # Use BCM GPIO numbers
  GPIO.setup(LCD_E, GPIO.OUT)  # E
  GPIO.setup(LCD_RS, GPIO.OUT) # RS
  GPIO.setup(LCD_D4, GPIO.OUT) # DB4
  GPIO.setup(LCD_D5, GPIO.OUT) # DB5
  GPIO.setup(LCD_D6, GPIO.OUT) # DB6
  GPIO.setup(LCD_D7, GPIO.OUT) # DB7
  GPIO.setup(LED_ON, GPIO.OUT) # Backlight enable

  # Initialise display
  lcd_init()

  # Toggle backlight off-on
  GPIO.output(LED_ON, False)
  time.sleep(1)
  GPIO.output(LED_ON, True)
  time.sleep(1)

  # 1

  def typewriter_like(sentence, lcd_line, delay=0.7):
    for i,letter in enumerate(sentence):
    lcd_byte(LCD_LINE_1, LCD_CMD)
    lcd_string(sentence[:i+1],1) 
    time.sleep(delay)
  
  typewriter_like("EXEMPLE", LCD_LINE_1)

  def typewriter_like(sentence, lcd_line, delay=0.7):
    for i,letter in enumerate(sentence):
    lcd_byte(LCD_LINE_2, LCD_CMD)
    lcd_string(sentence[:i+1],1) 
    time.sleep(delay)
  
  typewriter_like("EXEMPLESS", LCD_LINE_2)

  def typewriter_like(sentence, lcd_line, delay=0.7):
    for i,letter in enumerate(sentence):
    lcd_byte(LCD_LINE_3, LCD_CMD)
    lcd_string(sentence[:i+1],1) 
    time.sleep(delay)
  
  typewriter_like("EXEMPLESSS", LCD_LINE_3)

  def typewriter_like(sentence, lcd_line, delay=0.7):
    for i,letter in enumerate(sentence):
    lcd_byte(LCD_LINE_4, LCD_CMD)
    lcd_string(sentence[:i+1],1) 
    time.sleep(delay)
  
  typewriter_like("EXEMPLESSSS", LCD_LINE_4)

  
  time.sleep(10) # 10 second delay 

# BLANK
  lcd_byte(LCD_LINE_1, LCD_CMD)
  lcd_string("",2) 
  lcd_byte(LCD_LINE_2, LCD_CMD)
  lcd_string("",2)
  lcd_byte(LCD_LINE_3, LCD_CMD)
  lcd_string("",2)
  lcd_byte(LCD_LINE_4, LCD_CMD)
  lcd_string("",2) 

  time.sleep(4) # 4 second delay


  # Turn off backlight
  GPIO.output(LED_ON, False)

def lcd_init():
  # Initialise display
  lcd_byte(0x33,LCD_CMD)
  lcd_byte(0x32,LCD_CMD)
  lcd_byte(0x28,LCD_CMD)
  lcd_byte(0x0C,LCD_CMD)  
  lcd_byte(0x06,LCD_CMD)
  lcd_byte(0x01,LCD_CMD)  

def lcd_string(message,style):
  # Send string to display
  # style=1 Left justified
  # style=2 Centred
  # style=3 Right justified

  if style==1:
    message = message.ljust(LCD_WIDTH," ")  
  elif style==2:
    message = message.center(LCD_WIDTH," ")
  elif style==3:
    message = message.rjust(LCD_WIDTH," ")

  for i in range(LCD_WIDTH):
    lcd_byte(ord(message[i]),LCD_CHR)

def lcd_byte(bits, mode):
  # Send byte to data pins
  # bits = data
  # mode = True  for character
  #        False for command

  GPIO.output(LCD_RS, mode) # RS

  # High bits
  GPIO.output(LCD_D4, False)
  GPIO.output(LCD_D5, False)
  GPIO.output(LCD_D6, False)
  GPIO.output(LCD_D7, False)
  if bits&0x10==0x10:
    GPIO.output(LCD_D4, True)
  if bits&0x20==0x20:
    GPIO.output(LCD_D5, True)
  if bits&0x40==0x40:
    GPIO.output(LCD_D6, True)
  if bits&0x80==0x80:
    GPIO.output(LCD_D7, True)

  # Toggle 'Enable' pin
  time.sleep(E_DELAY)    
  GPIO.output(LCD_E, True)  
  time.sleep(E_PULSE)
  GPIO.output(LCD_E, False)  
  time.sleep(E_DELAY)      

  # Low bits
  GPIO.output(LCD_D4, False)
  GPIO.output(LCD_D5, False)
  GPIO.output(LCD_D6, False)
  GPIO.output(LCD_D7, False)
  if bits&0x01==0x01:
    GPIO.output(LCD_D4, True)
  if bits&0x02==0x02:
    GPIO.output(LCD_D5, True)
  if bits&0x04==0x04:
    GPIO.output(LCD_D6, True)
  if bits&0x08==0x08:
    GPIO.output(LCD_D7, True)

  # Toggle 'Enable' pin
  time.sleep(E_DELAY)    
  GPIO.output(LCD_E, True)  
  time.sleep(E_PULSE)
  GPIO.output(LCD_E, False)  
  time.sleep(E_DELAY)   

if __name__ == '__main__':
  main()

-
Edité par NicolasLunard 13 novembre 2014 à 14:24:26

Tu veux faire répéter quelle partie de ton code, exactement ?

PArdon j'avais voulu mettre en gras dans le code ce que je voulais répéter, cela a tout bouleversé

J'ai remis le code tel qu'il est

Je voudrais donc répéter les phrases (ici "EXEMPLE") Ligne 81 à 128 (dans mon code il y a de nombreuses autres phrases mais c'est le même principe)

Merci

Salut braconnier ,

Avant toute chose, il faut que tu comprenne que les fonctions servent à automatiser l'exécution de code (et donc l'écriture). Aussi, dans tes lignes mentionnées, il ne sert à rien de redéfinir à chaque fois ta fonction typewriter_like(). Pour faire ce que tu souhaite, il suffit juste de mettre cette partie (pas la définition de la fonction, juste ses appels) dans une boucle.

Et puisque tu veux utiliser une boucle while (boucle infinie):

#Définition de la fonction (ce fait qu'une fois)
def typewriter_like(sentence, lcd_line, delay=0.7):
    for i,letter in enumerate(sentence):
        lcd_byte(lcd_line, LCD_CMD)
        lcd_string(sentence[:i+1],1)
        time.sleep(delay)

#Les variables sur lesquelles on va boucler
mots = ("EXEMPLE", "EXEMPLES", "EXEMPLESS", "EXEMPLESSS")
lcds = (0x80, 0xC0, 0x94, 0xD4)

#La boucle
while True:
    for mot, lcd in zip(mots, lcds):
        typewriter_like(mot, lcd)
    
    time.sleep(10)

    for lcd in lcds:
        lcd_byte(lcd, LCD_CMD)
        lcd_string("",2)
    
    time.sleep(4)

-
Edité par Olygrim 13 novembre 2014 à 17:19:39

Merci Olygrim

J'essaie ton code sur mon Raspberry Pi

> j'avais un souci de reconnaissance de caractères. J'ai rajouté

# -*- coding: latin-1 -*-

au début du script. Ça a l'air de passé

> Mais Python me rembarre pour un probleme d'indentation line 4 que je n'arrive pas à résoudre depuis 1 heure

> Enfin, je te remercie et je comprends parfaitement qu'un bon code est concis mais si j'ai plus d'EXEMPLES (ligne 9) que dois-je mettre ligne 10 ?

MErci

Oui tu as raison, j'avais mal indenté mon code. Je viens de le corriger.

Si tu veux mettre plus de mot, il suffit de les ajouter à la variable mots. Et il faudra également ajouter leur position dans la variable lcds:

mots = ("o", "ol", "oly", "olyg", "olygr", "olygri", "olygrim")
lcds = (0x80, 0xC0, 0x94, 0xD4, 0x80, 0xC0, 0x94)

D'après ce que me dit la console : il y a un souci car "global name "LCD_LINE" is not defined"

(dans "mon" code, je spécifiais le numéro de la ligne 1,2,3,4 et cela fonctionnait)

Mais quitte à ce que mon code soit vilain, redondant, ne pourrais-je pas repartir du code qui marche et juste le boucler tel quel avec un while true au bon endroit ?

(après tout un braconnage n'est pas une chasse à cour princière, tant qu'on a du gibier sous la dent, on est content)

Tu peux remontrer ton code stp

@NicolasLunard: avant de t'amuser avec ce module, au contenu extrêmement redondant, tu devrais apprendre correctement les bases du langage Python.

---

PS: Plus je lis le script d'origine et plus je me dis que son auteur est forcément meilleur électronicien que programmeur... Edit: Bon ok, au premier coup d’œil j'aurais pu m'en rendre compte...

-
Edité par Anonyme 13 novembre 2014 à 18:16:16

Olygrim a écrit:

Tu peux remontrer ton code stp

Mon code initial (il est en haut du post) ? Ou le code avec tes propositions ?

@Psycopy : je sais bien que ce n'est pas une bonne méthode. Mais en fait j'avoue avoir beaucoup de mal (l'âge sans doute et un peu le manque de temps) à bien apprendre Python. Du coup je me résous à essayer de faire ce que je veux (en l'occurrence afficher des phrases) avec les moyens du bord (connaissance : 0) et l'amicale collaboration de forumeurs bienveillants. Du coup peu à peu j'apprends...

Merci à ceux qui veulent bien m'aider. Une fois que j'ai ma boucle, je n'embête plus personne. Promis (jusqu'à demain)

Je n'avais pas regardé le code en détail (ne connaissant pas le module GPIO, et provenant de différentes sources), mais effectivement il n'y a aucune boucle dans le code.

Le code avec les propositions

Si on reprend le code, sans connaître RPi.GPIO, voilà ce que j'aurais vu en procédural :

import

import RPi.GPIO as GPIO import time

Define GPIO to LCD mapping

LCD_RS = 7 LCD_E = 8 LCD_D4 = 25 LCD_D5 = 24 LCD_D6 = 23 LCD_D7 = 18 LED_ON = 15

Define some device constants

LCD_WIDTH = 20 # Maximum characters per line LCD_CHR = True LCD_CMD = False

LCD_LINES = (0x80, 0xC0, 0x94, 0xD4)

Timing constants for signal

E_DELAY = 0.00005

def init():

GPIO.setmode(GPIO.BCM)
for pin in (LCD_E, LCD_RS, LCD_D4, LCD_D5, LCD_D6, LCD_D7, LED_ON):
    GPIO.setup(pin, GPIO.OUT)
time.sleep(0.015)
for byte in (0x33, 0x32, 0x28, 0x0C, 0x06, 0x01):
    _send_byte(byte, LCD_CMD)
for bool in (False, True):
    GPIO.output(LED_ON, bool)
    time.sleep(0.5)

def _send_byte(byte, mode):

GPIO.output(LCD_RS, mode)
for masks in ((0x10, 0x20, 0x40, 0x80), (0x01, 0x02, 0x04, 0x08)):
    for pin, mask in zip((LCD_D4, LCD_D5, LCD_D6, LCD_D7), masks):
        GPIO.output(pin, byte&mask==mask)
    time.sleep(E_DELAY)
    for bool in (True, False):
        GPIO.output(LCD_E, bool)
        time.sleep(E_DELAY)

def write(text, line, align=1)

align = (str.ljust, str.center, str.rjust)[align-1]
_send_byte(LCD_LINES[line-1], LCD_CMD)
for byte in align(text, LCD_WIDTH, ' ').encode('ascii')[:LCD_WIDTH]:
    _send_byte(byte, LCD_CHR)

def clear(line=None):

if line is None:
    for i in range(1, 5):
        write('', i)
else:
    write('', line)

def quit():

GPIO.output(LED_ON, False)

Test

if name == "main":

init()
write("v0.1", 3, 4)
text = "Welcome !"
for i in range(len(text)):
    time.sleep(0.5)
    write(text[:i+1], 2, 2)
time.sleep(5)
clear(2)
write('Bye, bye...', 1)
time.sleep(3)
quit()

</pre>

Je laisse de coté l'idée de la POO pour plus tard (en plus j'ai rien pour tester alors c'est pas drole...)

-
Edité par Anonyme 13 novembre 2014 à 18:42:37

Olygrim a écrit:

Le code avec les propositions

Le voici (en espérant que le copier/coller depuis le Raspberry jusqu'à mon mac via un email n'ai pas tout chambouler)

#!/usr/bin/python
# -*- coding: latin-1 -*-
# HD44780 20x4 LCD Test Script for
# Raspberry Pi
#
# Author : Matt Hawkins
# Site   : http://www.raspberrypi-spy.co.uk/
# 
# Date   : 09/08/2012
#

# The wiring for the LCD is as follows:
# 1 : GND
# 2 : 5V
# 3 : Contrast (0-5V)*
# 4 : RS (Register Select)
# 5 : R/W (Read Write)       - GROUND THIS PIN
# 6 : Enable or Strobe
# 7 : Data Bit 0             - NOT USED
# 8 : Data Bit 1             - NOT USED
# 9 : Data Bit 2             - NOT USED
# 10: Data Bit 3             - NOT USED
# 11: Data Bit 4
# 12: Data Bit 5
# 13: Data Bit 6
# 14: Data Bit 7
# 15: LCD Backlight +5V**
# 16: LCD Backlight GND

#import
import RPi.GPIO as GPIO
import time
import os
import sys


# Define GPIO to LCD mapping
LCD_RS = 7
LCD_E  = 8
LCD_D4 = 25 
LCD_D5 = 24
LCD_D6 = 23
LCD_D7 = 18
LED_ON = 15

# Define some device constants
LCD_WIDTH = 20    # Maximum characters per line
LCD_CHR = True
LCD_CMD = False

LCD_LINE_1 = 0x80 # LCD RAM address for the 1st line
LCD_LINE_2 = 0xC0 # LCD RAM address for the 2nd line
LCD_LINE_3 = 0x94 # LCD RAM address for the 3rd line
LCD_LINE_4 = 0xD4 # LCD RAM address for the 4th line 

# Timing constants
E_PULSE = 0.00005
E_DELAY = 0.00005

def main():
  # Main program block

  GPIO.setmode(GPIO.BCM)       # Use BCM GPIO numbers
  GPIO.setup(LCD_E, GPIO.OUT)  # E
  GPIO.setup(LCD_RS, GPIO.OUT) # RS
  GPIO.setup(LCD_D4, GPIO.OUT) # DB4
  GPIO.setup(LCD_D5, GPIO.OUT) # DB5
  GPIO.setup(LCD_D6, GPIO.OUT) # DB6
  GPIO.setup(LCD_D7, GPIO.OUT) # DB7
  GPIO.setup(LED_ON, GPIO.OUT) # Backlight enable

  # Initialise display
  lcd_init()

  # Toggle backlight off-on
  GPIO.output(LED_ON, False)
  time.sleep(1)
  GPIO.output(LED_ON, True)
  time.sleep(1)

  # 1

  def typewriter_like(sentence, lcd_line, delay=0.7):
    for i,letter in enumerate(sentence):
    lcd_byte(LCD_LINE, LCD_CMD)
    lcd_string(sentence[:i+1],1) 
    time.sleep(delay)
  
  mots = ("EXEMPLE", "EXEMPLESS", "EXEMPLESSS")
  lcds = (0x80, 0xC0, 0x94)

  while True:
      for mot, lcd in zip(mots,lcds):
          typewriter_like(mot, lcd)

      time.sleep(10)

      for lcd in lcds:
 lcd_byte(lcd, LCD_CMD)
 lcd_string("",2)

      time.sleep(4)

# BLANK
  lcd_byte(LCD_LINE_1, LCD_CMD)
  lcd_string("                    ",2) 
  lcd_byte(LCD_LINE_2, LCD_CMD)
  lcd_string("                    ",2)
  lcd_byte(LCD_LINE_3, LCD_CMD)
  lcd_string("                    ",2)
  lcd_byte(LCD_LINE_4, LCD_CMD)
  lcd_string("                    ",2) 

  time.sleep(4) # 4 second delay

  # Turn off backlight
  GPIO.output(LED_ON, False)

def lcd_init():
  # Initialise display
  lcd_byte(0x33,LCD_CMD)
  lcd_byte(0x32,LCD_CMD)
  lcd_byte(0x28,LCD_CMD)
  lcd_byte(0x0C,LCD_CMD)  
  lcd_byte(0x06,LCD_CMD)
  lcd_byte(0x01,LCD_CMD)  

def lcd_string(message,style):
  # Send string to display
  # style=1 Left justified
  # style=2 Centred
  # style=3 Right justified

  if style==1:
    message = message.ljust(LCD_WIDTH," ")  
  elif style==2:
    message = message.center(LCD_WIDTH," ")
  elif style==3:
    message = message.rjust(LCD_WIDTH," ")

  for i in range(LCD_WIDTH):
    lcd_byte(ord(message[i]),LCD_CHR)

def lcd_byte(bits, mode):
  # Send byte to data pins
  # bits = data
  # mode = True  for character
  #        False for command

  GPIO.output(LCD_RS, mode) # RS

  # High bits
  GPIO.output(LCD_D4, False)
  GPIO.output(LCD_D5, False)
  GPIO.output(LCD_D6, False)
  GPIO.output(LCD_D7, False)
  if bits&0x10==0x10:
    GPIO.output(LCD_D4, True)
  if bits&0x20==0x20:
    GPIO.output(LCD_D5, True)
  if bits&0x40==0x40:
    GPIO.output(LCD_D6, True)
  if bits&0x80==0x80:
    GPIO.output(LCD_D7, True)

  # Toggle 'Enable' pin
  time.sleep(E_DELAY)    
  GPIO.output(LCD_E, True)  
  time.sleep(E_PULSE)
  GPIO.output(LCD_E, False)  
  time.sleep(E_DELAY)      

  # Low bits
  GPIO.output(LCD_D4, False)
  GPIO.output(LCD_D5, False)
  GPIO.output(LCD_D6, False)
  GPIO.output(LCD_D7, False)
  if bits&0x01==0x01:
    GPIO.output(LCD_D4, True)
  if bits&0x02==0x02:
    GPIO.output(LCD_D5, True)
  if bits&0x04==0x04:
    GPIO.output(LCD_D6, True)
  if bits&0x08==0x08:
    GPIO.output(LCD_D7, True)

  # Toggle 'Enable' pin
  time.sleep(E_DELAY)    
  GPIO.output(LCD_E, True)  
  time.sleep(E_PULSE)
  GPIO.output(LCD_E, False)  
  time.sleep(E_DELAY)   

if __name__ == '__main__':
  main()

@psycopy

J'ai essayé ton code (merci !!!) : ça a pris du temps car le passage au Raspberry occassionne des bizarreries (je dois refaire les espaces etc...). Bref une fois éliminées les erreurs que je comprends voici ce qu'il me dit et là, j'avoue mon incompétence

pi@raspberrypi ~/Desktop $ sudo python test7.py
Traceback (most recent call last):
  File "test7.py", line 68, in <module>
    write("v0.1", 3, 4)
  File "test7.py", line 48, in write
    align = (str.ljust, str.center, str.rjust)[align-1]
IndexError: tuple index out of range

Et bien c'est parce que tu as mal recopié ma fonction. Dans la mienne, j'ai mis lcd_line en minuscule et non en majuscule (ligne 85 de ton code). Et n'oublie pas de corriger la mauvaise indentation (voir la modification de mon 1er message)

Oups, j'ai inversé les arguments.

# Test
if __name__ == "__main__":
    init()
    write("v0.1", 4, 3)
    text = "Welcome !"
    for i in range(len(text)):
        time.sleep(0.5)
        write(text[:i+1], 2, 2)
    for n in range(5, 0, -1):
        write(str(n), 3, 2)
        time.sleep(5)
    clear(2)
    write('Bye, bye...', 1)
    time.sleep(3)
    quit()

@ olygrim

Merci beaucoup en effet ça marche (et désolé d'avoir mal recopié ton code !)... Mais à peine avais-je sauté de joie qu'un détail apparut

Ma mauvaise manière de faire permettait de gerer différemments les temps alors que ton code permet certes de tourner en boucle mais je n'obtiens pas le même effet. Je m'explique

En gros voici ce que j'avais

1/ affichage typewriter_like

PREMIER

DEUXIEME

TROISIEME

QUATRIEME

Ces 4 lignes restent un temps (ligne 116 de mon tout premier post)

2/ Tout s'efface

3/ Typewriting_like à nouveau (mots différents mais c'est la même chose)

CINQUIEME

SIXIEME

SEPTIEME

HUITIEME

4/ Pause etc....

Tu crois qu'on peut trouver une solution avant que vous en ayiez assez du braconneur et de ses lapins ?

-
Edité par NicolasLunard 13 novembre 2014 à 21:51:05

@psycopy : je regarde

@ psycopy

Sauf erreur de ma part, voici ce que me renvoie le terminal

pi@raspberrypi ~/Desktop $ sudo python test7.py
Traceback (most recent call last):
  File "test7.py", line 68, in <module>
    write("v0.1", 4, 3)
  File "test7.py", line 51, in write
    _send_byte(byte, LCD_CHR)
  File "test7.py", line 41, in _send_byte
    GPIO.output(pin, byte&mask==mask)
TypeError: unsupported operand type(s) for &: 'str' and 'int'

Tu ajoute ce que tu veux dans la boucle while. Et pour l'occasion, on modifie le bout de code:

#Puisque beaucoup de redondances, on crée une fonction:
def affichage(texte, ecran=lcds):
    for mot, lcd in zip(texte, ecran):
        typewriter_like(mot, lcd)

    time.sleep(10)
    for lcd in ecran:
        lcd_byte(lcd, LCD_CMD)
        lcd_string("",2)

    time.sleep(4)


#Les variables sur lesquelles on va boucler
mots = (("EXEMPLE", "EXEMPLES", "EXEMPLESS", "EXEMPLESSS"),
        ("Un", "Deux", "Trois", "Allons au bois"),
        ("Quatre", "Cinq", "Six", "Cueillir des cer"))
lcds = (0x80, 0xC0, 0x94, 0xD4)


#La boucle
while True:
    for mot in mots:
        affichage(mot)

-
Edité par Olygrim 13 novembre 2014 à 23:56:07

Merci beaucoup de ton aide

Ce nouveau code est d'une belle concision je trouve, j'ai essayé de le tester pour voir s'il permettait d'afficher les phrases, de les laisser (time.sleep(10)), d'en remettre d'autre et ainsi de suite jusqu'à la fin des temps.

Helas, la console me dit

pi@raspberrypi ~/Desktop $ sudo python test5b.py
Traceback (most recent call last):
  File "test5b.py", line 185, in <module>
    main()
  File "test5b.py", line 83, in main
    def affichage(texte, ecran=lcds):
UnboundLocalError: local variable 'lcds' referenced before assignment

Ok, c'est normal. J'ai mis la variable lcds en valeur par défaut dans la fonction, mais elle n'est créée qu'après. D'où l'erreur. Donc on va simplement faire 2 petites modifications (à la ligne 2 et à la ligne 24), et également 2 modifications pour la clarté (ligne 3 et 4):

#Puisque beaucoup de redondances, on crée une fonction:
def affichage(texte, ecran):
    for txt, lcd in zip(texte, ecran):
        typewriter_like(txt, lcd)
 
    time.sleep(10)
    for lcd in ecran:
        lcd_byte(lcd, LCD_CMD)
        lcd_string("",2)
 
    time.sleep(4)
 
 
#Les variables sur lesquelles on va boucler
mots = (("EXEMPLE", "EXEMPLES", "EXEMPLESS", "EXEMPLESSS"),
        ("Un", "Deux", "Trois", "Allons au bois"),
        ("Quatre", "Cinq", "Six", "Cueillir des cer"))
lcds = (0x80, 0xC0, 0x94, 0xD4)
 
 
#La boucle
while True:
    for mot in mots:
        affichage(mot, lcds)

-
Edité par Olygrim 14 novembre 2014 à 10:39:34

Merci encore et toujours pour ta patience

Mais la console est vilaine fille

pi@raspberrypi ~/Desktop $ sudo python test5b.py
Traceback (most recent call last):
  File "test5b.py", line 185, in <module>
    main()
  File "test5b.py", line 103, in main
    affichage(mot, lcds)
  File "test5b.py", line 85, in affichage
    typewriter_like(txt, lcd)
NameError: global name 'typewriter_like' is not defined

typewriter_like() c'est la fonction qu'on a définit en premier. Il faut pas la retirer. Il faut la mettre juste avant ce bout de code.

Dans un premier temps, c'est raisonnable de penser le code en termes de bits à envoyer sur telle ou telle broche, pour vérifier que ça fonctionne et qu'on arrive bien à afficher un message là où on veut.

Mais ça c'est l'exploration des possibilités du matos. Dans un second temps, la problèmatique est différente, c'est de se demander comment on va employer le machin. Donc une approche de plus haut niveau.

On y gagnerait, je pense, à prendre le problème par le haut, et se demander comment on va arriver à s'en servir commodément, sans avoir à s'occuper des détails affreux (ci-dessus).

Un moyen c'est de faire une classe qui s'occupe du truc, et de ce dire que ce qu'on voudrait, c'est écrire des trucs du genre

a = Afficheur(4,12)
a.changerLigne(0,"hello")
a.changerLigne(1,"world")
a.changerLigne(3," /\\0o/\\")
for i in range(20):
    a.afficher()
    a.decaler()
    time.sleep(1)

et que ça produirait des affichages comme

+------------+
|hello       |
|world       |
|            |
| /\0o/\     |
+------------+

+------------+
|ello       h|
|orld       w|
|            |
|/\0o/\      |
+------------+

+------------+
|llo       he|
|rld       wo|
|            |
|\0o/\      /|
+------------+

Ici c'est une simulation (pas d'afficheur sous la main), qui est programmée comme suit. En vrai, c'est là dedans qu'on s'occupe des GPIO machin trucs, et pas ailleurs.

import time

class Afficheur:
    def __init__(self, nbLignes, nbColonnes):
        self.nbLignes = nbLignes
        self.nbColonnes = nbColonnes
        self.lignes = nbLignes*[nbColonnes * ' ' ];
        self.decalage = 0
        
    def decaler(self):
        self.decalage = (self.decalage+1) % self.nbColonnes
        
    def afficher(self):
        trait = "+%s+" % (self.nbColonnes * "-")
        print (trait)
        for ligne in self.lignes:
            print ( "|%s%s|" %
                    (ligne[self.decalage:],
                     ligne[0:self.decalage]))
        print (trait)

    def changerLigne(self, numeroLigne, texte):
        t = texte[0:self.nbColonnes]  # elim. excedent
        self.lignes[numeroLigne] = t + (self.nbColonnes - len(t))*" "

@olygrim

Et pour lui claquer le bec quand il me dit

global name 'affichage' is not defined

je fais quoi ?

@ Michelbillaud : Merci également. Un braconneur aime courir deux lièvres à la fois... Je vais essayer et je vous dis

-
Edité par NicolasLunard 14 novembre 2014 à 11:53:52

Olygrim a écrit:

typewriter_like() c'est la fonction qu'on a définit en premier. Il faut pas la retirer. Il faut la mettre juste avant ce bout de code.

@Nico: J'utilise Python 3, c'est pour ça que mon code ne fonctionne pas chez toi.

Aussi, je suis parfaitement d'accord avec Michel, mais malgré cela je pense que tu n'as vraiment pas le niveau nécessaire en Python pour jouer avec ton LCD. Il faut que tu suives un tutoriel pour apprendre les bases du langage. Les forums ne sont pas adaptés pour ce genre d'enseignement. Ici, on ne peut qu'éclaircir point par point des détails, des algorithmes ou des idées. Mais te donner un cours d'initiation à la programmation ici serait une perte de temps, pour toi, comme pour nous. Alors puisqu'il existe déjà un cours, tu devrais le suivre.

-
Edité par Anonyme 14 novembre 2014 à 12:38:25

Il faut un peu d'apprentissage pour ne plus reculer devant l'idée d'utiliser des trucs qu'on ne connait pas bien (c'est normal quand on apprend), mais ça en faut le cout(p). Par exemple

for pin in [ LCD_E, LCD_RS, LCD_D4, LCD_D5, LCD_D6, LCD_D7, LCD_ON]:
    GPIO.setup(pin, GPIO_OUT)

// ou 
  for x in [0x33, 0x32, 0x28, ......]:
     lcd_byte(x, LCD_CMD)

c'est plus facile à écrire et relire que de tonnes de copier-coller d'instructions faisant à peu près la même chose

EDIT : mais bien évidemment, ce que je dis s'adresse plutot aux auteurs de exemples qui postent leur truc sur Internet (celui-ci venait de http://www.raspberrypi-spy.co.uk/2012/07/16x2-lcd-module-control-using-python/ )
Il y a apparemment une tradition chez les électroniciens de programmer comme des pieds, en ignorant absolument tout ce qui peut être un critère de bonne programmation  :-)

-
Edité par michelbillaud 14 novembre 2014 à 16:19:04