Raspberry Pi - Socket-Konfiguration

[Thorsten (Gast)]

Hallo,

ich beschäftige mich grade mit meinem Raspberry Pi, indem ich mit der 
App fürs Smartphone NetIO versuche eine LED an meinen Raspberry 
anzusteuern.
das klappt auch soweit alles seht gut.

Jetzt möchte ich gernen im nächsten schritt die per App gesendeten Daten 
über UART versenden.

Doch bevor ich dieses in Angriff nehme, sitz ich jetzt schon ewig dabei, 
zu versuchen, wie man es in Python hinbekommt, dass die IP Verbindung 
zur App nicht jedesmal wieder neu aufgesetzt werden muss, indem man das 
Programm neu startet.

Irgendwie muss die Verbindung bei jedem Verbindungsabbruch zurückgesetzt 
werden.

Hat da jemand von euch schon mal was gemacht ?

Hier hab ich mal den Code von http://netio.davideickhoff.de/ 
reingepackt:

#!/usr/bin/python 

# Echo server program
import socket
import RPi.GPIO as GPIO

#####################################################################
#### SETUP IOs ######################################################
#####################################################################
# to use Raspberry Pi board pin numbers
GPIO.setmode(GPIO.BCM)
# For LED1 we use pin 4 according BCM pin count 
# (see https://projects.drogon.net/raspberry-pi/wiringpi/pins/)
LED1 = 4
# For Switch input we use pin 17 according BCM pin count
SWITCH1 = 17
# set up GPIO output channel
GPIO.setup(LED1, GPIO.OUT)

# set up GPIO input with pull-up control
#   (pull_up_down be PUD_OFF, PUD_UP or PUD_DOWN, default PUD_OFF)
GPIO.setup(SWITCH1, GPIO.IN, pull_up_down=GPIO.PUD_UP)


#####################################################################
#### SETUP SOCKET INTERFASE #########################################
#####################################################################
HOST = ''                 # Symbolic name meaning the local host
PORT = 54321              # Arbitrary non-privileged port
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, PORT))
s.listen(1)
conn, addr = s.accept()
print 'Connected by', addr
#####################################################################
#### Continous loop, that waits for new data and acts depending  ####
#### on data content on it                                       ####
#####################################################################
while 1:
    data = conn.recv(1024)
    print 'New Receive', data
    if not data: break
    print 'Received Data:', data
    if data == 'LED1 on\n':
        conn.send('on')
        GPIO.output(LED1, GPIO.HIGH)
        print 'received on'
    elif data == 'LED1 off\n':
        conn.send('off')
        GPIO.output(LED1, GPIO.LOW)
        print 'received off'
    elif data == 'get status\n':
        print 'Input Status:', GPIO.input(SWITCH1)
        if GPIO.input(SWITCH1):
           conn.send('on')  
           print 'Read GIOP 0 result On'
        else:
           conn.send('off')  
           print 'Read GIOP 0 result Off'
        # ende if
    else:
        conn.send('unknown command')
        print 'Unknown command:', data
    # continue with while 1
conn.close()

Schönen Abend noch

[Conny G. (conny_g)]

Hallo Thorsten,

das Problem ist hier, dass Dein Progrämmchen so geschrieben ist, dass es 
nur eine Verbindung annimmt:

Zu Beginn

s.bind((HOST, PORT))
s.listen(1)
conn, addr = s.accept()

d.h. Du hängst Dich an den TCP/IP Port (bind), wartest auf eine 
Verbindung (listen) und nimmst Sie an (accept).
Dann gehst Du in die Endlosschleife (while (1)) um die Daten zu 
verarbeiten.
Wenn nichts mehr kommt hast Du ein Problem:
das Programm hängt in der Endlosschleife, aber es existiert keine 
Verbindung mehr.

D.h. Du müsstest das Annehmen der Verbindung in die Schleife 
hineinnehmen und richtig auf Verbindungsabbruch/-Ende mit der Gegenseite 
reagieren (vermutlich close, evtl. nochmal listen).

D.h. Deine Schleife sähe schnell hingeschrieben in etwa so aus:

