From c3e5ef5576bf5f0d65f42aa5077d2566bafda2aa Mon Sep 17 00:00:00 2001 From: Anthony Correa Date: Thu, 12 Nov 2015 00:00:00 -0600 Subject: [PATCH] commit 11/12/2015 --- config.ini | 8 +- data_handling_legacy.py | 154 ++++++++++++++ datahandling.py | 445 ++++++++++++++++------------------------ instruments.py | 155 ++++++-------- logging.ini | 37 ++++ main.py | 174 ++++++++-------- mission.py | 43 ++++ system.py | 2 +- test.py | 40 ++-- 9 files changed, 600 insertions(+), 458 deletions(-) create mode 100644 data_handling_legacy.py create mode 100644 logging.ini create mode 100644 mission.py diff --git a/config.ini b/config.ini index ad51c35..4e43ec8 100644 --- a/config.ini +++ b/config.ini @@ -1,9 +1,9 @@ [refresh rates] -refresh camera local = 5 -refresh camera transmit = 10 +refresh camera local = 10 +refresh camera transmit = 15 refresh barometer local = 1 -refresh barometer transmit = 5 +refresh barometer transmit = 2 refresh gps local = 2 refresh gps transmit = 5 @@ -25,7 +25,7 @@ use_lan = True url = "http://home.ascorrea.com" server_port = 5010 data_path = "upload-data" -image_path = "upload-file" +image_path = "missions" ping_path = "ping" [local storage settings] diff --git a/data_handling_legacy.py b/data_handling_legacy.py new file mode 100644 index 0000000..a51df1f --- /dev/null +++ b/data_handling_legacy.py @@ -0,0 +1,154 @@ +__author__ = 'asc' +logger + def log(self, message, message_type="text"): + if message_type == "text": + print ("%s - Log Message: %s"% (str(datetime.datetime.now()), message)) + elif message_type == "image": + image = message + if image: + filename = datetime.datetime.now().strftime("Image %Y%m%d-%H%M%S.jpg") + with open(os.path.join(self.photo_path, filename), 'wb') as f: + f.write(message) + return 'success' + elif message_type == "data": + message["sent"] = str(datetime.datetime.now()) + file=self.log_path + + header = add_keys_if_necessary(file, message) + keys = header + + log=open(file, 'a') + writer = csv.DictWriter(log, keys, extrasaction="ignore") + writer.writerow(message) + log.close() + else: + raise Exception + + + def _send_data(self, message, message_type): + if message_type == "ping": + #TODO send text + contentType='text/xml' + + if self.use_lan: + logger.info("Sending ping using LAN") + req = request.Request("{0}:{1}/{2}".format(self.url, self.server_port, self.ping_path)) + req.add_header('Content-Type', contentType) + response = request.urlopen(req,json.dumps(message).encode()) + response = response.read() + pass + + elif not self.use_lan: + logger.info("Sending ping using modem") + # logger.debug("attaching GPRS") + # + # if not self.inet.attachGPRS("wholesale", "", "", 1): + # logger.error("error attaching GPRS") + # return False + + logger.debug("posting") + if not self.inet.httpPOST( + self.url, + self.server_port, + "/{}".format(self.ping_path), + json.dumps(message), + contentType=contentType + ): + logger.error("error making HTTP post: {0}".format(self.inet.errorText)) + return False + + response=self.inet.httpResponse + + if response is not None: + response = str(self.inet.httpResponse).replace("\n\r", "\n") + else: + response = ("empty response") + + + elif message_type == "image": + response=None + m = MultipartEncoder(fields={'image': ('image', message, 'image/jpeg')}) + + if self.use_lan: + logger.info ("Sending image using LAN") + response = requests.post("{0}:{1}/{2}".format(self.url, self.server_port, self.image_path), data=m.read(), headers={'Content-Type': m.content_type}) + pass + + elif not self.use_lan: + logger.info ("Sending image using modem") + # logger.debug("attaching GPRS") + # if not self.inet.attachGPRS("wholesale", "", "", 1): + # logger.error("error attaching GPRS") + # return False + + logger.debug("ip = {0}".format(self.inet.ip)) + + logger.debug("making HTTP POST request") + + if not self.inet.httpPOST( + self.url, + self.server_port, + "/{}".format(self.image_path), + m.to_string(), + contentType=m.content_type + ): + logger.error("error making HTTP POST: {0}".format(self.inet.errorText)) + return False + + if self.inet.httpResponse is not None: + response = str(self.inet.httpResponse).replace("\n\r", "\n") + else: + response = "empty response" + + elif message_type == "data": + contentType="application/json" + message["sent"] = str(datetime.datetime.now()) + + if self.use_lan: + logger.info("Sending data using LAN") + req = request.Request("{0}:{1}/{2}".format(self.url, self.server_port, self.data_path)) + req.add_header('Content-Type', contentType) + response = request.urlopen(req,json.dumps(message).encode()) + response = response.read() + pass + + elif not self.use_lan: + logger.info("Sending data using modem") + + logger.debug("posting") + + if not self.inet.httpPOST( + self.url, + self.server_port, + "/{}".format(self.data_path), + json.dumps(message), + contentType=contentType + ): + logger.error("error making HTTP POST: {0}".format(self.inet.errorText)) + return False + + if self.inet.httpResponse is not None: + response = str(self.inet.httpResponse).replace("\n\r", "\n") + else: + response = ("empty response") + + def create_transpondence(self): + if self._transpondence is None: + self._transpondence={} + + self._transpondence['mt']=self.mt.now() + + + def add_to_transpondence(self, data, info_type="data"): + if self._transpondence.get(info_type) is not None: + if type(self._transpondence.get(info_type)) is list: + self._transpondence[info_type].append(data) + else: + self._transpondence[info_type] = [self._transpondence[info_type]] + self._transpondence[info_type].append(data) + + else: + self._transpondence[info_type]=[data] + + + self._transpondence diff --git a/datahandling.py b/datahandling.py index 711c296..8828c58 100644 --- a/datahandling.py +++ b/datahandling.py @@ -7,48 +7,12 @@ import json from cell_connection import initializeUartPort, baseOperations, initializeLogs import logging from requests_toolbelt import MultipartEncoder -import post_encode -import base64 -import binascii -import array import csv +import base64 -# logging.basicConfig(level=logging.INFO) - - - -# LOGGER_LEVEL=logging.DEBUG -# CONSOLE_LOGGER_LEVEL=logging.DEBUG -# SCRIPTDIR = os.path.dirname(os.path.abspath(__file__)) logger = logging.getLogger(__name__) -# handler = logging.StreamHandler() -# formatter = logging.Formatter('[%(asctime)-15s] %(name)-5s %(levelname)-8s %(message)s') -# handler.setFormatter(formatter) -# logger.addHandler(handler) -# logger.setLevel(logging.INFO) - -# logger_gsm = logging.getLogger("cell_connection") -# handler = logging.StreamHandler() -# formatter = logging.Formatter('[%(asctime)-15s] %(name)-5s %(levelname)-8s %(message)s') -# handler.setFormatter(formatter) -# logger_gsm.addHandler(handler) -# logger_gsm.setLevel(logging.DEBUG) - -# logger_1 = logging.getLogger("gsm") -# handler = logging.StreamHandler() -# formatter = logging.Formatter('[%(asctime)-15s] %(name)-5s %(levelname)-8s %(message)s') -# handler.setFormatter(formatter) -# logger_1.addHandler(handler) -# logger_1.setLevel(logging.DEBUG) -# -# logger_2 = logging.getLogger("intetgsm") -# handler = logging.StreamHandler() -# formatter = logging.Formatter('[%(asctime)-15s] %(name)-5s %(levelname)-8s %(message)s') -# handler.setFormatter(formatter) -# logger_2.addHandler(handler) -# logger_2.setLevel(logging.DEBUG) def add_keys_if_necessary(existing_file, test_dict): all=None @@ -63,7 +27,7 @@ def add_keys_if_necessary(existing_file, test_dict): if len(header) == 0: header = list(test_dict.keys()) - writer = csv.DictWriter(existing_file, test_dict.keys(), extrasaction="ignore") + writer = csv.DictWriter(existing_file, test_dict.keys(), extrasaction='ignore') writer.writeheader() # if not header >= list(test_dict.keys()) or not header <= list(test_dict.keys()): @@ -82,7 +46,7 @@ def add_keys_if_necessary(existing_file, test_dict): except (OSError, IOError, TypeError) as e: header = list(test_dict.keys()) f=open(existing_file, 'a+') - writer = csv.DictWriter(f, test_dict.keys(), extrasaction="ignore") + writer = csv.DictWriter(f, test_dict.keys(), extrasaction='ignore') writer.writeheader() f.close() @@ -92,117 +56,59 @@ def add_keys_if_necessary(existing_file, test_dict): writer.writerows(all) return header -class Datalogger_Debug (): - def __init__(self, text_path, + +class Datalogger(): + def __init__(self, + missiontime, + text_path, log_path, photo_path): + self._mt = missiontime self.text_path=text_path - self.log_path=os.path.join(log_path, datetime.datetime.now().strftime("Log %Y%m%d-%H%M%S.csv")) + self.log_path=os.path.join(log_path, 'MISSION {}.csv'.format(self._mt.name)) self.photo_path=photo_path pass - - - def log(self, message, message_type="text"): - if message_type == "text": - print ("%s - Log Message: %s"% (str(datetime.datetime.now()), message)) - elif message_type == "image": - image = message - if image: - filename = datetime.datetime.now().strftime("Image %Y%m%d-%H%M%S.jpg") - with open(os.path.join(self.photo_path, filename), 'wb') as f: - f.write(message) + def log(self, r): + self._record = r._get_dict() + # logger.info('Recording {}'.format(self._record)) + for k in self._record.keys(): + if k is 'b': + if self._record[k] is not list: + l = [self._record[k]] + else: + l = self._record[k] + for item in l: + logger.debug("item: {}".format(self._record)) + item['at']=self._mt.to_absolutetime(item['mt']) + item['mid']=self._mt.name + header = add_keys_if_necessary(self.log_path, item) + keys = header + log=open(self.log_path, 'a') + writer = csv.DictWriter(log, keys, extrasaction='ignore') + writer.writerow(item) + log.close() + elif k is 'i': + if self._record[k] is tuple: + l = [self._record[k]] + else: + l = self._record[k] + for item in l: + # Form is ('name', file object, 'type') + logger.info('item is {}'.format(type(item))) + filename = item[0] + file = base64.b64decode(bytes(item[1],'ascii')) + with open(os.path.join(self.photo_path, filename), 'wb') as f: + f.write(file) + # file.save(os.path.join(self.photo_path, filename)) return 'success' - elif message_type == "data": - message["sent"] = str(datetime.datetime.now()) - file=self.log_path - header = add_keys_if_necessary(file, message) - keys = header - - log=open(file, 'a') - writer = csv.DictWriter(log, keys, extrasaction="ignore") - writer.writerow(message) - log.close() - else: - raise Exception - -class Datareporter_Debug (): - def __init__(self, path=SCRIPTDIR): - #TODO communication - pass - - @property - def status (self): - return (0, "Data reporter functioning properly") - - def send(self, message, type="text"): - if type == "text": - #TODO send text - print ("%s - Sent Message: %s"% (str(datetime.datetime.now()), message)) - elif type == "image": - #todo send image - print ("%s - Sent Image: %s"% (str(datetime.datetime.now()), message)) - else: - #todo error handling - raise Exception - - -class Datareporter_Debug2 (): - #Debug 2 sends to server - def __init__(self, path=SCRIPTDIR, - report_url = "http://10.0.1.4:5010/report", - report_image_url = "http://10.0.1.4:5010/photo", - com_port_name = "/dev/ttyAMA0", - baud_rate = 9600): - self.report_url = report_url - self.report_image_url = report_image_url - self.com_port_name = com_port_name, - self.baud_rate = baud_rate - pass - - - @property - def status (self): - #TODO status check - try: - check = json.loads(request.urlopen(self.report_url).read().decode()).get('status') - pass - if not check: - return (0, "Data reporter functioning properly") - else: - return (1, check) - except Exception as e: - return (1, "Data reporter error: %s" % e) - - - - def send(self, message, type="text"): - try: - if type == "text": - #TODO send text - print ("%s - Sent Message: %s"% (str(datetime.datetime.now()), message)) - elif type == "image": - #todo send image - response = requests.post(self.report_url, files={'file': message}) - print ("%s - Sent Image: %s"% (str(datetime.datetime.now()), message)) - elif type == "data": - #add date to message - message['sent']=str(datetime.datetime.now()) - req = request.Request(self.report_image_url) - req.add_header('Content-Type', 'application/json') - response = request.urlopen(req,json.dumps(message).encode()) - the_page = response.read() - return 0 - except Exception as e: - #todo error handling - pass - -class Datareporter_Debug3 (): +class Datareporter(): #Debug 2 sends from cell to server from lib.sim900.inetgsm import SimInetGSM def __init__(self, + missiontime, url, data_path, image_path, @@ -213,6 +119,7 @@ class Datareporter_Debug3 (): use_lan = False, path=SCRIPTDIR): #TODO communication + self.mt = missiontime self.url = url self.server_port=server_port self.image_path = image_path @@ -221,149 +128,161 @@ class Datareporter_Debug3 (): self.baud_rate = baud_rate self.ping_path = ping_path self.use_lan = use_lan - self.port = initializeUartPort(portName=self.com_port_name, baudrate=self.baud_rate) + self._transpondence=None if not use_lan: + self.port = initializeUartPort(portName=self.com_port_name, baudrate=self.baud_rate) d = baseOperations(self.port, logger) if not d is None: - # return None - (self.gsm, self.imei) = d - self.inet = self.SimInetGSM(self.port, logger) + self.inet = self.SimInetGSM(self.port, logger) - logger.info("ip = {0}".format(self.inet.ip)) + logger.info('ip = {0}'.format(self.inet.ip)) - pass + logger.debug('attaching GPRS') + + if not self.inet.attachGPRS('wholesale', '', '', 1): + logger.error('error attaching GPRS') + return False + + #register mission number to server + intiate = Record(str(self.mt.timezero),'zt') + # intiate.add(self.mt.mid,'mid') + self.send(intiate, _intiating_report=True) @property def status (self): #TODO status check try: - return (0, "Data reporter functioning properly") + return (0, 'Data reporter functioning properly') except Exception as e: - return (1, "Data reporter error: %s" % e) + return (1, 'Data reporter error: %s' % e) - def send(self, message, message_type): - # logger.debug("Message.read is {}".format(message.read())) - if message_type == "ping": - #TODO send text - contentType='text/xml' + def _send_data(self, message, _intiating_report=False): + response=None + m = MultipartEncoder(fields=message) - if self.use_lan: - req = request.Request("{0}:{1}/{2}".format(self.url, self.server_port, self.ping_path)) - req.add_header('Content-Type', contentType) - response = request.urlopen(req,json.dumps(message).encode()) - response = response.read() - pass - - elif not self.use_lan: - logger.info("making HTTP POST request from cell") - logger.info("attaching GPRS") - - if not self.inet.attachGPRS("wholesale", "", "", 1): - logger.error("error attaching GPRS") - return False - - if not self.inet.httpPOST( - self.url, - self.server_port, - "/{}".format(self.ping_path), - json.dumps(message), - contentType=contentType - ): - logger.error("error making HTTP GET post: {0}".format(self.inet.errorText)) - return False - - response=self.inet.httpResponse - - if response is not None: - response = str(self.inet.httpResponse).replace("\n\r", "\n") - else: - response = ("empty response") - - - elif message_type == "image": - contentType="mulipart/form-data" - re=message - response=None - m = MultipartEncoder(fields={'image': ('image', message, 'image/jpeg')}) - - - if self.use_lan: - # req.add_header('Content-Type', contentType) - response = requests.post("{0}:{1}/{2}".format(self.url, self.server_port, self.image_path), data=m.read(), headers={'Content-Type': m.content_type}) - # response = requests.post("{0}:{1}/{2}".format(self.url, self.server_port, self.image_path), data=m) - # response = response.text() - pass - - elif not self.use_lan: - logger.info("attaching GPRS") - if not self.inet.attachGPRS("wholesale", "", "", 1): - logger.error("error attaching GPRS") - return False - - logger.info("ip = {0}".format(self.inet.ip)) - - #making HTTP GET request - logger.info("making HTTP POST request") - - - if not self.inet.httpPOST( - self.url, - self.server_port, - "/{}".format(self.image_path), - m.to_string(), - contentType=m.content_type - ): - logger.error("error making HTTP POST: {0}".format(self.inet.errorText)) - return False - - if self.inet.httpResponse is not None: - response = str(self.inet.httpResponse).replace("\n\r", "\n") - else: - response = "empty response" - - elif message_type == "data": - #making HTTP GET request - contentType="application/json" - message["sent"] = str(datetime.datetime.now()) - - if self.use_lan: - req = request.Request("{0}:{1}/{2}".format(self.url, self.server_port, self.data_path)) - req.add_header('Content-Type', contentType) - response = request.urlopen(req,json.dumps(message).encode()) - response = response.read() - pass - - elif not self.use_lan: - logger.info("making HTTP POST request from cell") - logger.info("attaching GPRS") - - if not self.inet.attachGPRS("wholesale", "", "", 1): - logger.error("error attaching GPRS") - return False - - if not self.inet.httpPOST( - self.url, - self.server_port, - "/{}".format(self.data_path), - json.dumps(message), - contentType=contentType - ): - logger.error("error making HTTP GET post: {0}".format(self.inet.errorText)) - return False - - if response is not None: - response = str(self.inet.httpResponse).replace("\n\r", "\n") - else: - response = ("empty response") - - if response is not None: - logger.info("response: \"{0}\"".format(response)) + if _intiating_report: + path = '{0}'.format(self.image_path) else: - logger.info("empty response") + path = '{0}/{1}'.format(self.image_path,self.mt.mid) + + if self.use_lan: + logger.info ('Sending transpondence using LAN') + response = requests.post('{0}:{1}/{2}'.format(self.url, self.server_port, path), data=m.read(), headers={'Content-Type': m.content_type}) + pass + + elif not self.use_lan: + logger.info ('Sending transpondence using modem') + # logger.debug('attaching GPRS') + # if not self.inet.attachGPRS('wholesale', '', '', 1): + # logger.error('error attaching GPRS') + # return False + + logger.debug('ip = {0}'.format(self.inet.ip)) + + logger.debug('making HTTP POST request') + + if not self.inet.httpPOST( + self.url, + self.server_port, + "/{}".format(path), + m.to_string(), + contentType=m.content_type + ): + logger.error('error making HTTP POST: {0}'.format(self.inet.errorText)) + return False + + if self.inet.httpResponse is not None: + response = str(self.inet.httpResponse).replace('\n\r', '\n') + else: + response = 'empty response' + + if _intiating_report: + if type (response) is str: + mid = response + else: + mid = response.text + self.mt.set_mid(mid) + + return response + + + + def send(self, t, _intiating_report=False): + self._transpondence = t._get_dict() + self._transpondence['mt'] = self.mt.now() + # print ('Send transpondence {}'.format(self._transpondence)) + + for k in self._transpondence.keys(): + # if self._transpondence[k] is list or self._transpondence[k] is dict or self._transpondence[k] is float: + if type(self._transpondence) is dict: + self._transpondence[k] = json.dumps(self._transpondence[k]) + + r = self._send_data(message=self._transpondence, _intiating_report=_intiating_report) + + #On error, do not clear transpondence + if not r: + self._transpondence = self._transpondence + + return None + +class Record(): + def __init__(self,first_item=None, first_item_type=None): + # if self._transpondence is None: + self._transpondence={} + if first_item and first_item_type: + self.add(first_item, first_item_type) + + def add(self, data, info_type='data'): + if type(data) is not list: + if self._transpondence.get(info_type) is not None: + if type(self._transpondence.get(info_type)) is list: + self._transpondence[info_type].append(data) + else: + self._transpondence[info_type] = [self._transpondence[info_type]] + self._transpondence[info_type].append(data) + + else: + self._transpondence[info_type]=data + + else: + if self._transpondence.get(info_type) is not None: + if type(self._transpondence.get(info_type)) is list: + self._transpondence[info_type] + data + else: + self._transpondence[info_type] = [self._transpondence[info_type]] + self._transpondence[info_type] + data + else: + self._transpondence[info_type]=data + + def _get_dict(self): + return self._transpondence + + # def send(self): + # # self._transpondence['mid'] = m.name + # # self._transpondence['mt'] = m.now() + # # print ('Send transpondence {}'.format(self._transpondence)) + # + # for k in self._transpondence.keys(): + # if self._transpondence[k] is not str: #basically, check if image + # self._transpondence[k] = json.dumps(self._transpondence[k]) + # + # r = self._send(message=self._transpondence, message_type='transpondence') + # + # #On error, do not clear transpondence + # if not r: + # self._transpondence = None + + + + + + + + diff --git a/instruments.py b/instruments.py index 559bbca..3af7d01 100644 --- a/instruments.py +++ b/instruments.py @@ -2,73 +2,20 @@ __author__ = 'asc' debug = True from random import random import Adafruit_BMP.BMP085 as BMP085 -import picamera import configparser import time import logging +import base64 logger = logging.getLogger(__name__) -class Barometer_Debug (): - def __init__(self): - pass - - @property - def status (self): - return (0, "Barometer functioning properly") - - @property - def temperature (self): - if self.status[0]: - return 'error' - - if debug: - temp = random()*100 - else: - raise Exception ('Not Debug') - return temp - - @property - def pressure (self): - if (self.status[0]): - return 'error' - - if debug: - press = random() - else: - raise Exception ('Not Debug') - return press - - @property - def altitude (self): - if self.status[0]: - return 'error' - if debug: - alt = random()*100000 - else: - raise Exception ('Not Debug') - - return alt - -class Camera_Debug(): - - def __init__(self): - pass - - @property - def status (self): - return (0, "Camera functioning properly") - - def capture (self): - #todo capture image - return ({"file":open("image2.jpg", 'rb')}) - -#camera debug 2 uses actual camera -class Camera_Debug2(): - def __init__(self, low_quality_resolution=(320,240), +class Camera: + def __init__(self, + low_quality_resolution=(320,240), low_quality_compression_pct=5, high_quality_resolution=(2592,1944), high_quality_compression_pct=85, + debug = False, **kwargs): logger.debug("Initializing camera") time.sleep(1) @@ -77,11 +24,13 @@ class Camera_Debug2(): self.high_quality_resolution = high_quality_resolution self.high_quality_compression_pct = high_quality_compression_pct self.kwargs=kwargs - self._cam = picamera.PiCamera(resolution=high_quality_resolution) - # if "vflip" in kwargs.keys(): - for k in kwargs.keys(): - setattr(self._cam, k, kwargs.get(k)) - + self._debug = debug + if self._debug == False: + import picamera + self._cam = picamera.PiCamera(resolution=high_quality_resolution) + # if "vflip" in kwargs.keys(): + for k in kwargs.keys(): + setattr(self._cam, k, kwargs.get(k)) logger.debug("Camera intialized") pass @@ -90,39 +39,56 @@ class Camera_Debug2(): def status (self): return (0, "Camera functioning properly") - def capture (self, no_low_quality=False, no_high_quality=False, **kwargs): + def capture (self, name, no_low_quality=False, no_high_quality=False, **kwargs): #todo image adjustments img_hi = None img_lo = None - if not no_high_quality: - logger.debug('Taking high quality photo') - self._cam.capture("temp_img_hi.jpg", - resize=self.high_quality_resolution, - quality=self.high_quality_compression_pct, - # **kwargs - ) - img_hi = open("temp_img_hi.jpg", 'rb') - with open("temp_img_hi.jpg", 'rb') as f: - img_hi = f.read() - logger.debug('High quality photo taken') + r = {} + if not self._debug: + if not no_high_quality: + logger.debug('Taking high quality photo') + self._cam.capture("temp_img_hi.jpg", + resize=self.high_quality_resolution, + quality=self.high_quality_compression_pct, + # **kwargs + ) + with open("temp_img_hi.jpg", 'rb') as f: + # img_hi = base64.b64encode(f.read()) + img_hi = str(base64.b64encode(f.read()),'ascii') + r['hi']=("{}_hi.jpg".format(name), img_hi, "image/jpeg") + logger.debug('High quality photo taken') - if not no_low_quality: - time.sleep(1) - logger.debug('Taking low quality photo (Resolution: {}, JPEG Quality: {}%)'.format(self.low_quality_resolution, self.low_quality_compression_pct)) - self._cam.capture("temp_img_lo.jpg", - resize=self.low_quality_resolution, - quality=self.low_quality_compression_pct, - # **kwargs - ) - with open("temp_img_lo.jpg", 'rb') as f: - img_lo = f.read() - logger.debug('Low quality photo taken') + if not no_low_quality: + time.sleep(1) + logger.debug('Taking low quality photo (Resolution: {}, JPEG Quality: {}%)'.format(self.low_quality_resolution, self.low_quality_compression_pct)) + self._cam.capture("temp_img_lo.jpg", + resize=self.low_quality_resolution, + quality=self.low_quality_compression_pct, + # **kwargs + ) + with open("temp_img_lo.jpg", 'rb') as f: + img_lo = str(base64.b64encode(f.read()),'ascii') + # img_lo = str(f.read()) + r['lo']=("{}_lo.jpg".format(name), img_lo, "image/jpeg") + logger.debug('Low quality photo taken') + else: + if not no_high_quality: + with open("temp_img_hi.jpg", 'rb') as f: + img_hi = str(base64.b64encode(f.read()),'ascii') + # img_hi = str(f.read(),'ascii') + r['hi']=("{}_hi.jpg".format(name), img_hi, "image/jpeg") + logger.info('High quality photo taken') - return ({"hi":img_hi, - "lo":img_lo}) + if not no_low_quality: + with open("temp_img_lo.jpg", 'rb') as f: + img_lo = str(base64.b64encode(f.read()),'ascii') + # img_lo = str(f.read()) + r['lo']=("{}_lo.jpg".format(name), img_lo, "image/jpeg") + logger.info('Low quality photo taken') -#barometerdebug2 uses actual barometer -class Barometer_Debug2 (): + return r + +class Barometer: def __init__(self): logger.debug("Intializing barometer") self.bmp = BMP085.BMP085() @@ -165,14 +131,17 @@ class Barometer_Debug2 (): alt = self.altitude press = self.pressure temp = self.temperature - result = {"altitude":alt, - "temperature":temp, - "pressure":press, + result = {"a":alt, + "t":temp, + "p":press, } logger.debug("Barometer reads {}".format(result)) return result +# class Gps: + + diff --git a/logging.ini b/logging.ini new file mode 100644 index 0000000..0d4ff62 --- /dev/null +++ b/logging.ini @@ -0,0 +1,37 @@ +[loggers] +keys=root,datahandling,instruments + +[handlers] +keys=fileHandler, consoleHandler + +[formatters] +keys=myFormatter + +[logger_root] +level=DEBUG +handlers=consoleHandler, fileHandler + +[logger_datahandling] +level=INFO +handlers=fileHandler +qualname=datahandling + +[logger_instruments] +level=INFO +handlers=fileHandler +qualname=instruments + +[handler_consoleHandler] +class=StreamHandler +level=INFO +formatter=myFormatter +args=(sys.stdout,) + +[handler_fileHandler] +class=FileHandler +formatter=myFormatter +args=("config.log",) + +[formatter_myFormatter] +format=[%(asctime)-15s] %(name)-25s %(levelname)-8s %(message)s +datefmt= \ No newline at end of file diff --git a/main.py b/main.py index 5fb92f1..7dc14cc 100644 --- a/main.py +++ b/main.py @@ -1,80 +1,94 @@ __author__ = 'asc' DEBUG = True import logging +import logging.handlers,logging.config -if DEBUG: - from instruments import Barometer_Debug2 as Barometer - from instruments import Camera_Debug2 as Camera - from datahandling import Datalogger_Debug as Datalogger - from datahandling import Datareporter_Debug3 as Datareporter - from system import System_Debug as System - import threading +from instruments import Barometer, Camera +from datahandling import Datalogger, Datareporter +from system import System as System +import threading +from datahandling import Record +from mission import Mission +import random +import string - import datetime - -import configparser - -# logging.basicConfig(level=logging.DEBUG, format=("%(asctime)s - %(name)s - %(levelname)s - %(message)s")) -# log = logging.getLogger("instruments") -# log.setLevel(logging.DEBUG) -# log. -# # log.setFo +logging.config.fileConfig('logging.ini') log = logging.getLogger(__name__) -log1 = logging.getLogger("instruments") -log2 = logging.getLogger("datahandling") -handler = logging.FileHandler('myapp.log') +# log = logging.basicConfig() +# log1 = logging.getLogger("instruments") +# log2 = logging.getLogger("datahandling") +# handler = logging.handlers.RotatingFileHandler('spaceballoon.log', backupCount=5) -formatter = logging.Formatter('[%(asctime)-15s] %(name)-15s %(levelname)-8s %(message)s') -handler.setFormatter(formatter) -log.addHandler(handler) -log1.addHandler(handler) -log2.addHandler(handler) +formatter = logging.Formatter('[%(asctime)-25s] %(name)-15s %(levelname)-8s %(message)s') +# handler.setFormatter(formatter) +# log.addHandler(handler) +# log1.addHandler(handler) +# log2.addHandler(handler) log.setLevel(logging.DEBUG) -log1.setLevel(logging.DEBUG) -log2.setLevel(logging.INFO) +# log1.setLevel(logging.DEBUG) +# log2.setLevel(logging.INFO) #start-up #log denotes write to local, report denotes sending to server -#TODO startup message - #loadconfig from config import * -notebook = Datalogger (text_path=None, - log_path=log_path, - photo_path=photo_path) -log.debug ("System started") -# logger.log("Log Intiated") - -#system check -system = System() - -log.debug (system.stats) +mission = Mission() #todo test cell connection reporter = Datareporter ( - use_lan = True, - url = "http://home.ascorrea.com", - server_port = 5010, + missiontime = mission, + use_lan = False, + url = "http://spaceballoon-server.herokuapp.com", + server_port = 80, data_path = "upload-data", - image_path = "upload-file", + image_path = "missions", ping_path = "ping", com_port_name="/dev/ttyAMA0", - baud_rate = 9600) + baud_rate = 9600 +) + +t = Record({'zt':mission.timezero}) +# mid = reporter.send(t) #reply of first message is the mission number + +# mission.set_mid(mid) + +notebook = Datalogger ( + missiontime = mission, + text_path=None, + log_path=log_path, + photo_path=photo_path) + +log.debug ("System started") + +#system check +system = System() +log.debug (system.stats) + +#set mission time + +log.info("Mission {} started, time zero is {}".format(mission.name, mission.timezero)) + + +#intiate mission + + + +# log.info('Sent {} to server'.format(intiate)) #TODO test camera camera = Camera (low_quality_compression_pct=low_quality_compression_pct, low_quality_resolution=low_quality_resolution, high_quality_compression_pct=high_quality_compression_pct, high_quality_resolution=high_quality_resolution, - vflip=True, + vflip=False, hflip=True, - exposure_mode='sports' + exposure_mode='sports', + # debug=True ) - #todo test barometer barometer = Barometer() @@ -95,51 +109,51 @@ def scheduler (interval, worker_func, iterations = 0): def update_barometer_local(): global bar bar = barometer.read() - notebook.log(bar, message_type="data") + bar.update({'mt':mission.now()}) + record = Record(bar.copy(),'b') + notebook.log(record) def update_image_local(): global img - img = camera.capture() - notebook.log(img.get('hi'), message_type="image") + img = camera.capture(name=mission.now()) + record = Record([img.get('hi'), img.get('lo')], 'i') + notebook.log(record) +def submit_report(): + global bar + global img + global counter + global transpondence -scheduler(2, update_barometer_local) -scheduler(5, update_image_local) + # reporter.create_transpondence() + + if not transpondence: + log.info("type of transpondence is {}".format(type(transpondence))) + transpondence = Record() + log.info("type of transpondence is {} and is {}".format(type(transpondence), transpondence)) + + if (counter % refresh_barometer_transmit) == 0: + log.info("type of transpondence is {} and is {}".format(type(transpondence), transpondence)) + transpondence.add(bar,'b') + + if (counter % refresh_camera_transmit) == 0: + transpondence.add(img.get('lo'),'i') + + transpondence = reporter.send(transpondence) #returns none on success, (bad practice?) + counter += 1 + log.info('Counter = {}'.format(counter)) counter=1 -while counter>0: - global img - global bar - # bar=None - # img=None - try: - reporter.send(1, message_type="ping") +img = None +bar = None +transpondence = None - # if (counter % refresh_camera_local) == 0: - # if not img: - # img = camera.capture() - # notebook.log(img.get('hi'), message_type="image") +scheduler(1, update_barometer_local) +scheduler(refresh_camera_local, update_image_local) +scheduler(2, submit_report) - if (counter % refresh_barometer_transmit) == 0: - if not bar: - bar = barometer.read() - reporter.send(bar, message_type="data") - if (counter % refresh_camera_transmit) == 0: - # log.debug('Need to transmit picture, {}'.format(img)) - if not img: - img = camera.capture() - reporter.send(img.get('lo'), message_type="image") - if (counter % refresh_system) == 0: - log.debug(system.stats) - - except Exception as e: - log.debug("Exception: {}".format(e)) - continue - - counter += 1 - log.debug("Counter = {}".format(counter)) pass diff --git a/mission.py b/mission.py new file mode 100644 index 0000000..2d4767b --- /dev/null +++ b/mission.py @@ -0,0 +1,43 @@ +__author__ = 'asc' +import time +import datetime +import random, string + +# def generate_mid(): +# new_mission_id = ''.join(random.SystemRandom().choice(string.ascii_uppercase) for _ in range(2)) +# return new_mission_id + +class Mission(): + def __init__(self, timezero=None, mid=None): + if not timezero: + timezero = datetime.datetime.now() + self._zero=timezero + self._mid = mid + # self._mid=generate_mid() + + def set_mid(self, mid): + self._mid = mid + + def now(self): + #returns a string + d=datetime.datetime.now()-self._zero + return str(d.total_seconds()) + + @property + def timezero(self): + return self._zero + + def to_absolutetime(self, mission_time): + return self._zero + datetime.timedelta(seconds=float(mission_time)) + + @property + def mid(self): + if self._mid: + mid = self._mid + else: + mid= None + return self._mid + + @property + def name(self): + return self._mid \ No newline at end of file diff --git a/system.py b/system.py index aceb707..9a52c67 100644 --- a/system.py +++ b/system.py @@ -3,7 +3,7 @@ import os import psutil -class System_Debug(): +class System(): def __init__(self): #TODO add system initialization diff --git a/test.py b/test.py index dd97266..3348879 100644 --- a/test.py +++ b/test.py @@ -1,14 +1,17 @@ import csv, requests -from instruments import Camera_Debug2 as Camera -from datahandling import Datareporter_Debug3 as Datareporter -from system import System_Debug +from instruments import Camera +from datahandling import Datareporter +from system import System import serial import sys import logging import base64 from requests_toolbelt import MultipartEncoder +from time import sleep +from logging import config -logging.getLogger("datahandling") +config.fileConfig('logging.ini') +logging.getLogger("inetgsm") data = {"temp":1,"press":3,"altitude":2,"cheetas":"just enough"} @@ -17,6 +20,7 @@ pass com_port_name = "/dev/ttyAMA0" image = open("resized_image.jpg", 'rb') +image = image.read() # image = image.read() # e=base64.b64encode(image) @@ -26,7 +30,7 @@ image = open("resized_image.jpg", 'rb') # m = MultipartEncoder(fields={'image': ('image', image, 'image/jpeg')}) report = Datareporter ( - use_lan = True, + # use_lan = True, url = "http://home.ascorrea.com", server_port = 5010, data_path = "upload-data", @@ -35,28 +39,30 @@ report = Datareporter ( ping_path="ping", baud_rate = 9600) -camera = Camera (low_quality_compression_pct=10, - low_quality_resolution=(320, 240), - high_quality_compression_pct=100, - high_quality_resolution=(2592,1944), - vflip=True, - hflip=True, - exposure_mode='sports' - ) +# camera = Camera (low_quality_compression_pct=10, +# low_quality_resolution=(320, 240), +# high_quality_compression_pct=100, +# high_quality_resolution=(2592,1944), +# vflip=True, +# hflip=True, +# # exposure_mode='sports' +# ) # print (report.check()) # print (image) # report.send(m.to_string(), message_type="image") # report.send(data, message_type="data") -img = camera.capture() -report.send(img.get('lo'), message_type="image") +# img = camera.capture() +# report.send(img.get('lo'), message_type="image") # report.send(image, message_type="image") # execfile("test_sms.py") - -# report.send("1",message_type="ping") +for i in range(1,10): + print (i) + report.send(image,message_type="image") + sleep(1) pass \ No newline at end of file