Internet Speedtest

Sockets, TCP/IP, (XML-)RPC und ähnliche Themen gehören in dieses Forum
Sirius3
User
Beiträge: 8101
Registriert: Sonntag 21. Oktober 2012, 17:20

Montag 23. Januar 2017, 10:30

@Nr8: das mit dem Einrücken passiert hier, weil Du Tabs mit Spaces gemischt hast. Das sollte nicht sein, weil es, wie Du siehst, nur Probleme macht. Jeder vernünftige Editor bietet Dir die Möglichkeit einmalig Tabs in Spaces umzuwandeln und danach nur noch mit Spaces einzurücken, damit solche Fehler nicht passieren.

Statt irgendwelche Zeichen aus einem String rauszulöschen und zu hoffen, dass dadurch nicht der wichtige Inhalt kaputt geht, solltest Du den String parsen. Da das eine Komma-separierte Liste ist, sollte das nicht all zu schwierig sein.
Nr8
User
Beiträge: 42
Registriert: Mittwoch 21. Dezember 2016, 08:43

Dienstag 24. Januar 2017, 12:34

Gibt es python etwas wie grep?

Wenn ich also response = ser.readline() nach etwas greppen möchte???

Vielen Dank!
BlackJack

Dienstag 24. Januar 2017, 12:43

@Nr8: Den ``in``-Operator auf Zeichenketten für einfache Tests auf statische Teilzeichenketten oder das `re`-Modul für reguläre Ausdrücke.
Nr8
User
Beiträge: 42
Registriert: Mittwoch 21. Dezember 2016, 08:43

Dienstag 24. Januar 2017, 15:03

Habe den Code jetzt etwas geändert.

Leider bekomme ich noch nicht das gewünschte Ergebniss.

response="" wollte ich testen ob ich alle paar sekunden neue Werte von HCSQ bekomme und das ist leider nicht so.

Sendet ser.write("AT^HCSQ?\x0D") nicht alle paar Sekunden eine Abfrage?

Code: Alles auswählen

ser = serial.Serial()
ser.port = "/dev/ttyUSB1"
ser.baudrate = 9600
ser.bytesize = serial.EIGHTBITS 
ser.parity = serial.PARITY_NONE
ser.stopbits = serial.STOPBITS_ONE
ser.timeout = 0            
ser.xonxoff = False    
ser.rtscts = False    
ser.dsrdtr = False      
ser.writeTimeout = 2    

def doSignal():
    ser.flushInput() #flush input buffer, discarding all its contents
    ser.flushOutput()#flush output buffer, aborting current output

    
    while True:
        response = ser.readline().rstrip()
        ser.write("AT^HCSQ?\x0D")
        time.sleep(1)  #give the serial port sometime to receive the data
        for HCSQ in response:  
            signalst =  response.split(',')
            verbindung = signalst[0]

            if (verbindung == '^HCSQ:"WCDMA"'):
                rssi = int(signalst[1])-120.5
                rsrp = int(signalst[2])-120.5
                sinr = int(signalst[3])
                sinr = (0.5*sinr)-32
                rsrq = 0
                verbindung = "WCDMA"
                subprocess.call("./Verbindungsaufbau1")
  
            elif (verbindung == '^HCSQ:"LTE"'):
                rssi = int(signalst[1])-120.5
                rsrp = int(signalst[2])-140.5
                sinr = int(signalst[3])
                sinr = (0.2*sinr)-20.1
                rsrq = (int(signalst[4])*0.5)-19.75
                verbindung = "LTE"
                
            elif (verbindung == '^HCSQ:"GSM"'):
                rssi = int(signalst[1])-120.5
                rsrp = 0
                sinr = 0
                sinr = 0
                rsrq = 0
                verbindung = "GSM"
                subprocess.call("./Verbindungsaufbau1")
            
            time.sleep(2)
            datei = (format(DateTime.now(), '%H:%M:%S'),str(rssi), str(rsrp), str(sinr), str(rsrq), str(verbindung))
            print (response)
            print (";".join(datei))
            fout.write(";".join(datei)+"\n")
            #print (verbindung)
            response=""

try: 
	ser.open()

except Exception, e:
	print "error open serial port: " + str(e)
	exit()

if ser.isOpen():
	while True:
		doSignal()
		time.sleep(0.1)


Nr8
User
Beiträge: 42
Registriert: Mittwoch 21. Dezember 2016, 08:43

Dienstag 24. Januar 2017, 17:02

Mit dem bash Code geht es.

[codebox=bash file=Unbenannt.bsh]
#!/bin/bash

sudo cat /dev/ttyUSB1 | grep HCSQ &

while true
do
sudo echo "AT^HCSQ?" >/dev/ttyUSB1
sleep 2
done
[/code]
BlackJack

Dienstag 24. Januar 2017, 17:11

@Nr8: Zumindest das zweite ``sudo`` macht keinen Sinn. Und wenn man dafür die nötigen Rechte hat, dann sollte das erste ``sudo`` auch überflüssig sein.

Edit: Also (ungetestet):
[codebox=bash file=Unbenannt.bsh]#!/bin/bash
DEVICE_FILENAME='/dev/ttyUSB1'

grep 'HCSQ' "$DEVICE_FILENAME" &

while true; do
echo 'AT^HCSQ?' >"$DEVICE_FILENAME"
sleep 2
done[/code]
Nr8
User
Beiträge: 42
Registriert: Mittwoch 21. Dezember 2016, 08:43

Dienstag 24. Januar 2017, 17:30

Kannst du dir erklären warum das mit dem bash geht aber mit Python nicht?
BlackJack

Dienstag 24. Januar 2017, 17:44

@Nr8: Das geht auch in Python.
Nr8
User
Beiträge: 42
Registriert: Mittwoch 21. Dezember 2016, 08:43

Dienstag 24. Januar 2017, 19:30

Was mache ich denn falsch?
BlackJack

Dienstag 24. Januar 2017, 21:09

@Nr8: Naja, Du hast halt was anderes implementiert. Zum Beispiel sehe ich nichts was dem ``&`` im Shell-Skript entspricht, damit das auslesen und filtern parallel ausgeführt wird.
BlackJack

Dienstag 24. Januar 2017, 21:58

Nur mal so als Beispiel Dein Python-Programm als Shell-Skript, weil das irgendwie so klang als könnte man im Shell-Skript etwas machen was in Python nicht geht (ungetestet):
[codebox=bash file=Unbenannt.bsh]#!/bin/bash
SERIAL='/dev/ttyUSB1'
VERBINDUNGSAUFBAU_1='./Verbindungsaufbau1'

do_signal() {
local response
local -a signalst
local verbindung
local rssi
local datei

while true; do
read -r response
echo 'AT^HCSQ?' > "$SERIAL"
sleep 1
for (( i = 0; i < $(#response); i++ )); do # XXX Völlig unsinnig.
IFS=',' read -r -a signalst <<< "$response"
verbindung=${signalst[0]}
case "$verbindung" in
'HCSQ:"WCDMA"'*)
rssi=$(echo "${signalst[1]} - 120.5" | bc)
verbindung='WCDMA'
$VERBINDUNGSAUFBAU_1
;;
'HCSQ:"LTE"'*)
rssi=$(echo "${signalst[1]} - 120.5" | bc)
verbindung='LTE'
;;
'HCSQ:"GSM"'*)
rssi=$(echo "${signalst[1]} - 120.5" | bc)
verbindung='GSM'
$VERBINDUNGSAUFBAU_1
;;
esac

sleep 2
datei="$(date '+%H:%M:%S');$rssi"
echo "$response"
echo "$datei"
response='' # XXX Nur nötig wegen der unsinnigen ``for``-Schleife!
done

done < "$SERIAL"
}

while true; do
do_signal
sleep 0.1
done[/code]
Die Kommentare zur ``for``-Schleife gelten natürlich auch für Deine Python-Fassung. Und ich habe hier nur `rssi` berechnet um Tipparbeit zu sparen, das wäre für die anderen Variablen ähnlich.

Die ``while``-Schleife im Hauptprogramm ist auch total unnötig weil die Funktion ja bereits eine Endlosschleife enthält.
Nr8
User
Beiträge: 42
Registriert: Mittwoch 21. Dezember 2016, 08:43

Mittwoch 25. Januar 2017, 08:20

Hab es jetzt so probiert.

Code: Alles auswählen

#!/usr/bin/python

import serial, time
import sys
import subprocess 
from datetime import datetime as DateTime
#initialization and open the port

#possible timeout values:
#    1. None: wait forever, block call
#    2. 0: non-blocking mode, return immediately
#    3. x, x is bigger than 0, float allowed, timeout block call
ser = serial.Serial()
#ser.port = "/dev/ttyUSB0"
ser.port = "/dev/ttyUSB1"
#ser.port = "/dev/ttyS2"
ser.baudrate = 9600
ser.bytesize = serial.EIGHTBITS #number of bits per bytes
ser.parity = serial.PARITY_NONE #set parity check: no parity
ser.stopbits = serial.STOPBITS_ONE #number of stop bits
#ser.timeout = None          #block read
ser.timeout = 1            #non-block read
#ser.timeout = 2              #timeout block read
ser.xonxoff = False     #disable software flow control
ser.rtscts = False     #disable hardware (RTS/CTS) flow control
ser.dsrdtr = False       #disable hardware (DSR/DTR) flow control
ser.writeTimeout = 2     #timeout for write

try: 
    ser.open()
except Exception, e:
    print "error open serial port: " + str(e)
    exit()