bind
listen
modus = warten auf verbindung
while (1)
  prüfen auf eingehende verbindung
  wenn eingehende verbindung
       accept
       modus = daten empfangen
  wenn modus == daten empfangen
      daten vorhanden?
          ja: daten empfangen, daten verarbeiten
          nein: nach x Zeit keine Daten: aktiv Verbindung trennen,
                 ggf verbindungsannahme neu initialisieren
                 modus = warten auf Verbindung
      verbindungsabbruch von gegenseite:
          close
          evtl. verbindungsannahme neu initialisieren
          modus = warten auf Verbindung

Evtl. muss man noch abfangen, dass man nicht mehr als 1 Verbindung 
annimmt - sonst wird's etwas komplizierter, wenn man mehrere 
Verbindungen verwalten will.

Vg,
Conny

[Conny G. (conny_g)]

Dafür müssten sich übrigens Code-Beispiele finden lassen, wie man die 
Connections beendet und wieder annimmt - jeder selbstgebaute Python 
Simple/Mini-Webserver macht das.

[Bastler (Gast)]

Klar doch:
http://fragments.turtlemeat.com/pythonwebserver.php

[Bastler (Gast)]

Sorry, sollte ja RAW sein:
http://www.binarytides.com/python-socket-server-code-example/

[Conny G. (conny_g)]

Perfekt!

[Thorsten (Gast)]

Vielen dank für die vielen und vor allem super Antworten.

Das mit den mehreren Verbindungen klappt super und ich kann mich mit 
mehreren Clienten anmelden.

Jetzt kommt mein nächstes Problem. ich habe einen Beispielcode für UART 
aus dem Netz gezogen, um einmal die Verbindung über UART zu testen.

Dazu habe ich einen Pegelwandler zwischen Raspberry und Pc geklemmt. Die 
Verbindung funktioniert auch prima und ich kann daten zum Pc schicken. 
Soabl ich aber versuche daten vom Pc zu empfangen, schmiert das Programm 
auf dem Pi immer ab.

In den Anhang habe ich mal einen Sreenshot gepackt, auf dem man in SSH 
die konsole und dann HTerm auf dem Pc sehen kann, welche Fehlermeldung 
kommt.

Woran liegt das, also das Programm wurde im Netz als funktionsfähig 
beschrieben.

 # Serial Interface Raspberry Pi <----> ATXMEGA

import serial
import time
import platform
import decimal
import binascii




print "......Start Program....."
print "OS Name = ", platform.system()
print "Time/Date = ", time.asctime()


# Some String conversions as Python lessons
# Convert decimal to string
dec = decimal.Decimal("12")
dec = dec * 3
print str(dec)


# convert hex to ASCII string --> &H41 --> "A" ....
my_string = "41424344454647"
print binascii.unhexlify(my_string)


# or


print my_string.decode("hex")


# Using a bytearray
bytes = bytearray(b"ABDCEFGHIJKLMNOPQRSTV")
# 65 decimal = "A" ASCII
print bytes[0]
print bytes[1]
 


# configure the serial port of raspberry pi (ttyAMA0)
# Make sure this port will not be used by the system like Syslog....
ser = serial.Serial(
    port="/dev/ttyAMA0",
    baudrate=9600,
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE,
    bytesize=serial.EIGHTBITS,
    #timeout=10, # timout in seconds
    xonxoff=0, # Software flow control
    rtscts=0,  # hardware (RTS/CTS) flow control
    dsrdtr=0,  # hardware (DSR/DTR) flow control
    interCharTimeout=None 
)


# Check if port is open
if ser.isOpen() == True:
    print "ttyAMA0 is open !"
else:
    print "Error open ttyAMA0"




ser.write("\x0D"+"\x0A")
output = "Hello ATXMEGA_1"+chr(13)+chr(10)  # Carriage Return solution 1
ser.write(output)
output = "Hello ATXMEGA_2"+"\x0D"+"\x0A"  # Carriage Return solution 2
ser.write(output)


ser.flushInput()    # Flush input buffer


while 1:
    time.sleep(2)   # sleep 2 seconds
    # Request the data from ATXMEGA by sending ">"
    ser.write(">")
    # Wait for data from ATXMEGA
    response =ser.readline()
    
    print "Len = ", len(response)
    print response
    


    # If we receive exit then exit the while loop
    if response == "exit"+chr(13)+chr(10):
        print "End program"
        break    
# ASCII data in Python e.g. chr(13)


