no message

config.ini

@@ -1,9 +1,9 @@
 [refresh rates]
-refresh camera local = 5
+refresh camera local = 10
-refresh camera transmit = 10
+refresh camera transmit = 15
 
-refresh barometer local = 1
+refresh barometer local = 2
-refresh barometer transmit = 5
+refresh barometer transmit = 2
 
 refresh gps local = 2
 refresh gps transmit = 5
@@ -12,7 +12,7 @@ refresh system = 10
 
 [camera settings]
 low quality resolution = (320, 240)
-low quality compression pct = 10
+low quality compression pct = 7
 high quality resolution = (2592,1944)
 high quality compression pct = 100
 
@@ -22,11 +22,11 @@ baud rate = 9600
 
 [server settings]
 use_lan = True
-url = "http://home.ascorrea.com"
+url = http://home.ascorrea.com
 server_port = 5010
-data_path = "upload-data"
+data_path = upload-data
-image_path = "upload-file"
+image_path = missions
-ping_path = "ping"
+ping_path = ping
 
 [local storage settings]
 photo path = /home/pi/scripts/spaceballoon/photos

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

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,67 @@ 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, r):
-
+        self._record = r._get_dict()
-    def log(self, message, message_type="text"):
+        # logger.info('Recording {}'.format(self._record))
-        if message_type == "text":
+        for k in self._record.keys():
-            print ("%s - Log Message: %s"% (str(datetime.datetime.now()), message))
+            if k is 'b':
-        elif message_type == "image":
+                if self._record[k] is not list:
-            image = message
+                    l = [self._record[k]]
-            if image:
+                else:
-                filename = datetime.datetime.now().strftime("Image %Y%m%d-%H%M%S.jpg")
+                    l = self._record[k]
-                with open(os.path.join(self.photo_path, filename), 'wb') as f:
+                for item in l:
-                    f.write(message)
+                    logger.debug("item: {}".format(self._record), extra={'MISSION_TIME': self._mt.now(), 'MISSION_ID':self._mt.name})
-                return 'success'
+                    item['at']=self._mt.to_absolutetime(item['mt'])
-        elif message_type == "data":
+                    item['mid']=self._mt.name
-            message["sent"] = str(datetime.datetime.now())
+                    header = add_keys_if_necessary(self.log_path, item)
-            file=self.log_path
-
-            header = add_keys_if_necessary(file, message)
                     keys = header
-
+                    log=open(self.log_path, 'a')
-            log=open(file, 'a')
+                    writer = csv.DictWriter(log, keys, extrasaction='ignore')
-            writer = csv.DictWriter(log, keys, extrasaction="ignore")
+                    writer.writerow(item)
-            writer.writerow(message)
                     log.close()
+                    logger.info('Barometer data recorded',extra={'MISSION_TIME': self._mt.now(), 'MISSION_ID':self._mt.name})
+            elif k is 'i':
+                if self._record[k] is tuple:
+                    l = [self._record[k]]
                 else:
-            raise Exception
+                    l = self._record[k]
+                for item in l:
+                    # Form is ('name', file object, 'type')
+                    filename = item[0]
+                    file = base64.b64decode(bytes(item[1],'ascii'))
 
-class Datareporter_Debug ():
+                    folder = os.path.join(self.photo_path, self._mt.mid)
-    def __init__(self, path=SCRIPTDIR):
+                    file_path = os.path.join(self.photo_path, folder, filename)
-        #TODO communication
-        pass
 
-    @property
+                    if not os.path.exists(folder):
-    def status (self):
+                            os.makedirs(folder)
-        return (0, "Data reporter functioning properly")
 
-    def send(self, message, type="text"):
+                    with open(file_path, 'wb') as f:
-        if type == "text":
+                        f.write(file)
-            #TODO send text
+                    # file.save(os.path.join(self.photo_path, filename))
-            print ("%s - Sent Message: %s"% (str(datetime.datetime.now()), message))
+                    logger.info('Image data recorded',extra={'MISSION_TIME': self._mt.now(), 'MISSION_ID':self._mt.name})
-        elif type == "image":
-            #todo send image
-            print ("%s - Sent Image: %s"% (str(datetime.datetime.now()), message))
-        else:
-            #todo error handling
-            raise Exception
 
+                return 'success'
 
-class Datareporter_Debug2 ():
+class Datareporter():
-    #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 ():
-    #Debug 2 sends from cell to server
     from lib.sim900.inetgsm import SimInetGSM
 
     def __init__(self,
+                 missiontime,
                  url,
                  data_path,
                  image_path,
@@ -213,6 +127,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 +136,146 @@ 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)
 
-        logger.info("ip = {0}".format(self.inet.ip))
+            logger.info('ip = {0}'.format(self.inet.ip), extra={'MISSION_TIME': self.mt.now(), 'MISSION_ID':self.mt.name})
 
-        pass
+            logger.debug('attaching GPRS', extra={'MISSION_TIME': self.mt.now(), 'MISSION_ID':self.mt.name})
+
+            if not self.inet.attachGPRS('wholesale', '', '', 1):
+                logger.error('error attaching GPRS', extra={'MISSION_TIME': self.mt.now(), 'MISSION_ID':self.mt.name})
+                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):
+    def _send_data(self, message, _intiating_report=False):
-        # logger.debug("Message.read is {}".format(message.read()))
-        if message_type == "ping":
-            #TODO send text
-            contentType='text/xml'
-
-            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')})
+        m = MultipartEncoder(fields=message)
 
+        if _intiating_report:
+            path = '{0}'.format(self.image_path)
+        else:
+            path = '{0}/{1}'.format(self.image_path,self.mt.mid)
 
         if self.use_lan:
-                # req.add_header('Content-Type', contentType)
+            logger.info ('Sending transpondence using LAN', extra={'MISSION_TIME': self.mt.now(), 'MISSION_ID':self.mt.name})
-                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, 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")
+            logger.info ('Sending transpondence using modem', extra={'MISSION_TIME': self.mt.now(), 'MISSION_ID':self.mt.name})
-                if not self.inet.attachGPRS("wholesale", "", "", 1):
+            # logger.debug('attaching GPRS')
-                    logger.error("error attaching GPRS")
+            # if not self.inet.attachGPRS('wholesale', '', '', 1):
-                    return False
+            #     logger.error('error attaching GPRS')
+            #     return False
 
-                logger.info("ip = {0}".format(self.inet.ip))
+            logger.debug('ip = {0}'.format(self.inet.ip), extra={'MISSION_TIME': self.mt.now(), 'MISSION_ID':self.mt.name})
-
-                #making HTTP GET request
-                logger.info("making HTTP POST request")
 
+            logger.debug('making HTTP POST request', extra={'MISSION_TIME': self.mt.now(), 'MISSION_ID':self.mt.name})
 
             if not self.inet.httpPOST(
                     self.url,
                     self.server_port,
-                        "/{}".format(self.image_path),
+                    "/{}".format(path),
                     m.to_string(),
                     contentType=m.content_type
             ):
-                    logger.error("error making HTTP POST: {0}".format(self.inet.errorText))
+                logger.error('error making HTTP POST: {0}'.format(self.inet.errorText), extra={'MISSION_TIME': self.mt.now(), 'MISSION_ID':self.mt.name})
                 return False
 
             if self.inet.httpResponse is not None:
-                    response = str(self.inet.httpResponse).replace("\n\r", "\n")
+                response = str(self.inet.httpResponse).replace('\n\r', '\n')
             else:
-                    response = "empty response"
+                response = 'empty response'
 
-        elif message_type == "data":
+        if _intiating_report:
-            #making HTTP GET request
+            if type (response) is str:
-            contentType="application/json"
+                mid = response
-            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")
+                mid = response.text
+            self.mt.set_mid(mid)
 
