def _get_printer_details(self): communicator = UsbPacketCommunicator(self.usb_queue_length) communicator.register_handler(IAmMessage, self._ident_call_back) communicator.start() communicator.send(IdentifyMessage()) until = time.time() + 5.0 while (not self.printer_details and time.time() < until): time.sleep(0.1) communicator.close() details = self.printer_details self.printer_details = None return details
def _get_printer_details(self): communicator = UsbPacketCommunicator(self.usb_queue_length) communicator.register_handler(IAmMessage, self._ident_call_back) communicator.start() communicator.send(IdentifyMessage()) until = time.time() + 5.0 while (not self.printer_details and time.time() < until): time.sleep(0.1) communicator.close() if not self.printer_details: raise MissingPrinterException() details = self.printer_details self.printer_details = None logger.info("Loaded printer \n{}".format(str(details.sn))) return details
def prepare(self): usb_communicator = UsbPacketCommunicator(50) usb_communicator.start() usb_communicator.send(EnterBootloaderMessage()) time.sleep(0.1) #need to wait for usb usb_communicator.close()
class UsbTestTerminal(object): VREF_CAL_POS = 0 TEMP30_CAL_POS = 1 TEMP110_CAL_POS = 2 ADC_KEY_POS = 3 ADC_PA3_POS = 4 ADC_TEMP_POS = 5 ADC_VREF_POS = 6 def __init__(self, verbose=False): self._verbose = verbose self._drips = 0 self._serial = None self._swrev = None self._hwrev = None self._adcNum = [] self._adcVal = [] self._dataRate = None self._adcCals = [] self._move = [0, 0, 0] self._usb = UsbPacketCommunicator(10) self._usb.register_handler(IAmMessage, self.iAmHandler) self._usb.register_handler(DripRecordedMessage, self.dripHandler) self._usb.register_handler(ReturnAdcValMessage, self.adcHandler) self._usb.start() if verbose: print "Started usb terminal" time.sleep(0.1) def usbClose(self): self._usb.close() def laserOff(self): move = self._move self._usb.send(MoveMessage(move[0], move[1], 0)) def laserOn(self): move = self._move self._usb.send(MoveMessage(move[0], move[1], 255)) def move(self, x, y, laserPower=0): self._move = [x, y, laserPower] self._usb.send(MoveMessage(x, y, laserPower)) def setDrips(self, dripCount=0): self._usb.send(SetDripCountMessage(dripCount)) def identify(self): self._usb.send(IdentifyMessage()) def enterBootloader(self, i_am_sure=None): if i_am_sure == (0xDEADBEEF): self._usb.send(EnterBootloaderMessage()) if (self._verbose): print "Bootloadereded" elif (self._verbose): print "i_am_sure not loaded with the correct value" print "Note: This may lock your peachy into the bootloader" print " if you have old firmware on your board" #A non-ideal push/pop queue interface. #Doesn't account for mis-matching - May be worth clearing on each request? def popAdc(self, timeout=0.1): start = time.time() timeout = start + timeout #in seconds while (time.time() < timeout): #wait for data being available or if (len(self._adcVal) != 0): tmp = [self._adcNum[0], self._adcVal[0]] del self._adcNum[0] del self._adcVal[0] return tmp else: time.sleep(0.01) def clearAdcQueues(self): self._adcNum = [] self._adcVal = [] def getAdcCalibrations(self): if len(self._adcCals) != 3: [adcNum, adcVrefCal] = self.getAdcVal(self.VREF_CAL_POS) [adcNum, adcTemp30] = self.getAdcVal(self.TEMP30_CAL_POS) [adcNum, adcTemp110] = self.getAdcVal(self.TEMP110_CAL_POS) self._adcCals = [adcVrefCal, adcTemp30, adcTemp110] def getTemperature(self): self.getAdcCalibrations() #Return actual Temperature in C #Formulas taken from STM32F0 datasheet page 252 adcVrefCal = self._adcCals[self.VREF_CAL_POS] adcTemp30 = self._adcCals[self.TEMP30_CAL_POS] adcTemp110 = self._adcCals[self.TEMP110_CAL_POS] #Get the current Vref and Temperature each time [adcNum, adcTemperature] = self.getAdcVal(self.ADC_TEMP_POS) [adcNum, adcVref] = self.getAdcVal(self.ADC_VREF_POS) vrefCompensation = 1.0 * adcVrefCal / adcVref temperature = adcTemperature * vrefCompensation - adcTemp30 temperature = temperature * (110 - 30) / (adcTemp110 - adcTemp30) temperature = temperature + 30 if (self._verbose): print('Temperatures Value={0} Celcius={1}'.format( adcTemperature, temperature)) return temperature def getSupplyVoltage(self): self.getAdcCalibrations() adcVrefCal = self._adcCals[self.VREF_CAL_POS] [adcNum, adcVref] = self.getAdcVal(self.ADC_VREF_POS) vrefCompensation = 1.0 * adcVrefCal / adcVref #calibrated at 3.3V always supplyVoltage = 3.3 * vrefCompensation if (self._verbose): print('Voltage {0}, Value {1}'.format(supplyVoltage, adcVref)) return supplyVoltage def getAdcKeyVal(self): return self.getAdcVal(self.ADC_KEY_POS) def getAdcVal(self, adcNum): '''ADC NUMBERS: 0 - Vref Calibration Factor 1 - 30C temperature calibration 2 - 110C temperature calibration 3 - ADC key (PA2) 4 - Pin (PA3) 5 - Temperature 6 - Vref (3.3V volts) ''' self._adcNum.append(adcNum) self._usb.send(GetAdcValMessage(adcNum)) if self._verbose: print('adcNum: {0}'.format(adcNum)) return self.popAdc() def adcHandler(self, message): if (len(self._adcNum) > len(self._adcVal)): self._adcVal.append(message.adcVal) if self._verbose: print('adcNum: {0} adcVal: {1}'.format(self._adcNum[-1], self._adcVal[-1])) else: self.clearAdcQueues() def dripHandler(self, message): self._drips = message.drips if self._verbose: print('Recieved drip: {0}'.format(message.drips)) def iAmHandler(self, message): self._serial = message.sn self._swrev = message.swrev self._hwrev = message.hwrev self._dataRate = message.dataRate if self._verbose: print('Serial number: {0}'.format(message.sn)) print('SW rev number: {0}'.format(message.swrev)) print('HW rev number: {0}'.format(message.hwrev)) print('Data Rate: {0}'.format(message.dataRate))
class DripperSetupMixIn(object): '''This is a Mixin for the ConfigurationAPI and exists only for organizational purposes''' def get_dripper_drips_per_mm(self): '''Returns Drips Per mm''' return self._current_config.dripper.drips_per_mm def get_dripper_type(self): '''Returns the configured Dripper Type''' return self._current_config.dripper.dripper_type def get_dripper_emulated_drips_per_second(self): '''Gets the drips per second to be emulated''' return self._current_config.dripper.emulated_drips_per_second def get_dripper_photo_zaxis_delay(self): '''Gets the photo delay in seconds''' return self._current_config.dripper.photo_zaxis_delay def set_dripper_drips_per_mm(self, drips): '''Sets Drips Per mm''' self._current_config.dripper.drips_per_mm = drips if self._drip_detector: self._drip_detector.set_drips_per_mm(drips) self.save() def set_dripper_type(self, value): '''Sets the configured Dripper Type''' self._current_config.dripper.dripper_type = value self.save() def set_dripper_emulated_drips_per_second(self, value): '''Sets the drips per second to be emulated''' self._current_config.dripper.emulated_drips_per_second = value self.save() def set_dripper_photo_zaxis_delay(self, value): '''Sets the photo delay in seconds''' self._current_config.dripper.photo_zaxis_delay = value self.save() def reset_drips(self): '''Sets the drip count back to 0''' self._drip_detector.reset() def start_counting_drips(self, drip_call_back=None): '''Turns on the counting of drips. Stop must be called to end this.''' self.drip_call_back = drip_call_back if self._current_config.serial.on: self._commander = SerialCommander(self._current_config.serial.port) self._change_dripper() def _change_dripper(self): self._stop_current_dripper() if self._current_config.dripper.dripper_type == 'emulated': pass elif self._current_config.dripper.dripper_type == 'photo': pass elif self._current_config.dripper.dripper_type == 'microcontroller': self._communicator = UsbPacketCommunicator(self._current_config.circut.calibration_queue_length) self._communicator.start() self._drip_detector = SerialDripZAxis(self._communicator, 1, 0.0, drip_call_back=self.drip_call_back) def _stop_current_dripper(self): if self._communicator: self._communicator.close() if self._drip_detector: self._drip_detector.close() self._drip_detector = None def stop_counting_drips(self): '''Turns off the counting of drips if counting''' if self._commander: self._commander.close() self._stop_current_dripper() def send_dripper_on_command(self): '''If serial commuinication is enabled this send the turn on drips command''' if self._commander: self._commander.send_command(self._current_config.serial.on_command) else: raise Exception("Serial not Started") def send_dripper_off_command(self): '''If serial commuinication is enabled this send the turn off drips command''' if self._commander: self._commander.send_command(self._current_config.serial.off_command) else: raise Exception("Serial not Started")
class UsbTestTerminal(object): VREF_CAL_POS = 0 TEMP30_CAL_POS = 1 TEMP110_CAL_POS = 2 ADC_KEY_POS = 3 ADC_PA3_POS = 4 ADC_TEMP_POS = 5 ADC_VREF_POS = 6 def __init__(self,verbose=False): self._verbose=verbose self._drips=0 self._serial=None self._swrev=None self._hwrev=None self._adcNum=[] self._adcVal=[] self._dataRate=None self._adcCals=[] self._move=[0,0,0] self._usb = UsbPacketCommunicator(10) self._usb.register_handler(IAmMessage, self.iAmHandler) self._usb.register_handler(DripRecordedMessage, self.dripHandler) self._usb.register_handler(ReturnAdcValMessage, self.adcHandler) self._usb.start() if verbose: print "Started usb terminal" time.sleep(0.1) def usbClose(self): self._usb.close() def laserOff(self): move=self._move self._usb.send(MoveMessage(move[0],move[1],0)) def laserOn(self): move=self._move self._usb.send(MoveMessage(move[0],move[1],255)) def move(self,x,y,laserPower=0): self._move=[x,y,laserPower] self._usb.send(MoveMessage(x,y,laserPower)) def setDrips(self,dripCount=0): self._usb.send(SetDripCountMessage(dripCount)) def identify(self): self._usb.send(IdentifyMessage()) def enterBootloader(self,i_am_sure=None): if i_am_sure==(0xDEADBEEF): self._usb.send(EnterBootloaderMessage()) if (self._verbose): print "Bootloadereded" elif (self._verbose): print "i_am_sure not loaded with the correct value" print "Note: This may lock your peachy into the bootloader" print " if you have old firmware on your board" #A non-ideal push/pop queue interface. #Doesn't account for mis-matching - May be worth clearing on each request? def popAdc(self,timeout=0.1): start=time.time() timeout=start+timeout #in seconds while(time.time()<timeout): #wait for data being available or if (len(self._adcVal) != 0): tmp=[self._adcNum[0],self._adcVal[0]] del self._adcNum[0] del self._adcVal[0] return tmp else: time.sleep(0.01) def clearAdcQueues(self): self._adcNum=[] self._adcVal=[] def getAdcCalibrations(self): if len(self._adcCals)!=3: [adcNum,adcVrefCal] = self.getAdcVal(self.VREF_CAL_POS) [adcNum,adcTemp30] = self.getAdcVal(self.TEMP30_CAL_POS) [adcNum,adcTemp110] = self.getAdcVal(self.TEMP110_CAL_POS) self._adcCals = [adcVrefCal,adcTemp30,adcTemp110] def getTemperature(self): self.getAdcCalibrations() #Return actual Temperature in C #Formulas taken from STM32F0 datasheet page 252 adcVrefCal = self._adcCals[self.VREF_CAL_POS] adcTemp30 = self._adcCals[self.TEMP30_CAL_POS] adcTemp110 = self._adcCals[self.TEMP110_CAL_POS] #Get the current Vref and Temperature each time [adcNum,adcTemperature]=self.getAdcVal(self.ADC_TEMP_POS) [adcNum,adcVref]=self.getAdcVal(self.ADC_VREF_POS) vrefCompensation = 1.0*adcVrefCal/adcVref temperature = adcTemperature*vrefCompensation-adcTemp30 temperature = temperature*(110-30)/(adcTemp110-adcTemp30) temperature = temperature + 30 if (self._verbose): print ('Temperatures Value={0} Celcius={1}'.format(adcTemperature,temperature)) return temperature def getSupplyVoltage(self): self.getAdcCalibrations() adcVrefCal=self._adcCals[self.VREF_CAL_POS] [adcNum,adcVref]=self.getAdcVal(self.ADC_VREF_POS) vrefCompensation = 1.0*adcVrefCal/adcVref #calibrated at 3.3V always supplyVoltage = 3.3*vrefCompensation if (self._verbose): print ('Voltage {0}, Value {1}'.format(supplyVoltage,adcVref)) return supplyVoltage def getAdcKeyVal(self): return self.getAdcVal(self.ADC_KEY_POS) def getAdcVal(self,adcNum): '''ADC NUMBERS: 0 - Vref Calibration Factor 1 - 30C temperature calibration 2 - 110C temperature calibration 3 - ADC key (PA2) 4 - Pin (PA3) 5 - Temperature 6 - Vref (3.3V volts) ''' self._adcNum.append(adcNum) self._usb.send(GetAdcValMessage(adcNum)) if self._verbose: print('adcNum: {0}'.format(adcNum)) return self.popAdc() def adcHandler(self,message): if (len(self._adcNum) > len(self._adcVal)): self._adcVal.append(message.adcVal) if self._verbose: print('adcNum: {0} adcVal: {1}'.format(self._adcNum[-1], self._adcVal[-1])) else: self.clearAdcQueues() def dripHandler(self, message): self._drips=message.drips if self._verbose: print('Recieved drip: {0}'.format(message.drips)) def iAmHandler(self, message): self._serial=message.sn self._swrev=message.swrev self._hwrev=message.hwrev self._dataRate=message.dataRate if self._verbose: print('Serial number: {0}'.format(message.sn)) print('SW rev number: {0}'.format(message.swrev)) print('HW rev number: {0}'.format(message.hwrev)) print('Data Rate: {0}'.format(message.dataRate))
class DripperSetupMixIn(object): '''Depricated use get_dripper_drips_per_mm''' def get_drips_per_mm(self): logging.warning("Depricated use get_dripper_drips_per_mm") return self.get_dripper_drips_per_mm() '''Returns Drips Per mm''' def get_dripper_drips_per_mm(self): return self._current_config.dripper.drips_per_mm '''Returns the configured Dripper Type''' def get_dripper_type(self): return self._current_config.dripper.dripper_type '''Depricated use get_dripper_emulated_drips_per_second''' def get_emulated_drips_per_second(self): logging.warning("Depricated use get_dripper_emulated_drips_per_second") return self.get_dripper_emulated_drips_per_second() '''Gets the drips per second to be emulated''' def get_dripper_emulated_drips_per_second(self): return self._current_config.dripper.emulated_drips_per_second '''Depricated use get_dripper_photo_zaxis_delay''' def get_photo_zaxis_delay(self): logging.warning("Depricated use get_dripper_photo_zaxis_delay") return self.get_dripper_photo_zaxis_delay() '''Gets the photo delay in seconds''' def get_dripper_photo_zaxis_delay(self): return self._current_config.dripper.photo_zaxis_delay '''Depricated use set_dripper_drips_per_mm''' def set_drips_per_mm(self, drips): logging.warning("Depricated use set_dripper_drips_per_mm") self.set_dripper_drips_per_mm(drips) '''Sets Drips Per mm''' def set_dripper_drips_per_mm(self, drips): self._current_config.dripper.drips_per_mm = drips if self._drip_detector: self._drip_detector.set_drips_per_mm(drips) self.save() '''Sets the configured Dripper Type''' def set_dripper_type(self, value): self._current_config.dripper.dripper_type = value self.save() '''Depricated use set_dripper_emulated_drips_per_second''' def set_emulated_drips_per_second(self, value): logging.warning("Depricated use set_dripper_emulated_drips_per_second") self.set_dripper_emulated_drips_per_second(value) '''Sets the drips per second to be emulated''' def set_dripper_emulated_drips_per_second(self, value): self._current_config.dripper.emulated_drips_per_second = value self.save() '''Depricated use set_dripper_photo_zaxis_delay''' def set_photo_zaxis_delay(self, value): logging.warning("Depricated use set_dripper_photo_zaxis_delay") self.set_dripper_photo_zaxis_delay(value) '''Sets the photo delay in seconds''' def set_dripper_photo_zaxis_delay(self, value): self._current_config.dripper.photo_zaxis_delay = value self.save() '''Sets the drip count back to 0''' def reset_drips(self): self._drip_detector.reset() '''Turns on the counting of drips. Stop must be called to end this.''' def start_counting_drips(self, drip_call_back=None): self.drip_call_back = drip_call_back if self._current_config.serial.on: self._commander = SerialCommander(self._current_config.serial.port) self._change_dripper() def _change_dripper(self): self._stop_current_dripper() if self._current_config.dripper.dripper_type == 'emulated': pass elif self._current_config.dripper.dripper_type == 'photo': pass elif self._current_config.dripper.dripper_type == 'microcontroller': self._communicator = UsbPacketCommunicator(self._current_config.circut.calibration_queue_length) self._communicator.start() self._drip_detector = SerialDripZAxis(self._communicator, 1, 0.0, drip_call_back=self.drip_call_back) def _stop_current_dripper(self): if self._communicator: self._communicator.close() if self._drip_detector: self._drip_detector.close() self._drip_detector = None '''Turns off the counting of drips if counting''' def stop_counting_drips(self): if self._commander: self._commander.close() self._stop_current_dripper() def send_dripper_on_command(self): if self._commander: self._commander.send_command(self._current_config.serial.on_command) else: raise Exception("Serial not Started") def send_dripper_off_command(self): if self._commander: self._commander.send_command(self._current_config.serial.off_command) else: raise Exception("Serial not Started")
class DripperSetupMixIn(object): '''This is a Mixin for the ConfigurationAPI and exists only for organizational purposes''' def get_dripper_drips_per_mm(self): '''Returns Drips Per mm''' return self._current_config.dripper.drips_per_mm def get_dripper_type(self): '''Returns the configured Dripper Type''' return self._current_config.dripper.dripper_type def get_dripper_emulated_drips_per_second(self): '''Gets the drips per second to be emulated''' return self._current_config.dripper.emulated_drips_per_second def get_dripper_photo_zaxis_delay(self): '''Gets the photo delay in seconds''' return self._current_config.dripper.photo_zaxis_delay def set_dripper_drips_per_mm(self, drips): '''Sets Drips Per mm''' self._current_config.dripper.drips_per_mm = drips if self._drip_detector: self._drip_detector.set_drips_per_mm(drips) self.save() def set_dripper_type(self, value): '''Sets the configured Dripper Type''' self._current_config.dripper.dripper_type = value self.save() def set_dripper_emulated_drips_per_second(self, value): '''Sets the drips per second to be emulated''' self._current_config.dripper.emulated_drips_per_second = value self.save() def set_dripper_photo_zaxis_delay(self, value): '''Sets the photo delay in seconds''' self._current_config.dripper.photo_zaxis_delay = value self.save() def reset_drips(self): '''Sets the drip count back to 0''' self._drip_detector.reset() def start_counting_drips(self, drip_call_back=None): '''Turns on the counting of drips. Stop must be called to end this.''' self.drip_call_back = drip_call_back if self._current_config.serial.on: self._commander = SerialCommander(self._current_config.serial.port) self._change_dripper() def _change_dripper(self): self._stop_current_dripper() if self._current_config.dripper.dripper_type == 'emulated': pass elif self._current_config.dripper.dripper_type == 'photo': pass elif self._current_config.dripper.dripper_type == 'microcontroller': self._communicator = UsbPacketCommunicator( self._current_config.circut.calibration_queue_length) self._communicator.start() self._drip_detector = SerialDripZAxis( self._communicator, 1, 0.0, drip_call_back=self.drip_call_back) def _stop_current_dripper(self): if self._communicator: self._communicator.close() if self._drip_detector: self._drip_detector.close() self._drip_detector = None def stop_counting_drips(self): '''Turns off the counting of drips if counting''' if self._commander: self._commander.close() self._stop_current_dripper() def send_dripper_on_command(self): '''If serial commuinication is enabled this send the turn on drips command''' if self._commander: self._commander.send_command( self._current_config.serial.on_command) else: raise Exception("Serial not Started") def send_dripper_off_command(self): '''If serial commuinication is enabled this send the turn off drips command''' if self._commander: self._commander.send_command( self._current_config.serial.off_command) else: raise Exception("Serial not Started")
class DripperSetupMixIn(object): '''Depricated use get_dripper_drips_per_mm''' def get_drips_per_mm(self): logging.warning("Depricated use get_dripper_drips_per_mm") return self.get_dripper_drips_per_mm() '''Returns Drips Per mm''' def get_dripper_drips_per_mm(self): return self._current_config.dripper.drips_per_mm '''Returns the configured Dripper Type''' def get_dripper_type(self): return self._current_config.dripper.dripper_type '''Depricated use get_dripper_emulated_drips_per_second''' def get_emulated_drips_per_second(self): logging.warning("Depricated use get_dripper_emulated_drips_per_second") return self.get_dripper_emulated_drips_per_second() '''Gets the drips per second to be emulated''' def get_dripper_emulated_drips_per_second(self): return self._current_config.dripper.emulated_drips_per_second '''Depricated use get_dripper_photo_zaxis_delay''' def get_photo_zaxis_delay(self): logging.warning("Depricated use get_dripper_photo_zaxis_delay") return self.get_dripper_photo_zaxis_delay() '''Gets the photo delay in seconds''' def get_dripper_photo_zaxis_delay(self): return self._current_config.dripper.photo_zaxis_delay '''Depricated use set_dripper_drips_per_mm''' def set_drips_per_mm(self, drips): logging.warning("Depricated use set_dripper_drips_per_mm") self.set_dripper_drips_per_mm(drips) '''Sets Drips Per mm''' def set_dripper_drips_per_mm(self, drips): self._current_config.dripper.drips_per_mm = drips if self._drip_detector: self._drip_detector.set_drips_per_mm(drips) self.save() '''Sets the configured Dripper Type''' def set_dripper_type(self, value): self._current_config.dripper.dripper_type = value self.save() '''Depricated use set_dripper_emulated_drips_per_second''' def set_emulated_drips_per_second(self, value): logging.warning("Depricated use set_dripper_emulated_drips_per_second") self.set_dripper_emulated_drips_per_second(value) '''Sets the drips per second to be emulated''' def set_dripper_emulated_drips_per_second(self, value): self._current_config.dripper.emulated_drips_per_second = value self.save() '''Depricated use set_dripper_photo_zaxis_delay''' def set_photo_zaxis_delay(self, value): logging.warning("Depricated use set_dripper_photo_zaxis_delay") self.set_dripper_photo_zaxis_delay(value) '''Sets the photo delay in seconds''' def set_dripper_photo_zaxis_delay(self, value): self._current_config.dripper.photo_zaxis_delay = value self.save() '''Sets the drip count back to 0''' def reset_drips(self): self._drip_detector.reset() '''Turns on the counting of drips. Stop must be called to end this.''' def start_counting_drips(self, drip_call_back=None): self.drip_call_back = drip_call_back if self._current_config.serial.on: self._commander = SerialCommander(self._current_config.serial.port) self._change_dripper() def _change_dripper(self): self._stop_current_dripper() if self._current_config.dripper.dripper_type == 'emulated': pass elif self._current_config.dripper.dripper_type == 'photo': pass elif self._current_config.dripper.dripper_type == 'microcontroller': self._communicator = UsbPacketCommunicator( self._current_config.circut.calibration_queue_length) self._communicator.start() self._drip_detector = SerialDripZAxis( self._communicator, 1, 0.0, drip_call_back=self.drip_call_back) def _stop_current_dripper(self): if self._communicator: self._communicator.close() if self._drip_detector: self._drip_detector.close() self._drip_detector = None '''Turns off the counting of drips if counting''' def stop_counting_drips(self): if self._commander: self._commander.close() self._stop_current_dripper() def send_dripper_on_command(self): if self._commander: self._commander.send_command( self._current_config.serial.on_command) else: raise Exception("Serial not Started") def send_dripper_off_command(self): if self._commander: self._commander.send_command( self._current_config.serial.off_command) else: raise Exception("Serial not Started")