if ser.isOpen():

    try:
        ser.flushInput() #flush input buffer, discarding all its contents
        ser.flushOutput()#flush output buffer, aborting current output 
                 #and discard all that is in buffer
        #write data
        ser.write("AT^HCSQ?\x0D")
        time.sleep(0.5) 
        numOfLines = 0
        while True:
            response = ser.readline().rstrip()
            for HCSQ in response:
                a =  response.translate(None, ':')
                a = a.translate(None, ' ')
                a = a.translate(None, '^')
                a = a.translate(None, '"')
                a = a.translate(None, "'")
                a = a.translate(None, 'HCSQ')
                a = a.translate(None, '\r\n')
                b = a.split(",")
                signalst = tuple(b)
                verbindung = signalst[0]
                            
                if (verbindung == "WDMA"):
                    rssi = int(signalst[1])-120.5
                    rsrp = int(signalst[2])-120.5
                    sinr = int(signalst[3])
                    sinr = (0.5*sinr)-32
                    rsrq = 0
                    verbindung = "WCDMA"
                    subprocess.call("./Verbindungsaufbau1")
  
                elif (verbindung == "LTE"):
                    rssi = int(signalst[1])-120.5
                    rsrp = int(signalst[2])-140.5
                    sinr = int(signalst[3])
                    sinr = (0.2*sinr)-20.1
                    rsrq = (int(signalst[4])*0.5)-19.75
                    verbindung = "LTE"
               
                elif (verbindung == "GM"):
                    rssi = int(signalst[1])-120.5
                    rsrp = 0
                    sinr = 0
                    sinr = 0
                    rsrq = 0
                    verbindung = "GSM"
                    subprocess.call("./Verbindungsaufbau1")
            

                datei = format(DateTime.now(), '%H:%M:%S'),str(rssi), str(rsrp), str(sinr), str(rsrq), str(verbindung)
                print (";".join(datei))
                fout.write(";".join(datei)+"\n")

                numOfLines = numOfLines + 2


                if (numOfLines >= 2):
                    break
                time.sleep(2)
            if (numOfLines >= 2):
                break
                time.sleep(2)
        ser.close()
    except Exception, e1:
        print "error communicating...: " + str(e1)

else:
    print "cannot open serial port "


Sollte .rstrip() nicht die Leerzeile löschen?
Hat nicht geklappt, deshalb habe ich "for HCSQ in response:" noch mit drin.

Die Sache mit dem translate klappt irgendwie am besten.
BlackJack

Mittwoch 25. Januar 2017, 10:46

Diese ``for HCSQ in response:``-Schleife ist völlig Banane. Wie oft wird die denn in welchen Fällen durchlaufen? Schleifen sind dazu da Code zumindest potentiell mehrfach zu wiederholen, sonst macht eine Schleife keinen Sinn. Also wie muss `response` aussehen (Beispielwerte und Erklärungen bitte) um diese Schleife 0 mal, 1 mal, 2 mal zu durchlaufen? Und an welchen Wert wird `HCSQ` in jedem dieser Durchläufe gebunden? Warum wird der Wert dann nirgends in der Schleife für irgend etwas verwendet?

Was meinst Du mit `rstrip()` und Leerzeile löschen? Auf eine Leerzeile angewandt ergibt das eine leere Zeichenkette, wobei Leerzeile in diesem Fall eine Zeile ist die nur „whitespace“-Zeichen enthält.

Der Test nach dem öffnen der seriellen Schnittstelle ob sie denn auch tatsächlich offen ist, macht keinen Sinn. Denn zu dem Zeitpunkt wo das getestet wird, ist die Schnittstelle natürlich offen, denn sonst wäre das `open()` direkt davor ja fehlgeschlagen.

Die `translate()`-Methode wird falsch verwendet. Der Code macht nicht das was Du denkst was er tut. Das gleiche Ergebnis könnte man mit *einem* Aufruf erreichen: ``a = response.translate(None, '\n\r "\':CHQS^')``. Und das klappt halt auch nur solange es tatsächlich klappt. Ich würde an der Stelle auf die Struktur der Daten in der Zeile eingehen statt etwas willkürlich einzelne Zeichen da rauszuschiessen. Das hat mehr was von Schrotgewehr anstelle eines passenden Werkzeugs.

Edit: Das einfache Shell-Skript mit ``grep`` als Hy-Programm (ungetestet):
[codebox=clojure file=Unbenannt.txt]#!/usr/bin/env hy
(import
[multiprocessing [Process]]
[time [sleep]]
[serial [Serial]])


(defn call-async [func &rest args]
(let [process (Process :target func :args args)]
(setv (. process daemon) True)
(.start process)
process))


(defn print-hcsq-lines [lines]
(for [line (filter (fn [s] (in "HCSQ" s)) lines)]
(print line)))


(defmain [&rest args]
(with [serial (Serial "/dev/ttyUSB1")]
(call-async print-hcsq-lines serial)
(while True
(doto serial
(.write "AT^HCSQ?\n")
(.flush))
(sleep 2))))[/code]
Das wäre also auch in Python nicht sonderlich komplex.
Antworten