-        if response is not None:
+        return response
-                logger.info("response: \"{0}\"".format(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:
-                logger.info("empty response")
+                    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
+
+
+
+
+
+
+
+
 
 

instruments.py

@@ -1,16 +1,100 @@
 __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 ():
+class Camera:
-    def __init__(self):
+    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.info("Initializing camera", extra={'MISSION_TIME': "", 'MISSION_ID':""})
+        time.sleep(1)
+        self.low_quality_resolution = low_quality_resolution
+        self.low_quality_compression_pct = low_quality_compression_pct
+        self.high_quality_resolution = high_quality_resolution
+        self.high_quality_compression_pct = high_quality_compression_pct
+        self.kwargs=kwargs
+        self._debug = debug
+        if not self._debug:
+            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", extra={'MISSION_TIME': "", 'MISSION_ID':""})
+        pass
+
+    @property
+    def status (self):
+        return (0, "Camera functioning properly")
+
+    def capture (self, name, no_low_quality=False, no_high_quality=False, **kwargs):
+        #todo image adjustments
+        img_hi = None
+        img_lo = None
+        r = {}
+        if not self._debug:
+            if not no_high_quality:
+                logger.debug('Taking high quality photo', extra={'MISSION_TIME': "", 'MISSION_ID':""})
+                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', extra={'MISSION_TIME': "", 'MISSION_ID':""})
+
+            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', extra={'MISSION_TIME': "", 'MISSION_ID':""})
+        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', extra={'MISSION_TIME': "", 'MISSION_ID':""})
+
+            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', extra={'MISSION_TIME': "", 'MISSION_ID':""})
+
+        return r
+
+class Barometer:
+    def __init__(self, debug=False):
+        logger.debug("Intializing barometer", extra={'MISSION_TIME': "", 'MISSION_ID':""})
+        if not debug:
+            import Adafruit_BMP.BMP085 as BMP085
+            self.bmp = BMP085.BMP085()
+        logger.debug("Barometer intilized", extra={'MISSION_TIME': "", 'MISSION_ID':""})
         pass
 
     @property
@@ -22,10 +106,7 @@ class Barometer_Debug ():
         if self.status[0]:
             return 'error'
 
-        if debug:
+        temp = self.bmp.read_temperature()
-            temp = random()*100
-        else:
-            raise Exception ('Not Debug')
         return temp
 
     @property
@@ -33,100 +114,43 @@ class Barometer_Debug ():
         if (self.status[0]):
             return 'error'
             
-        if debug:
+#         press = 100000*random()
-            press = random()
+        press = self.bmp.read_pressure()
-        else:
+
-            raise Exception ('Not Debug')
         return press
 
     @property
     def altitude (self):
         if self.status[0]:
             return 'error'
-        if debug:
+        #TODO Set the altitude of your current location in meter 
-            alt = random()*100000
+        alt = self.bmp.read_altitude()
-        else:
-            raise Exception ('Not Debug')
-
         return alt
 
-class Camera_Debug():
+    def read(self):
+        logger.debug("Reading from barometer", extra={'MISSION_TIME': "", 'MISSION_ID':""})
+        #refresh each instrument
+        if not debug:
+            alt = self.altitude
+            press = self.pressure
+            temp = self.temperature
+        else:
+            temp = random()*100
+            press = random()
+            alt = random()*100000
+        result = {"a":alt,
+                "t":temp,
+                "p":press,
+                    }
+        logger.debug("Barometer reads {}".format(result), extra={'MISSION_TIME': "", 'MISSION_ID':""})
 
+        return result
+
+class Gps:
     def __init__(self):
-        pass
+        logger.debug("Intializing GPS")
-
+        # self.bmp = BMP085.BMP085()
-    @property
+        logger.debug("Gps intilized")
-    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),
-                 low_quality_compression_pct=5,
-                 high_quality_resolution=(2592,1944),
-                 high_quality_compression_pct=85,
-                 **kwargs):
-        logger.debug("Initializing camera")
-        time.sleep(1)
-        self.low_quality_resolution = low_quality_resolution
-        self.low_quality_compression_pct = low_quality_compression_pct
-        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))
-
-
-        logger.debug("Camera intialized")
-        pass
-
-    @property
-    def status (self):
-        return (0, "Camera functioning properly")
-
-    def capture (self, 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')
-
-        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')
-
-        return ({"hi":img_hi,
-                 "lo":img_lo})
-
-#barometerdebug2 uses actual barometer
-class Barometer_Debug2 ():
-    def __init__(self):
-        logger.debug("Intializing barometer")
-        self.bmp = BMP085.BMP085()
-        logger.debug("Barometer intilized")
         pass
 
     @property
@@ -165,13 +189,15 @@ class Barometer_Debug2 ():
         alt = self.altitude
         press = self.pressure
         temp = self.temperature
-        result = {"altitude":alt,
+        result = {"a":alt,
-                "temperature":temp,
+                "t":temp,
-                "pressure":press,
+                "p":press,
                     }
-        logger.debug("Barometer reads {}".format(result))
+        logger.debug("Gps reads {}".format(result))
 
         return result
+# class Gps:
+
 
 
 

logging.ini

@@ -0,0 +1,52 @@
+[loggers]
+keys=root,datahandling,instruments
+
+[handlers]
+keys=consoleHandler, rootHandler, instrumentsHandler, datahandlingHandler
+
+[formatters]
+keys=myFormatter
+
+[logger_root]
+level=DEBUG
+handlers=consoleHandler, rootHandler
+
+[logger_datahandling]
+level=INFO
+handlers=datahandlingHandler
+qualname=datahandling
+
+[logger_instruments]
+level=INFO
+handlers=instrumentsHandler
+qualname=instruments
+
+[handler_consoleHandler]
+class=StreamHandler
+level=INFO
+formatter=myFormatter
+args=(sys.stdout,)
+
+[handler_fileHandler]
+class=FileHandler
+formatter=myFormatter
+args=("config.log",)
+
+[handler_rootHandler]
+class=FileHandler
+formatter=myFormatter
+args=("main_log.txt",)
+
+[handler_instrumentsHandler]
+class=FileHandler
+formatter=myFormatter
+args=("instruments_log.txt",)
+
+[handler_datahandlingHandler]
+class=FileHandler
+formatter=myFormatter
+args=("datahandling_log.txt",)
+
+[formatter_myFormatter]
+format=[%(asctime)-15s] [%(MISSION_TIME)-10s] %(MISSION_ID)-10s %(name)-25s %(levelname)-8s %(message)s
+datefmt=%Y-%m-%d %H:%M:%S

main.py

@@ -1,145 +1,174 @@
 __author__ = 'asc'
 DEBUG = True
 import logging
+import logging.handlers,logging.config
 
-if DEBUG:
+from instruments import Barometer, Camera
-    from instruments import Barometer_Debug2 as Barometer
+from datahandling import Datalogger, Datareporter
-    from instruments import Camera_Debug2 as Camera
+from system import System as System
-    from datahandling import Datalogger_Debug as Datalogger
+from threading import Timer
-    from datahandling import Datareporter_Debug3 as Datareporter
+from datahandling import Record
-    from system import System_Debug as System
+from mission import Mission
-    import threading
+import random
+import string
 
-    import datetime
+# class ContextFilter(logging.Filter):
+#     """
+#     This is a filter which injects contextual information into the log.
+#     """
+#     def filter(self, record):
+#         record.MYVAR = MYVAR
+#         return True
 
-import configparser
+logging.config.fileConfig('logging.ini')
-
-# 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
-
-log = logging.getLogger(__name__)
-log1 = logging.getLogger("instruments")
-log2 = logging.getLogger("datahandling")
-handler = logging.FileHandler('myapp.log')
-
-formatter = logging.Formatter('[%(asctime)-15s] %(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)
 
+log = logging.getLogger('root')
+log.addFilter(logging.Filter('root'))
+# log.addFilter(ContextFilter())
 #start-up
 #log denotes write to local, report denotes sending to server
 
-#TODO startup message
-
 #loadconfig
 from config import *
 
-notebook = Datalogger (text_path=None,
+mission = Mission()
-                     log_path=log_path,
-                     photo_path=photo_path)
-log.debug ("System started")
-# logger.log("Log Intiated")
-
-#system check
-system = System()
-
-log.debug (system.stats)
 
 #todo test cell connection
 reporter = Datareporter (
+    missiontime = mission,
     use_lan = True,
-    url = "http://home.ascorrea.com",
+    url = url,
     server_port = 5010,
-    data_path = "upload-data",
+    data_path = data_path,
-    image_path = "upload-file",
+    image_path = image_path,
-    ping_path = "ping",
+    ping_path = ping_path,
-    com_port_name="/dev/ttyAMA0",
+    com_port_name=com_port_name,
-    baud_rate = 9600)
+    baud_rate = baud_rate
+)
+
+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", extra={'MISSION_TIME': "", 'MISSION_ID':""})
+
+#system check
+system = System()
+log.debug (system.stats, extra={'MISSION_TIME': "", 'MISSION_ID':""})
+
+#set mission time
+
+log.info("Mission {} started, time zero is {}".format(mission.name, mission.timezero), extra={'MISSION_TIME': mission.now(), 'MISSION_ID':mission.name})
+
+
+#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,
+                 hflip=False,
-                 exposure_mode='sports'
+                 exposure_mode='sports',
+                 debug=True
                  )
 
-
 #todo test barometer
-barometer = Barometer()
+barometer = Barometer(debug=True)
 
 #todo test GPS, log, report
 
 #todo check for errors, throw exception if error
 
-def scheduler (interval, worker_func, iterations = 0):
+class scheduler ():
-  if iterations != 1:
-    threading.Timer (
-      interval,
-      scheduler, [interval, worker_func, 0 if iterations == 0 else iterations-1]
-    ).start ()
 
-  worker_func ()
+    def __init__(self, interval, function, *args, **kwargs):
+        self._timer     = None
+        self.interval   = interval
+        self.function   = function
+        self.args       = args
+        self.kwargs     = kwargs
+        self.is_running = False
+        self.start()
 
+    def _run(self):
+        self.is_running = False
+        self.start()
+        self.function(*self.args, **self.kwargs)
+
+    def start(self):
+        if not self.is_running:
+            self._timer = Timer(self.interval, self._run)
+            self._timer.start()
+            self.is_running = True
+
+    def stop(self):
+        self._timer.cancel()
+        self.is_running = False
 
 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')
+    log.info('Updating barometer...',extra={'MISSION_TIME': mission.now(), 'MISSION_ID':mission.name})
+    notebook.log(record)
 
 def update_image_local():
     global img
-    img = camera.capture()
+    img = camera.capture(name=mission.now())
-    notebook.log(img.get('hi'), message_type="image")
+    record = Record([img.get('hi'), img.get('lo')], 'i')
+    log.info('Updating image...', extra={'MISSION_TIME': mission.now(), 'MISSION_ID':mission.name})
+    notebook.log(record)
 
-
+def submit_report():
-scheduler(2, update_barometer_local)
-scheduler(5, update_image_local)
-
-counter=1
-while counter>0:
-    global img
     global bar
-    # bar=None
+    global img
-    # img=None
+    global counter
+    global transpondence
 
-    try:
+    # reporter.create_transpondence()
-        reporter.send(1, message_type="ping")
 
-        # if (counter % refresh_camera_local) == 0:
+    if not transpondence:
-        #     if not img:
+        log.info('Creating transpondence',extra={'MISSION_TIME': mission.now(), 'MISSION_ID':mission.name})
-        #         img = camera.capture()
+        transpondence = Record()
-        #     notebook.log(img.get('hi'), message_type="image")
 
     if (counter % refresh_barometer_transmit) == 0:
-            if not bar:
+        log.info('Adding barometer data to transpondence',extra={'MISSION_TIME': mission.now(), 'MISSION_ID':mission.name})
-                bar = barometer.read()
+        transpondence.add(bar,'b')
-            reporter.send(bar, message_type="data")
 
     if (counter % refresh_camera_transmit) == 0:
-            # log.debug('Need to transmit picture, {}'.format(img))
+        log.info('Adding image to transpondence',extra={'MISSION_TIME': mission.now(), 'MISSION_ID':mission.name})
-            if not img:
+        transpondence.add(img.get('lo'),'i')
-                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
 
+    log.info('Sending transpondence', extra={'MISSION_TIME': mission.now(), 'MISSION_ID':mission.name})
+    transpondence = reporter.send(transpondence) #returns none on success, (bad practice?)
     counter += 1
-    log.debug("Counter = {}".format(counter))
+    log.debug('Counter = {}'.format(counter), extra={'MISSION_TIME': mission.now(), 'MISSION_ID':mission.name})
+
+counter=1
+
+img = None
+bar = None
+transpondence = None
+
+scheduler(1, update_barometer_local)
+scheduler(refresh_camera_local, update_image_local)
+scheduler(2, submit_report)
+
+
+
 
 pass

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 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

system.py

@@ -3,7 +3,7 @@ import os
 import psutil
 
 
-class System_Debug():
+class System():
 
     def __init__(self):
      #TODO add system initialization

test.py

@@ -1,62 +1,110 @@
-import csv, requests
+__author__ = 'asc'
-from instruments import Camera_Debug2 as Camera
+DEBUG = True
-from datahandling import Datareporter_Debug3 as Datareporter
-from system import System_Debug
-import serial
-import sys
 import logging
-import base64
+import logging.handlers,logging.config
-from requests_toolbelt import MultipartEncoder
 
-logging.getLogger("datahandling")
+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
 
-data = {"temp":1,"press":3,"altitude":2,"cheetas":"just enough"}
+logging.config.fileConfig('logging.ini')
 
-pass
+log = logging.getLogger(__name__)
+# log = logging.basicConfig()
+# log1 = logging.getLogger("instruments")
+# log2 = logging.getLogger("datahandling")
+# handler = logging.handlers.RotatingFileHandler('spaceballoon.log', backupCount=5)
 
-com_port_name = "/dev/ttyAMA0"
+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)
 
