-         

Ergebnis 1 bis 6 von 6

Thema: Frage zu Python

  1. #1
    Erfahrener Benutzer Roboter Genie Avatar von pinsel120866
    Registriert seit
    18.12.2007
    Ort
    Hohenems
    Alter
    51
    Beiträge
    847

    Frage zu Python

    Anzeige

    Hallo,

    ich habe ein 16x1 Zeichen LCD an mein RPi angehängt und mit folgendem Code von der Adafruit HP funktioniert es auch:
    Code:
    #!/usr/bin/python
    
    from Adafruit_CharLCD import Adafruit_CharLCD
    from subprocess import * 
    from time import sleep, strftime
    from datetime import datetime
    
    lcd = Adafruit_CharLCD()
    
    cmd = "ip addr show wlan0 | grep inet | awk '{print $2}' | cut -d/ -f1"
    
    lcd.begin(16,1)
    
    def run_cmd(cmd):
            p = Popen(cmd, shell=True, stdout=PIPE)
            output = p.communicate()[0]
            return output
    
    while 1:
        lcd.clear()
        ipaddr = run_cmd(cmd)
            lcd.message(datetime.now().strftime('%b %d\n'))
            lcd.message(datetime.now().strftime('%H:%M:%S\n'))
    #    lcd.message(datetime.now().strftime('%b %d  %H:%M:%S\n'))
    #    lcd.message('IP %s' % ( ipaddr ) )
        sleep(1)
    Nun will ich die Messwerte des Ultraschallmodules auf dem LCD ausgeben und folgenden Code in den obigen integrieren:
    Code:
    import time
    import RPi.GPIO as GPIO
    
    GPIO.setmode(GPIO.BCM)
    GPIO.setwarnings(False)
    
    GPIO_TRIGGER = 14
    GPIO_ECHO = 15
    
    adjustment = 7
    
    print "Ultraschallmessung mit SRF04"
    
    while True:
    
        GPIO.setup(GPIO_TRIGGER,GPIO.OUT)
        GPIO.setup(GPIO_ECHO,GPIO.IN)
    
        GPIO.output(GPIO_TRIGGER, False)
    
        time.sleep(0.5)
    
        GPIO.output(GPIO_TRIGGER, True)
        time.sleep(0.00001)
        start = time.time()
        GPIO.output(GPIO_TRIGGER, False)
    
        while GPIO.input(GPIO_ECHO)==0:
          pass
    
        start = time.time()
    
        while GPIO.input(GPIO_ECHO)==1:
          pass
    
        stop = time.time()
    
        elapsed = stop-start
        
        distance = elapsed * 17000 + 8
        distance = distance - adjustment
    
        print "Abstand: %.1f cm" % distance
        time.sleep(1)
    
        GPIO.cleanup()
    Nur ist das nicht so einfach, zumindest bringe ich es nicht hin - könnte mir bitte hierbei jemand helfen, oder geht das gar nicht?

  2. #2
    Moderator Robotik Einstein Avatar von Kampi
    Registriert seit
    21.11.2009
    Ort
    Monheim, Nordrhein-Westfalen, Germany
    Alter
    27
    Beiträge
    3.517
    Blog-Einträge
    9
    Hey,

    du kannst zwei Programme miteinander verknüpfen.
    Unter C geht das z.B. mit dem Befehl "system()". Dadurch kannst du in deinem C-Programm quasi einen Kommandozeilenbefehl ausführen.
    Jetzt weiß ich nicht wie du was auf dem LCD anzeigen kannst, aber wenn das mittels Konsoleneingabe funktioniert kannst du es in dein Pythonprogramm mittels System machen:

    http://www.python-kurs.eu/os_modul_shell.php
    Schaut ruhig mal auf meiner Homepage vorbei :
    http://kampis-elektroecke.de

    Oder folge mir auf Google+:
    Daniel Kampert

    Es gibt 10 Arten von Menschen. Die einen können Binär, die anderen nicht.

    Gruß
    Daniel

  3. #3
    Erfahrener Benutzer Roboter Genie Avatar von pinsel120866
    Registriert seit
    18.12.2007
    Ort
    Hohenems
    Alter
    51
    Beiträge
    847
    hi kampi,

    als programmierpflaume habe ich so meine probleme. kannst du mir bei meinem beispiel helfen? ich will zuerst die messung durchführen und dann am lcd ausgeben.

  4. #4
    Moderator Robotik Einstein Avatar von Kampi
    Registriert seit
    21.11.2009
    Ort
    Monheim, Nordrhein-Westfalen, Germany
    Alter
    27
    Beiträge
    3.517
    Blog-Einträge
    9
    Hey,

    wie funktioniert den das mit der LCD-Ausgabe?
    Ich hab damit noch nicht gearbeitet.
    Wie kriegst du Daten oder Texte auf dem LCD angezeigt?
    Schaut ruhig mal auf meiner Homepage vorbei :
    http://kampis-elektroecke.de

    Oder folge mir auf Google+:
    Daniel Kampert

    Es gibt 10 Arten von Menschen. Die einen können Binär, die anderen nicht.

    Gruß
    Daniel

  5. #5
    Erfahrener Benutzer Roboter Genie Avatar von pinsel120866
    Registriert seit
    18.12.2007
    Ort
    Hohenems
    Alter
    51
    Beiträge
    847
    Das ist ein guter Hinweis, die LCD-Ausgabe ist eine "normale" Python-Datei. Ich werde mir das in den nächsten Tagen ansehen und mich dann nochmals melden.

    Danke vorerst.

  6. #6
    Erfahrener Benutzer Roboter Genie Avatar von pinsel120866
    Registriert seit
    18.12.2007
    Ort
    Hohenems
    Alter
    51
    Beiträge
    847
    Ich habe es nun gelöst, die Werte werden am LCD ausgegeben:

    Code:
    #!/usr/bin/python
    
    #
    # based on code from lrvick and LiquidCrystal
    # lrvic - https://github.com/lrvick/raspi-hd44780/blob/master/hd44780.py
    # LiquidCrystal - https://github.com/arduino/Arduino/blob/master/libraries/LiquidCrystal/LiquidCrystal.cpp
    #
    
    from time import sleep
    
    class Adafruit_CharLCD:
    
        # commands
        LCD_CLEARDISPLAY         = 0x01
        LCD_RETURNHOME         = 0x02
        LCD_ENTRYMODESET         = 0x04
        LCD_DISPLAYCONTROL         = 0x08
        LCD_CURSORSHIFT         = 0x10
        LCD_FUNCTIONSET         = 0x20
        LCD_SETCGRAMADDR         = 0x40
        LCD_SETDDRAMADDR         = 0x80
    
        # flags for display entry mode
        LCD_ENTRYRIGHT         = 0x00
        LCD_ENTRYLEFT         = 0x02
        LCD_ENTRYSHIFTINCREMENT     = 0x01
        LCD_ENTRYSHIFTDECREMENT     = 0x00
    
        # flags for display on/off control
        LCD_DISPLAYON         = 0x04
        LCD_DISPLAYOFF         = 0x00
        LCD_CURSORON         = 0x02
        LCD_CURSOROFF         = 0x00
        LCD_BLINKON         = 0x01
        LCD_BLINKOFF         = 0x00
    
        # flags for display/cursor shift
        LCD_DISPLAYMOVE         = 0x08
        LCD_CURSORMOVE         = 0x00
    
        # flags for display/cursor shift
        LCD_DISPLAYMOVE         = 0x08
        LCD_CURSORMOVE         = 0x00
        LCD_MOVERIGHT         = 0x04
        LCD_MOVELEFT         = 0x00
    
        # flags for function set
        LCD_8BITMODE         = 0x10
        LCD_4BITMODE         = 0x00
        LCD_2LINE             = 0x08
        LCD_1LINE             = 0x00
        LCD_5x10DOTS         = 0x04
        LCD_5x8DOTS         = 0x00
    
        def __init__(self, pin_rs=25, pin_e=24, pins_db=[23, 17, 21, 22], GPIO = None):
        # Emulate the old behavior of using RPi.GPIO if we haven't been given
        # an explicit GPIO interface to use
        if not GPIO:
            import RPi.GPIO as GPIO
           self.GPIO = GPIO
            self.pin_rs = pin_rs
            self.pin_e = pin_e
            self.pins_db = pins_db
    
            self.GPIO.setmode(GPIO.BCM)
            self.GPIO.setup(self.pin_e, GPIO.OUT)
            self.GPIO.setup(self.pin_rs, GPIO.OUT)
    
            for pin in self.pins_db:
                self.GPIO.setup(pin, GPIO.OUT)
    
        self.write4bits(0x33) # initialization
        self.write4bits(0x32) # initialization
        self.write4bits(0x28) # 2 line 5x7 matrix
        self.write4bits(0x0C) # turn cursor off 0x0E to enable cursor
        self.write4bits(0x06) # shift cursor right
    
        self.displaycontrol = self.LCD_DISPLAYON | self.LCD_CURSOROFF | self.LCD_BLINKOFF
    
        self.displayfunction = self.LCD_4BITMODE | self.LCD_1LINE | self.LCD_5x8DOTS
        self.displayfunction |= self.LCD_2LINE
    
        """ Initialize to default text direction (for romance languages) """
        self.displaymode =  self.LCD_ENTRYLEFT | self.LCD_ENTRYSHIFTDECREMENT
        self.write4bits(self.LCD_ENTRYMODESET | self.displaymode) #  set the entry mode
    
            self.clear()
    
    
        def begin(self, cols, lines):
    
        if (lines > 1):
            self.numlines = lines
                self.displayfunction |= self.LCD_2LINE
            self.currline = 0
    
    
        def home(self):
    
        self.write4bits(self.LCD_RETURNHOME) # set cursor position to zero
        self.delayMicroseconds(3000) # this command takes a long time!
        
    
        def clear(self):
    
        self.write4bits(self.LCD_CLEARDISPLAY) # command to clear display
        self.delayMicroseconds(3000)    # 3000 microsecond sleep, clearing the display takes a long time
    
    
        def setCursor(self, col, row):
    
        self.row_offsets = [ 0x00, 0x40, 0x14, 0x54 ]
    
        if ( row > self.numlines ): 
            row = self.numlines - 1 # we count rows starting w/0
    
        self.write4bits(self.LCD_SETDDRAMADDR | (col + self.row_offsets[row]))
    
    
        def noDisplay(self): 
        """ Turn the display off (quickly) """
    
        self.displaycontrol &= ~self.LCD_DISPLAYON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
    
    
        def display(self):
        """ Turn the display on (quickly) """
    
        self.displaycontrol |= self.LCD_DISPLAYON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
    
    
        def noCursor(self):
        """ Turns the underline cursor on/off """
    
        self.displaycontrol &= ~self.LCD_CURSORON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
    
    
        def cursor(self):
        """ Cursor On """
    
        self.displaycontrol |= self.LCD_CURSORON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
    
    
        def noBlink(self):
        """ Turn on and off the blinking cursor """
    
        self.displaycontrol &= ~self.LCD_BLINKON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
    
    
        def noBlink(self):
        """ Turn on and off the blinking cursor """
    
        self.displaycontrol &= ~self.LCD_BLINKON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
    
    
        def DisplayLeft(self):
        """ These commands scroll the display without changing the RAM """
    
        self.write4bits(self.LCD_CURSORSHIFT | self.LCD_DISPLAYMOVE | self.LCD_MOVELEFT)
    
    
        def scrollDisplayRight(self):
        """ These commands scroll the display without changing the RAM """
    
        self.write4bits(self.LCD_CURSORSHIFT | self.LCD_DISPLAYMOVE | self.LCD_MOVERIGHT);
    
    
        def leftToRight(self):
        """ This is for text that flows Left to Right """
    
        self.displaymode |= self.LCD_ENTRYLEFT
        self.write4bits(self.LCD_ENTRYMODESET | self.displaymode);
    
    
        def rightToLeft(self):
        """ This is for text that flows Right to Left """
        self.displaymode &= ~self.LCD_ENTRYLEFT
        self.write4bits(self.LCD_ENTRYMODESET | self.displaymode)
    
    
        def autoscroll(self):
        """ This will 'right justify' text from the cursor """
    
        self.displaymode |= self.LCD_ENTRYSHIFTINCREMENT
        self.write4bits(self.LCD_ENTRYMODESET | self.displaymode)
    
    
        def noAutoscroll(self): 
        """ This will 'left justify' text from the cursor """
    
        self.displaymode &= ~self.LCD_ENTRYSHIFTINCREMENT
        self.write4bits(self.LCD_ENTRYMODESET | self.displaymode)
    
    
        def write4bits(self, bits, char_mode=False):
            """ Send command to LCD """
    
        self.delayMicroseconds(1000) # 1000 microsecond sleep
    
            bits=bin(bits)[2:].zfill(8)
    
            self.GPIO.output(self.pin_rs, char_mode)
    
            for pin in self.pins_db:
                self.GPIO.output(pin, False)
    
            for i in range(4):
                if bits[i] == "1":
                    self.GPIO.output(self.pins_db[::-1][i], True)
    
        self.pulseEnable()
    
            for pin in self.pins_db:
                self.GPIO.output(pin, False)
    
            for i in range(4,8):
                if bits[i] == "1":
                    self.GPIO.output(self.pins_db[::-1][i-4], True)
    
        self.pulseEnable()
    
    
        def delayMicroseconds(self, microseconds):
        seconds = microseconds / float(1000000)    # divide microseconds by 1 million for seconds
        sleep(seconds)
    
    
        def pulseEnable(self):
        self.GPIO.output(self.pin_e, False)
        self.delayMicroseconds(1)        # 1 microsecond pause - enable pulse must be > 450ns 
        self.GPIO.output(self.pin_e, True)
        self.delayMicroseconds(1)        # 1 microsecond pause - enable pulse must be > 450ns 
        self.GPIO.output(self.pin_e, False)
        self.delayMicroseconds(1)        # commands need > 37us to settle
    
    
        def message(self, text):
            """ Send string to LCD. Newline wraps to second line"""
    
            for char in text:
                if char == '\n':
                    self.write4bits(0xC0) # next line
                else:
                    self.write4bits(ord(char),True)
    
    
    if __name__ == '__main__':
    
        lcd = Adafruit_CharLCD()
    
    GPIO_TRIGGER = 14
    GPIO_ECHO = 15
    
    adjustment = 7
    
    print "Ultraschallmessung mit SRF04"
    
    while True:
    
        GPIO.setup(GPIO_TRIGGER,GPIO.OUT)
        GPIO.setup(GPIO_ECHO,GPIO.IN)
    
        GPIO.output(GPIO_TRIGGER, False)
    
        time.sleep(0.5)
    
        GPIO.output(GPIO_TRIGGER, True)
        time.sleep(0.00001)
        start = time.time()
        GPIO.output(GPIO_TRIGGER, False)
    
        while GPIO.input(GPIO_ECHO)==0:
          pass
    
        start = time.time()
    
        while GPIO.input(GPIO_ECHO)==1:
          pass
    
        stop = time.time()
    
        elapsed = stop-start
        
        distance = elapsed * 17000 + 8
        distance = distance - adjustment
    
        print "Abstand: %.1f cm" % distance
        time.sleep(1)
    
        GPIO.cleanup()
    
    
    
        lcd.clear()
    #    lcd.message("  Adafruit 16x2\n  Standard LCD")
        lcd.message("Pinsel's\n RPi Bot")

Ähnliche Themen

  1. [ERLEDIGT] Python Email versand
    Von DanielSan im Forum Raspberry Pi
    Antworten: 17
    Letzter Beitrag: 23.11.2012, 15:27
  2. Suche Serviceleistung Python-Programmierung für Raspberry Pi
    Von Raspy im Forum Jobs/Hilfen/Stellen - Gesuche und Angebote
    Antworten: 0
    Letzter Beitrag: 01.09.2012, 10:23
  3. AVR und Python/PyMite
    Von KlausK51 im Forum Bauanleitungen, Schaltungen & Software nach RoboterNetz-Standard
    Antworten: 9
    Letzter Beitrag: 26.02.2010, 13:39
  4. Programmierung. Auch mit Python ?
    Von blenderkid im Forum Robby RP6
    Antworten: 3
    Letzter Beitrag: 27.11.2007, 15:05
  5. Asuro mit Python
    Von BeeWee im Forum Asuro
    Antworten: 3
    Letzter Beitrag: 12.07.2007, 22:54

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •