Internet Speedtest

Sockets, TCP/IP, (XML-)RPC und ähnliche Themen gehören in dieses Forum
BlackJack

@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

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

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

Was mache ich denn falsch?
BlackJack

@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

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

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

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