-image = open("resized_image.jpg", 'rb')
+#start-up
-# image = image.read()
+#log denotes write to local, report denotes sending to server
 
-# e=base64.b64encode(image)
+#loadconfig
+from config import *
 
-# e=b'alksdjnfkljanslkjnaklsfnglkanlkfgnlakalksdjnaklsfnglkajnaklsfnglkanlkfgnlakalksdjnfkljanslkjnglkjnaklsfnglkanlkfgnlakalksdjnfkljanslkjnglknlkfgnlakalksdjnfkljanslkjnglkanlkfgnlakalksdjnfkljanngnlakalksdjnfkljanslkjnglkanlkfgnlakalksdjnfkljannlkanlkfgnlakalksdjnfkljannglkanlkfgnlakalksdjnfkljannglkanlkfgnlakalksdjnfkl=='
+mission = Mission()
 
-# m = MultipartEncoder(fields={'image': ('image', image, 'image/jpeg')})
+#todo test cell connection
-
+reporter = Datareporter (
-report = Datareporter (
+    missiontime = mission,
     use_lan = True,
-    url = "http://home.ascorrea.com",
+    url = "http://10.0.1.4",
     server_port = 5010,
     data_path = "upload-data",
-    image_path = "upload-file",
+    image_path = "missions",
+    ping_path = "ping",
     com_port_name="/dev/ttyAMA0",
-    ping_path="ping",
+    baud_rate = 9600
-    baud_rate = 9600)
+)
 
