def power(serial):
try:
serial_request(serial, "\r\nPwrOn", RESPONSE_END, timeout=IMM_COMMAND_TIMEOUT)
yield
finally:
serial_request(serial, "\r\nPwrOff", RESPONSE_END, timeout=IMM_COMMAND_TIMEOUT)
sleep(IMM_SHUTDOWN_WAIT)
def force_capture_line(serial):
try:
serial_request(
serial, "ForceCaptureLine", RESPONSE_END, timeout=IMM_COMMAND_TIMEOUT
)
yield
finally:
serial_request(serial, "ReleaseLine", RESPONSE_END, timeout=IMM_COMMAND_TIMEOUT)
def stop(device_ids):
with imm_components():
with active_line() as serial:
for device_id in device_ids:
expected_response = "logging stopped.*" + REMOTE_RESPONSE_END
serial_request(serial,
"#{0}Stop".format(device_id),
expected_response,
timeout=10)
def set_interval(device_ids, interval):
with imm_components():
with active_line() as serial:
for device_id in device_ids:
serial_request(
serial,
"#{0}SampleInterval={1}".format(device_id, interval),
REMOTE_RESPONSE_END,
timeout=10,
)
def ping(serial):
expected = re.escape("OK\r\n")
try:
logger.debug("Pinging iridium")
serial_request(serial, "AT", expected, timeout=IRD_DEFAULT_TIMEOUT)
except Exception:
logger.error("Ping failed")
raise Exception("Iridium did not respond correctly to ping")
else:
logger.debug("Iridium ping ok")
def query_samples(serial, device_id, n=SEABIRD_RECENT_SAMPLES):
raw = serial_request(serial,
"#{0}DN{1}".format(device_id, n),
REMOTE_RESPONSE_END,
timeout=10)
return raw
def _get_status(serial, device_id):
raw = serial_request(serial,
"#{0}GetSD".format(device_id),
REMOTE_RESPONSE_END,
timeout=10)
xml_like = re.search(
re.escape("<StatusData") + r".*" + re.escape("</StatusData>"),
raw,
flags=re.DOTALL,
).group(0)
status_data = ET.fromstring(xml_like)
status = status_data.attrib
status["datetime"] = datetime.strptime(
status_data.find("DateTime").text, "%Y-%m-%dT%H:%M:%S")
status["voltage"] = float(status_data.find("Power/vMain").text)
status["voltage_li"] = float(status_data.find("Power/vLith").text)
status["bytes"] = int(status_data.find("MemorySummary/Bytes").text)
status["samples"] = int(status_data.find("MemorySummary/Samples").text)
status["samples_free"] = int(
status_data.find("MemorySummary/SamplesFree").text)
status["samples_length"] = int(
status_data.find("MemorySummary/SampleLength").text)
status["sampling"] = status_data.find("AutonomousSampling").text
return status
def get_datetime(serial):
expected_response = r".*? [\d-]+" + re.escape("\r\n")
raw_date = serial_request(
serial, "print,/par/time/utc/date", expected_response, timeout=10
)
expected_response = r".*? [\d\.:]+" + re.escape("\r\n")
raw_time = serial_request(
serial, "print,/par/time/utc/clock", expected_response, timeout=10
)
timestamp = datetime.strptime(
raw_date.strip().split()[1] + " " + raw_time.strip().split()[1],
"%Y-%m-%d %H:%M:%S.%f",
)
return timestamp
def query_last_sample(serial, device_id):
expected_response = re.escape("</SampleData>\r\n") + REMOTE_RESPONSE_END
raw = serial_request(serial,
"!{0}SampleGetLast".format(device_id),
expected_response,
timeout=5)
return raw
def _get_sample_range(serial, device_id, begin, end):
raw = serial_request(
serial,
"#{0}DD{1},{2}".format(device_id, begin, end),
REMOTE_RESPONSE_END,
timeout=10,
)
samples = parse_samples(device_id, raw)
return samples
def clear_mo_buffer(serial):
logger.debug("Clearing MO buffer")
expected = r"(?P<status>\d)" + re.escape("\r\n")
response = serial_request(serial,
"AT+SBDD0",
re.escape("\r\n"),
timeout=IRD_DEFAULT_TIMEOUT)
status = int(re.search(expected, response).groupdict()["status"])
if status:
raise Exception("SBD clear mo command returned error status")
def send_sbd(serial, message):
clear_mo_buffer(serial)
sleep(1)
size = message_size(message)
assert size <= SBD_MAX_SIZE, "Message is too large: {0} > {1}".format(
size, SBD_MAX_SIZE)
# Initiate write text
expected = "READY\r\n"
serial_request(serial, "AT+SBDWT", expected, timeout=IRD_DEFAULT_TIMEOUT)
sleep(5)
# Submit message
expected = r"(?P<status>\d)" + re.escape("\r\n\r\n") + r"OK" + re.escape(
"\r\n")
response = serial_request(serial,
message,
expected,
timeout=SBD_WRITE_TIMEOUT)
status = int(re.search(expected, response).groupdict()["status"])
if status:
raise Exception("SBD write command returned error status")
sleep(3)
# Initiate transfer to GSS
expected = (re.escape("+SBDIX: ") + (r"(?P<mo_status>\d+), "
r"(?P<momsn>\d+), "
r"(?P<mt_status>\d+), "
r"(?P<mtmsn>\d+), "
r"(?P<mt_length>\d+), "
r"(?P<mt_queued>\d+)") +
re.escape("\r\n"))
response = serial_request(serial,
"AT+SBDIX",
expected,
timeout=SBD_TRANSMISSION_TIMEOUT)
status = int(re.search(expected, response).groupdict()["mo_status"])
if status:
raise Exception("SBD transfer command returned error status")
def check_signal(serial):
expected = re.escape("+CSQ:") + r"(?P<strength>\d)" + re.escape("\r\n")
try:
logger.debug("Checking signal")
response = serial_request(serial,
"AT+CSQ",
expected,
timeout=IRD_DEFAULT_TIMEOUT)
except Exception:
logger.error("Signal check failed")
raise Exception("Iridium did not respond correctly to signal query")
strength = int(re.search(expected, response).groupdict()["strength"])
logger.debug("Signal strength: {0}".format(strength))
return strength
def query_gga(serial):
expected_response = re.escape("$GPGGA") + ".*" + re.escape("\r\n")
raw = serial_request(serial, "out,,nmea/GGA", expected_response, timeout=10)
return raw
def send_wakeup_tone(serial):
serial_request(serial, "SendWakeUpTone", RESPONSE_END, timeout=IMM_COMMAND_TIMEOUT)
