Adds a new handling for reconnects.

measurement_main.py

 TIMEOUT_OFFSET = 10.0
 WAIT_AFTER_IPERF = 5.0
 
+modem_serial_obj = None
+gps_serial_obj = None
+
 
 class ProcessHandler:
     def __init__(self):
         return
 
 
+def start_serial_monitoring(serial, baudrate, folder, prefix):
+    global modem_serial_obj
+
+    print_message("Opening serial port for {}".format(serial))
+    modem_serial_obj = serial.Serial(
+        port=serial,
+        baudrate=baudrate,
+    )
+    modem_serial_obj.isOpen()
+    ser_filepath = "{}{}_serial_monitor_output.txt".format(
+        folder, prefix
+    )
+    ser_thread = Thread(
+        target=monitor_serial,
+        args=(
+            modem_serial_obj,
+            ser_filepath,
+        ),
+    )
+    ser_thread.start()
+
+
+def is_serial_monitoring_running():
+    return modem_serial_obj.is_open
+
+
+def start_gps_monitoring(gps, baudrate, folder, prefix):
+    global gps_serial_obj
+
+    print_message("Opening GPS serial port for {}".format(gps))
+    gps_serial_obj = serial.Serial(
+        gps,
+        baudrate=baudrate,
+    )
+    gps_ser_filepath = "{}{}_gps.nmea".format(
+        folder, prefix
+    )
+    gps_ser_thread = Thread(
+        target=monitor_gps,
+        args=(
+            gps_serial_obj,
+            gps_ser_filepath,
+        ),
+    )
+    gps_ser_thread.start()
+
+
 def monitor_gps(ser, output_file):
     ser.flushInput()
     ser.flushOutput()
     print_message("...done")
 
 
-def reconnect_modem(provider="telekom"):
+def reconnect_modem(provider="telekom", hard=False):
+    global modem_serial_obj
     print_message("Reonnect modem with provider {} ...".format(provider))
-    os.system("/root/connect-modem.py -s")
-    sleep(5)
-    os.system("/root/connect-modem.py -l {}".format(provider))
+    if hard:
+        if modem_serial_obj.is_open:
+            modem_serial_obj.write(b'at+COPS?\r\n')
+            sleep(NR_SERIAL_RESPOND_TIME)
+            modem_serial_obj.write(b'AT+QENG="servingcell"\r\n')
+            sleep(NR_SERIAL_RESPOND_TIME)
+    else:
+        os.system("/root/connect-modem.py -s")
+        sleep(5)
+        os.system("/root/connect-modem.py -l {}".format(provider))
     print_message("...done")
 
 
         sleep(1)
         print_message("Start measurement")
 
-        ser = None
-
         if self.config["serial"] is not None:
-            print_message("Opening serial port for {}".format(self.config["serial"]))
-            ser = serial.Serial(
-                port=self.config["serial"],
-                baudrate=self.config["baudrate"],
-            )
-            ser.isOpen()
-            ser_filepath = "{}{}_serial_monitor_output.txt".format(
-                self.config["folder"], self.config["prefix"]
-            )
-            ser_thread = Thread(
-                target=monitor_serial,
-                args=(
-                    ser,
-                    ser_filepath,
-                ),
-            )
-            ser_thread.start()
-
-        gps_ser = None
+            start_serial_monitoring(self.config["serial"], self.config["baudrate"], self.config["folder"], self.config["prefix"])
 
         if self.config["gps"] is not None:
-            print_message("Opening GPS serial port for {}".format(self.config["gps"]))
-            gps_ser = serial.Serial(
-                self.config["gps"],
-                baudrate=self.config["gps_baudrate"],
-            )
-            gps_ser_filepath = "{}{}_gps.nmea".format(
-                self.config["folder"], self.config["prefix"]
-            )
-            gps_ser_thread = Thread(
-                target=monitor_gps,
-                args=(
-                    gps_ser,
-                    gps_ser_filepath,
-                ),
-            )
-            gps_ser_thread.start()
+            start_gps_monitoring(self.config["gps"], self.config["gps_baudrate"], self.config["folder"], self.config["prefix"])
 
         if self.config["bandwidth"]:
             self.bandwidth()
         elif self.config["ping"]:
             self.ping()
 
-        if ser is not None:
+        if modem_serial_obj is not None:
             print_message("Closing serial port...")
-            ser.close()
+            modem_serial_obj.close()
             sleep(2)
             print_message("done...")
-        if gps_ser is not None:
+        if gps_serial_obj is not None:
             print_message("Closing GPS serial port...")
-            gps_ser.close()
+            gps_serial_obj.close()
             sleep(2)
             print_message("done...")
 
             ws_filter = "{} and port {}".format("tcp", self.config["port"])
             print_message("Use ws filter: {}".format(ws_filter))
             for n in range(1, self.config["number_of_measurements"] + 1):
+                reconnect_count = 0
                 if not is_modem_connected():
                     background_write_to_file(
                         filepath="{}{}_reconnect.log".format(
                         content='{}"'.format(datetime.timestamp(datetime.now())),
                     )
                     reconnect_modem()
+                    sleep(2)
+                    if not is_serial_monitoring_running():
+                        start_serial_monitoring()
                 print_message(
                     "{} of {}".format(n, self.config["number_of_measurements"])
                 )
                             ),
                             content='{}"'.format(datetime.timestamp(datetime.now())),
                         )
-                        reconnect_modem()
+                        reconnect_modem(hard=reconnect_count > 5)
+                        reconnect_count += 1
+                        sleep(2)
+                        if not is_serial_monitoring_running():
+                            start_serial_monitoring()
                     try:
                         try:
                             iperf_return = subprocess.call(
                 enable_tcp_probe()
                 print_message("tcp probe is now enabled")
             for n in range(1, self.config["number_of_measurements"] + 1):
+                reconnect_count = 0
                 if not is_modem_connected():
                     background_write_to_file(
                         filepath="{}{}_reconnect.log".format(
                         content='{}"'.format(datetime.timestamp(datetime.now())),
                     )
                     reconnect_modem()
+                    sleep(2)
+                    if not is_serial_monitoring_running():
+                        start_serial_monitoring()
                 print_message(
                     "{} of {}".format(n, self.config["number_of_measurements"])
                 )
                             ),
                             content='{}"'.format(datetime.timestamp(datetime.now())),
                         )
-                        reconnect_modem()
+                        reconnect_modem(hard=reconnect_count > 5)
+                        reconnect_count += 1
+                        sleep(2)
+                        if not is_serial_monitoring_running():
+                            start_serial_monitoring()
                     try:
                         try:
                             iperf_return = subprocess.call(