commit 11/12/2015

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

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,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, 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))
+                    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)
+class Datareporter():
-            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 ():
     #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):
+    def _send_data(self, message, _intiating_report=False):
-        # logger.debug("Message.read is {}".format(message.read()))
+        response=None
-        if message_type == "ping":
+        m = MultipartEncoder(fields=message)
-            #TODO send text
-            contentType='text/xml'
 
-            if self.use_lan:
+        if _intiating_report:
-                req = request.Request("{0}:{1}/{2}".format(self.url, self.server_port, self.ping_path))
+            path = '{0}'.format(self.image_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))
         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
+
+
+
+
+
+
+
+
 
 

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 ():
+class Camera:
-    def __init__(self):
+    def __init__(self,
-        pass
+                 low_quality_resolution=(320,240),
-
-    @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),
                  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)
+        self._debug = debug
-        # if "vflip" in kwargs.keys():
+        if self._debug == False:
-        for k in kwargs.keys():
+            import picamera
-            setattr(self._cam, k, kwargs.get(k))
+            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:
+        r = {}
-            logger.debug('Taking high quality photo')
+        if not self._debug:
-            self._cam.capture("temp_img_hi.jpg",
+            if not no_high_quality:
-                              resize=self.high_quality_resolution,
+                logger.debug('Taking high quality photo')
-                              quality=self.high_quality_compression_pct,
+                self._cam.capture("temp_img_hi.jpg",
-                              # **kwargs
+                                  resize=self.high_quality_resolution,
-                              )
+                                  quality=self.high_quality_compression_pct,
-            img_hi = open("temp_img_hi.jpg", 'rb')
+                                  # **kwargs
-            with open("temp_img_hi.jpg", 'rb') as f:
+                                  )
-                img_hi = f.read()
+                with open("temp_img_hi.jpg", 'rb') as f:
-            logger.debug('High quality photo taken')
+                    # 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:
+            if not no_low_quality:
-            time.sleep(1)
+                time.sleep(1)
-            logger.debug('Taking low quality photo (Resolution: {}, JPEG Quality: {}%)'.format(self.low_quality_resolution, self.low_quality_compression_pct))
+                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",
+                self._cam.capture("temp_img_lo.jpg",
-                              resize=self.low_quality_resolution,
+                                  resize=self.low_quality_resolution,
-                              quality=self.low_quality_compression_pct,
+                                  quality=self.low_quality_compression_pct,
-                              # **kwargs
+                                  # **kwargs
-                              )
+                                  )
-            with open("temp_img_lo.jpg", 'rb') as f:
+                with open("temp_img_lo.jpg", 'rb') as f:
-                img_lo = f.read()
+                    img_lo = str(base64.b64encode(f.read()),'ascii')
-            logger.debug('Low quality photo taken')
+                    # 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,
+            if not no_low_quality:
-                 "lo":img_lo})
+                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
+        return r
-class Barometer_Debug2 ():
+
+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,
+        result = {"a":alt,
-                "temperature":temp,
+                "t":temp,
-                "pressure":press,
+                "p":press,
                     }
         logger.debug("Barometer reads {}".format(result))
 
         return result
 
+# class Gps:
+
+
 
 
 

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=

main.py

@@ -1,80 +1,94 @@
 __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
+import threading
-    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
+logging.config.fileConfig('logging.ini')
-
-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
 
 log = logging.getLogger(__name__)
-log1 = logging.getLogger("instruments")
+# log = logging.basicConfig()
-log2 = logging.getLogger("datahandling")
+# log1 = logging.getLogger("instruments")
-handler = logging.FileHandler('myapp.log')
+# log2 = logging.getLogger("datahandling")
+# handler = logging.handlers.RotatingFileHandler('spaceballoon.log', backupCount=5)
 
-formatter = logging.Formatter('[%(asctime)-15s] %(name)-15s %(levelname)-8s %(message)s')
+formatter = logging.Formatter('[%(asctime)-25s] %(name)-15s %(levelname)-8s %(message)s')
-handler.setFormatter(formatter)
+# handler.setFormatter(formatter)
-log.addHandler(handler)
+# log.addHandler(handler)
-log1.addHandler(handler)
+# log1.addHandler(handler)
-log2.addHandler(handler)
+# log2.addHandler(handler)
 log.setLevel(logging.DEBUG)
-log1.setLevel(logging.DEBUG)
+# log1.setLevel(logging.DEBUG)
-log2.setLevel(logging.INFO)
+# 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,
+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 (
-    use_lan = True,
+    missiontime = mission,
-    url = "http://home.ascorrea.com",
+    use_lan = False,
-    server_port = 5010,
+    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()
+    img = camera.capture(name=mission.now())
-    notebook.log(img.get('hi'), message_type="image")
+    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)
+    # reporter.create_transpondence()
-scheduler(5, update_image_local)
+
+    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:
+img = None
-        reporter.send(1, message_type="ping")
+bar = None
+transpondence = None
 
-        # if (counter % refresh_camera_local) == 0:
+scheduler(1, update_barometer_local)
-        #     if not img:
+scheduler(refresh_camera_local, update_image_local)
-        #         img = camera.capture()
+scheduler(2, submit_report)
-        #     notebook.log(img.get('hi'), message_type="image")
 
-        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

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

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,14 +1,17 @@
 import csv, requests
-from instruments import Camera_Debug2 as Camera
+from instruments import Camera
-from datahandling import Datareporter_Debug3 as Datareporter
+from datahandling import Datareporter
-from system import System_Debug
+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,
+# camera = Camera (low_quality_compression_pct=10,
-                 low_quality_resolution=(320, 240),
+#                  low_quality_resolution=(320, 240),
-                 high_quality_compression_pct=100,
+#                  high_quality_compression_pct=100,
-                 high_quality_resolution=(2592,1944),
+#                  high_quality_resolution=(2592,1944),
-                 vflip=True,
+#                  vflip=True,
-                 hflip=True,
+#                  hflip=True,
-                 exposure_mode='sports'
+#                  # 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()
+# img = camera.capture()
-report.send(img.get('lo'), message_type="image")
+# report.send(img.get('lo'), message_type="image")
 
 # report.send(image, message_type="image")
 
 
 # execfile("test_sms.py")
-
+for i in range(1,10):
-# report.send("1",message_type="ping")
+    print (i)
+    report.send(image,message_type="image")
+    sleep(1)
 
 pass