Example #1
0
 def __init__( self, urlData):
 #Initialization of the goodweData class. All data members are set
 #to default values. Then the urlData is filtered and parsed
    try:
       self.m_sample = goodweSample.goodweSample()
    except Exception, ex: 
       print "Error:" +str(ex)
Example #2
0
 def read_sample_data(self):
     '''Read a data sample.'''
     if self.m_worker and self.m_worker.is_online():
         print "Worker is online"
         sample = self.m_worker.get_current_value()
         for subscriber in self.subscribers:
             subscriber(sample.get_temperature())
         return sample
     else:
         return goodweSample.goodweSample()
Example #3
0
 def read_sample_data( self):
    '''Read a data sample.'''
    if self.m_worker and self.m_worker.is_online():
       print "Worker is online"
       sample = self.m_worker.get_current_value()
       for subscriber in self.subscribers:
          subscriber( sample.get_temperature())
       return sample
    else:
       return goodweSample.goodweSample()
Example #4
0
    def __init__(self, usb_pin, emulated, usb_id):
        '''Initialisation of the goodweUsb class. All data members are set
         to default values. '''
        self.m_sample = goodweSample.goodweSample()
        self.m_state = State.OFFLINE
        self.m_serialNumber = ""
        self.m_serialBuffer = ''
        self.m_inverter_adr = 0x11
        self.m_inverter_adr_confirmed = False
        self.m_deviceId = usb_id
        self.m_dev = None
        self.m_epi = None
        self.m_initialized = False
        self.m_emulated = "test" in emulated
        try:
            self.m_relay = gpio.usb_relay(usb_pin)
        except:
            exit(-1)

        self.cc_reg_switch = {
            FC.offline: self._skip_reg_message,
            FC.regreq: self._reg_received_registration,
            FC.allocreg: self._skip_reg_message,
            FC.addconf: self._reg_received_confirm_registration,
            FC.remreg: self._skip_reg_message,
            FC.remconf: self._reg_received_confirm_removal
        }

        self.cc_read_switch = {
            FC.query: self._skip_read_message,
            FC.result: self._read_received_message,
            FC.query_id: self._skip_read_message,
            FC.result_id: self._skip_read_message,
            FC.query_stt: self._skip_read_message,
            FC.result_stt: self._skip_read_message
        }

        self.state_switch = {
            State.OFFLINE: self._offline,
            State.CONNECTED: self._remove_registration,
            State.DISCOVER: self._discover_goodwe,
            State.ALLOC: self._alloc_register,
            State.ALLOC_CONF: self._read_data_goodwe,
            State.ALLOC_ASK: self._read_data_init,
            State.RUNNING: self._read_data
        }
Example #5
0
    def __init__(self, threadId, name, comms, interval):
        threading.Thread.__init__(self)
        self.m_threadId = threadId
        self.m_name = name
        self.m_sample_interval = interval
        self.m_stop = False
        self.m_comms = comms
        print "Set current sample in USB worker"
        try:
            self.m_current_value = self.m_comms.get_sample()
            print self.m_current_value.to_string()
            self.m_readError = False
        except:
            self.m_current_value = goodweSample.goodweSample()
            self.m_readError = True

        self.m_lock = threading.Lock()
        print "Init USB thread worker at " + str(interval) + " Hz."
Example #6
0
 def __init__(self, threadId, name, comms, interval):
    threading.Thread.__init__(self)
    self.m_threadId = threadId
    self.m_name = name
    self.m_sample_interval = interval
    self.m_stop = False
    self.m_comms = comms
    print "Set current sample in USB worker"
    try:
       self.m_current_value = self.m_comms.get_sample()
       print self.m_current_value.to_string()
       self.m_readError = False
    except:
       self.m_current_value = goodweSample.goodweSample()
       self.m_readError = True
       
    self.m_lock = threading.Lock()
    print "Init USB thread worker at " + str(interval) + " Hz."