-camera = Camera (low_quality_compression_pct=10,
+#intiate mission
-                 low_quality_resolution=(320, 240),
+
-                 high_quality_compression_pct=100,
+
-                 high_quality_resolution=(2592,1944),
+#TODO test camera
-                 vflip=True,
+camera = Camera (low_quality_compression_pct=low_quality_compression_pct,
-                 hflip=True,
+                 low_quality_resolution=low_quality_resolution,
-                 exposure_mode='sports'
+                 high_quality_compression_pct=high_quality_compression_pct,
+                 high_quality_resolution=high_quality_resolution,
+                 vflip=False,
+                 hflip=False,
+                 exposure_mode='sports',
+                 # debug=True
                  )
 
-# print (report.check())
+#todo test barometer
-# print (image)
+barometer = Barometer()
-# report.send(m.to_string(), message_type="image")
-# report.send(data, message_type="data")
 
-img = camera.capture()
+#todo test GPS, log, report
-report.send(img.get('lo'), message_type="image")
 
-# report.send(image, message_type="image")
+#todo check for errors, throw exception if error
+
+def scheduler (interval, worker_func, iterations = 0):
+  if iterations != 1:
+    threading.Timer (
+      interval,
+      scheduler, [interval, worker_func, 0 if iterations == 0 else iterations-1]
+    ).start ()
+
+  worker_func ()
 
 
-# execfile("test_sms.py")
+def update_barometer_local():
+    global bar
+    bar = barometer.read()
+    bar.update({'mt':mission.now()})
+    record = Record(bar.copy(),'b')
+    # notebook.log(record)
 
-# report.send("1",message_type="ping")
+def update_image_local():
+    global img
+    img = camera.capture(name=mission.now(), thumbnail=None)
+    record = Record([img.get('hi'), img.get('lo')], 'i')
+    # notebook.log(record)
+
+transpondence = Record()
+
+update_image_local()
+
+transpondence.add(img.get('lo'),'i')
+transpondence = reporter.send(transpondence) #returns none on success, (bad practice?)
+
+counter=1
+
+img = None
+bar = None
+transpondence = None
 
 pass