# Read a "/n" terminated line# 
#response =ser.readlineeadline()


# print the received string
print "Now close ttyAMA0"
ser.close()

[Conny G. (conny_g)]

Hallo Thorsten,

also die Fehlermeldung und Fehlererscheinung sagt mir gerade nichts.
Der Code sieht bei einem schnellen Überflug auch ok aus.

Eins was mir mal Ärger gemacht hat:
beim Raspberry Pi hängt standardmässig die Console am seriellen Port, 
hast Du den auch abgehängt?

Das geht so:
- in /etc/inittab die Zeile "T0:23:respawn:/sbin/getty -L ttyAMA0 115200 
vt100" auskommentieren
- in /boot/cmdline.txt den Teil "console=ttyAMA0,115200" entfernen

Vg,
Conny

[Thorsten (Gast)]

Hallo Conny,

genau daran hat es gelegen......... Man und das hat mich etliche Stunden 
gekostet. Wo kann man sowas denn nachlesen, weil ich hab sowas nirgendwo 
gefunden.

Kann mir noch jemand sagen, ob  es für die UART Schnittstelle auch sowas 
wie eine UART Variable gibt, nach welcher man abfragen kann, ob 
überhaupt igendetwas gesendet worden ist, damit man nicht immer auf eine 
Nachricht warten muss. Sowas wie:

if (UART hat Daten empfangen = 1)
   Daten auswerten
   print (Daten)
else
   normaler Programmablauf

Ich versuch mich da immer an der C-Programmierung zu orientieren, da 
gibt es sowas ja.....

MfG

[David (Gast)]

Hallo zusammen, gibt verschiedene Möglichkeiten bzgl. des TCP Servers.
Ein gut funktionierendes Beispiel gibt es hier:

http://netio.davideickhoff.de/forum/topic/66/

Direkt Download: 
http://netio.davideickhoff.de/forum/attachment/8f9094943777bf231b6fba9b0c71731fff9ccd92/

In der handle_command Funktion kommen dann deine Anpassungen rein.

[Conny G. (conny_g)]

Hi Thorsten,

serielle Console abschalten: das hab ich auch mal irgendwo gelesen, als 
ich schon einiges an seltsamen Effekten damit hatte :-)
Hier hab ich's grad wiedergefunden:
http://www.hobbytronics.co.uk/raspberry-pi-serial-port

Du meinst einen "non-blocking call" für's Zeichen lesen von Uart in 
Python?

Das gibt's. Du kannst entweder das zeilenweise Lesen in einen eigenen 
Thread verlagern:
http://stackoverflow.com/questions/17553543/pyserial-non-blocking-read-loop

oder Du liest einzelne Zeichen und wertest aus, ob Du überhaupt etwas 
bekommen hast:

ser = serial.Serial( '/dev/ttyAMA0', 38400, bytesize=serial.EIGHTBITS, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, timeout=0, xonxoff$

def handle_data(data):
    sys.stdout.write( '%s' % data )

def read_from_port():
        while running:
           data  = ser.read()
           if data:
             handle_data(data)

thread = threading.Thread(target=read_from_port)
thread.start()

Das "timeout=0" und "if data:" ist der Trick.

http://raspberrypi.stackexchange.com/questions/9419/how-to-read-values-with-pyserial

Vg,
Conny

[lasse (Gast)]

Hallo, wie programmiere ich das ich die GPIO Pins beim Raspberry PI so 
dass ich sie über Bluetooth ansteuern kann also dann zb. über eine App. 
Hat jemand ne IDEE??

[Conny G. (conny_g)]

lasse schrieb:
> Hallo, wie programmiere ich das ich die GPIO Pins beim Raspberry PI so
> dass ich sie über Bluetooth ansteuern kann also dann zb. über eine App.
> Hat jemand ne IDEE??

Entweder Du programmierst Dir einen entsprechenden Service auf dem RPi 
und eine App oder Du recherchierst, ob das schon jemand gemacht hat.
Die Wahrscheinlichkeit ist äußerst hoch, dass das schon jemand gemacht 
hat.

Voila, erster Treffer in Google:

https://behindthesciences.com/electronics/controlling-raspberry-pi-gpios-over-bluetooth-with-an-android-app/

https://www.google.de/search?&q=switch+gpio+raspberry+pi+via+bluetooth