Example #7
0
    def __init__(self, url, device, baudrate):
        '''Initialisation of the goodweRS485 class. All data members are set
         to default values. '''
        self.m_sample = goodweSample.goodweSample()
        self.m_state = State.OFFLINE
        self.m_serialNumber = ""
        self.m_serialBuffer = ''
        self.m_inverter_adr = 0x11
        self.m_inverter_adr_confirmed = False
        self.m_serial = None
        self.m_initialized = False
        self.m_emulated = "test" in url
        self.m_baudrate = baudrate
        self.m_device = device

        self.cc_reg_switch = {
            FC.offline: self._skip_message,
            FC.regreq: self._reg_received_registration,
            FC.allocreg: self._skip_message,
            FC.addconf: self._reg_received_confirm_registration,
            FC.remreg: self._skip_message,
            FC.remconf: self._reg_received_confirm_removal
        }

        self.cc_read_switch = {
            FC.query: self._skip_message,
            FC.result: self._read_received_message,
            FC.query_id: self._skip_message,
            FC.result_id: self._skip_message,
            FC.query_stt: self._skip_message,
            FC.result_stt: self._skip_message
        }

        self.state_switch = {
            State.OFFLINE: self.initialize,
            State.CONNECTED: self._remove_registration,
            State.DISCOVER: self._discover_goodwe,
            State.ALLOC: self._alloc_register,
            State.ALLOC_CONF: self._read_data_goodwe,
            State.ALLOC_ASK: self._read_data_init,
            State.RUNNING: self._read_data
        }
Example #8
0
   def __init__(self, usb_pin, emulated, usb_id):
      '''Initialisation of the goodweUsb class. All data members are set
         to default values. '''
      self.m_sample = goodweSample.goodweSample()
      self.m_state = State.OFFLINE
      self.m_serialNumber = ""
      self.m_serialBuffer = ''
      self.m_inverter_adr = 0x11
      self.m_inverter_adr_confirmed = False
      self.m_deviceId = usb_id
      self.m_dev = None
      self.m_epi = None
      self.m_initialized = False
      self.m_emulated = "test" in emulated
      try:
         self.m_relay = gpio.usb_relay( usb_pin)
      except:
         exit(-1)
         
      self.cc_reg_switch  = {FC.offline:      self._skip_reg_message,
                             FC.regreq:       self._reg_received_registration,
                             FC.allocreg:     self._skip_reg_message,
                             FC.addconf:      self._reg_received_confirm_registration,
                             FC.remreg:       self._skip_reg_message,
                             FC.remconf:      self._reg_received_confirm_removal}

      self.cc_read_switch = {FC.query:        self._skip_read_message,
                             FC.result:       self._read_received_message,
                             FC.query_id:     self._skip_read_message,
                             FC.result_id:    self._skip_read_message,
                             FC.query_stt:    self._skip_read_message,
                             FC.result_stt:   self._skip_read_message}

      self.state_switch = { State.OFFLINE:    self._offline,
                            State.CONNECTED:  self._remove_registration,
                            State.DISCOVER:   self._discover_goodwe,
                            State.ALLOC:      self._alloc_register,
                            State.ALLOC_CONF: self._read_data_goodwe,
                            State.ALLOC_ASK:  self._read_data_init,
                            State.RUNNING:    self._read_data }
Example #9
0
   def __init__(self, url, device, baudrate):
      '''Initialisation of the goodweRS485 class. All data members are set
         to default values. '''
      self.m_sample = goodweSample.goodweSample()
      self.m_state = State.OFFLINE
      self.m_serialNumber = ""
      self.m_serialBuffer = ''
      self.m_inverter_adr = 0x11
      self.m_inverter_adr_confirmed = False
      self.m_serial = None
      self.m_initialized = False
      self.m_emulated = "test" in url
      self.m_baudrate = baudrate
      self.m_device = device


      self.cc_reg_switch  = {FC.offline:      self._skip_message,
                             FC.regreq:       self._reg_received_registration,
                             FC.allocreg:     self._skip_message,
                             FC.addconf:      self._reg_received_confirm_registration,
                             FC.remreg:       self._skip_message,
                             FC.remconf:      self._reg_received_confirm_removal}

      self.cc_read_switch = {FC.query:        self._skip_message,
                             FC.result:       self._read_received_message,
                             FC.query_id:     self._skip_message,
                             FC.result_id:    self._skip_message,
                             FC.query_stt:    self._skip_message,
                             FC.result_stt:   self._skip_message}

      self.state_switch = { State.OFFLINE:    self.initialize,
                            State.CONNECTED:  self._remove_registration,
                            State.DISCOVER:   self._discover_goodwe,
                            State.ALLOC:      self._alloc_register,
                            State.ALLOC_CONF: self._read_data_goodwe,
                            State.ALLOC_ASK:  self._read_data_init,
                            State.RUNNING:    self._read_data }
 def __init__(self, urlData):
     #Initialization of the goodweSample data object. All data members are set
     #to default values.
     self.m_sample = goodweSample.goodweSample()
     # Parse and filter the urlData. This can throw an IOError or EOFError.
     self.parse_data(urlData)