def _make_server(self, icsconfig): """ Creates a self.server object based on the icsconfig @param icsconfig Configuration information about this interface @returns An RTU Server object """ serial = Serial() serial.port = icsconfig['port'] serial.baudrate = icsconfig['baudrate'] serial.open() server = modbus_rtu.RtuServer(serial) return server
def doMove(self, move): print("Armcontroller is doing move") serial = Serial('/dev/ttyUSB0') serial.baudrate = 9600 try: serial.write('x') except Exception as e: print "An error occured" print e
def _make_server(self, icsconfig): """ Creates a self.server object based on the icsconfig @param icsconfig Configuration information about this interface @returns An RTU Server object """ serial = Serial() serial.port = icsconfig['port'] serial.baudrate = icsconfig['baudrate'] serial.open() server = modbus_rtu.RtuServer(serial) server.set_verbose(True) #BRFIX modbus_tk.hooks.install_hook('modbus_rtu.RtuServer.before_write', self._delay_hook_B) #BRDEBUG return server
def run(self): Logger.log("d", "Auto detect baud rate started.") timeout = 3 tries = 2 programmer = Stk500v2() serial = None try: programmer.connect(self._serial_port) serial = programmer.leaveISP() except: programmer.close() for retry in range(tries): for baud_rate in self._all_baud_rates: Logger.log("d", "Checking {serial} if baud rate {baud_rate} works".format(serial= self._serial_port, baud_rate = baud_rate)) if serial is None: try: serial = Serial(str(self._serial_port), baud_rate, timeout = timeout, writeTimeout = timeout) except SerialException as e: Logger.logException("w", "Unable to create serial") continue else: # We already have a serial connection, just change the baud rate. try: serial.baudrate = baud_rate except: continue sleep(1.5) # Ensure that we are not talking to the boot loader. 1.5 seconds seems to be the magic number successful_responses = 0 serial.write(b"\n") # Ensure we clear out previous responses serial.write(b"M105\n") timeout_time = time() + timeout while timeout_time > time(): line = serial.readline() if b"ok T:" in line: successful_responses += 1 if successful_responses >= 3: self.setResult(baud_rate) return serial.write(b"M105\n") sleep(15) # Give the printer some time to init and try again. self.setResult(None) # Unable to detect the correct baudrate.
def run(self): port = Serial() port.baudrate = 115200 port.parity = 'N' port.rtscts = False port.xonxoff = True port.port = 0 port.open() sys.stdout = port print >>sys.stderr, 'reading from serial port' while 1: line = '' while 1: ch = port.read(1) line += ch print >>sys.stderr, 'got character %s from serial' % (ch) if ch == '\n': break print >>sys.stderr, 'got line', line server.process_request(SerialRequest(line,port), 'COM1')
def push(self, items): """ Function that prints the passed arguments using a connected cash register. It handles the serial communication, raising an exception if something goes wrong. """ try: # define the serial port conn = Serial() conn.port = settings.SERIAL_PORT conn.baudrate = settings.SERIAL_BAUDRATE conn.xonxoff = settings.SERIAL_XONXOFF conn.timeout = settings.SERIAL_TIMEOUT # create a cash register with a serial connection handler register = SaremaX1(settings.REGISTER_NAME, connection=conn) # prepare and send cash register commands register.sell_products(items) register.send() except SerialException: raise CashRegisterNotReady
def upload_serial(self, board, protocol, port): if not os.path.exists(port): raise Abort("%s doesn't exist. Is Arduino connected?" % port) # send a hangup signal when the last process closes the tty file_switch = '-f' if platform.system() == 'Darwin' else '-F' ret = subprocess.call([self.e['stty'], file_switch, port, 'hupcl']) if ret: raise Abort("stty failed") # pulse on DTR try: s = Serial(port, 115200) except SerialException as e: raise Abort(str(e)) s.setDTR(False) sleep(0.1) s.setDTR(True) s.close() # Need to do a little dance for Leonardo and derivatives: # open then close the port at the magic baudrate (usually 1200 bps) first # to signal to the sketch that it should reset into bootloader. after doing # this wait a moment for the bootloader to enumerate. On Windows, also must # deal with the fact that the COM port number changes from bootloader to # sketch. touch_port = \ board['upload'].get('use_1200bps_touch') == 'true' or \ board['upload']['protocol'] == 'avr109' if touch_port: new_port = None before = self.e.list_serial_ports() if port in before: ser = Serial() ser.port = port ser.baudrate = 1200 ser.open() ser.close() # Scanning for available ports seems to open the port or # otherwise assert DTR, which would cancel the WDT reset if # it happened within 250 ms. So we wait until the reset should # have already occured before we start scanning. if platform.system() != 'Darwin': sleep(0.3) elapsed = 0 enum_delay = 0.25 while elapsed < 10: now = self.e.list_serial_ports() diff = list(set(now) - set(before)) if diff: new_port = diff[0] break before = now sleep(enum_delay) elapsed += enum_delay if not new_port: raise Abort("Couldn’t find a board on the selected port. " "Check that you have the correct port selected. " "If it is correct, try pressing the board's reset " "button after initiating the upload.") port = new_port # call avrdude to upload .hex subprocess.call([ self.e['avrdude'], '-C', self.e['avrdude.conf'], '-p', board['build']['mcu'], '-P', port, '-c', protocol, '-b', board['upload']['speed'], '-D', '-U', 'flash:w:%s:i' % self.e['hex_path'], ])
def _establish_connection(self, port): """ Helper method to be used by the BoardCommunicator only to connect to the arduino board. Tells the arduino to home upon connection. """ cxn = Serial() cxn.baudrate = 115200 self._logger.log("Connecting to arduino board at %s" %port) cxn.port = port #Attempt to connect at the previously stored port. try: cxn.open() except (SerialException, OSError): cxn.close() self._logger.log("Failed connection to stored port %s" %port) if cxn.isOpen(): sleep(3) while cxn.inWaiting() > 0: cxn.read() #Send the handshake message cxn.write("connection") sleep(3) msg = cxn.read(cxn.inWaiting()).strip() self._logger.log("Handshake string received from arduino: %r" %msg) if msg == "main": self._logger.log("Main Arduino control unit found at port %s" %port) self._connection = cxn if self.send("h") == 0: self._logger.log("Homing of camera successful") return else: self._logger.log("Homing failed upon connection") raise SerialException("Homing Error, please check machine") else: self._logger.log("Connection at port %s was not the Arduino" + " control unit") cxn.close() #If the stored port fails, search available ports, trying the handshake #at each one else: self._logger.log("Searching available ports for the Arduino " "control unit") cxn.close() for searched_port in list_ports.comports(): cxn.port = searched_port[0] try: cxn.open() except (SerialException, OSError): self._logger.log("Failed connection to searched port %s" %searched_port[0]) if cxn.isOpen(): sleep(3) while cxn.inWaiting() > 0: cxn.read() cxn.write("connection") sleep(3) msg = cxn.read(cxn.inWaiting()).strip() self._logger.log("Handshake string received from arduino: %r" %msg) if msg == "main": self._logger.log("Main Arduino control unit found at port %s" %searched_port[0]) self._connection = cxn utils.update_config_dict("CameraCommunicator", dict(arduino_port = searched_port[0])) if self.send("h") == 0: self._logger.log("Homing of camera successful") return else: self._logger.log("Homing failed upon connection") raise SerialException("Homing Error, please check machine") else: self._logger.log(("Connection at port %s was not the Arduino" + " control unit") %searched_port[0]) cxn.close() if self._connection is None: self._logger.log("Did not connect to the Arduino Board after " + "searching all ports") raise SerialException("Did not connect to the Arduino Board")
def doFlashTasmota(self, room: str, espType: str, siteId: str): port = self.findUSBPort(timeout=60) if port: self.MqttManager.say(text=self.TalkManager.randomTalk( 'usbDeviceFound', module='AliceCore'), client=siteId) try: mac = ESPLoader.detect_chip(port=port, baud=115200).read_mac() mac = '%s' % (':'.join(map(lambda x: '%02x' % x, mac))) cmd = list() cmd.append('--port') cmd.append(port) cmd.append('--baud') cmd.append('115200') cmd.append('--after') cmd.append('no_reset') cmd.append('write_flash') cmd.append('--flash_mode') cmd.append('dout') cmd.append('0x00000') cmd.append('sonoff.bin') cmd.append('--erase-all') esptool.main(cmd) except Exception as e: self._logger.error( f'[{self.name}] Something went wrong flashing esp device: {e}' ) self.MqttManager.say(text=self.TalkManager.randomTalk( 'espFailed', module='AliceCore'), client=siteId) self._broadcastFlag.clear() return else: self.MqttManager.say(text=self.TalkManager.randomTalk( 'noESPFound', module='AliceCore'), client=siteId) self._broadcastFlag.clear() return self._logger.info(f'[{self.name}] Tasmota flash done') self.MqttManager.say(text=self.TalkManager.randomTalk( 'espFlashedUnplugReplug', module='AliceCore'), client=siteId) found = self.findUSBPort(timeout=60) if found: self.MqttManager.say(text=self.TalkManager.randomTalk( 'espFoundReadyForConf', module='AliceCore'), client=siteId) time.sleep(10) uid = self._getFreeUID(mac) tasmotaConfigs = TasmotaConfigs(deviceType=espType, uid=uid) confs = tasmotaConfigs.getBacklogConfigs(room) if not confs: self._logger.error( f'[{self.name}] Something went wrong getting tasmota configuration' ) self.MqttManager.say(text=self.TalkManager.randomTalk( 'espFailed', module='AliceCore'), client=siteId) else: serial = Serial() serial.baudrate = 115200 serial.port = port serial.open() try: for group in confs: cmd = ';'.join(group['cmds']) if len(group['cmds']) > 1: cmd = f'Backlog {cmd}' arr = list() if len(cmd) > 50: while len(cmd) > 50: arr.append(cmd[:50]) cmd = cmd[50:] arr.append(f'{cmd}\r\n') else: arr.append(f'{cmd}\r\n') for piece in arr: serial.write(piece.encode()) self._logger.info('[{}] Sent {}'.format( self.name, piece.replace('\r\n', ''))) time.sleep(0.5) time.sleep(group['waitAfter']) serial.close() self._logger.info( f'[{self.name}] Tasmota flashing and configuring done') self.MqttManager.say(text=self.TalkManager.randomTalk( 'espFlashingDone', module='AliceCore'), client=siteId) self.addNewDevice(espType, room, uid) self._broadcastFlag.clear() except Exception as e: self._logger.error( f'[{self.name}] Something went wrong writting configuration to esp device: {e}' ) self.MqttManager.say(text=self.TalkManager.randomTalk( 'espFailed', module='AliceCore'), client=siteId) self._broadcastFlag.clear() serial.close() else: self.MqttManager.say(text=self.TalkManager.randomTalk( 'espFailed', module='AliceCore'), client=siteId) self._broadcastFlag.clear() return
from serial import Serial import json import requests arduino = Serial() arduino.baudrate = 9600 arduino.port = 'COM3' arduino.open() def getdata(): count = 0 data = '' while count < 5: data += str(arduino.readline()) count += 1 print(data) listof=data.split("\\r\\n") print(listof) realdata= listof[2].split(';') print(realdata) return realdata if __name__ == "__main__": ipadress = 'http://neofinder.tech:5000/api/iot_data' iptoken = 'http://neofinder.tech:5000/api/iot_auth' listinfo = getdata() iddevice=listinfo[0] lat=listinfo[1] lon=listinfo[2]
b = array('B',[0]*2) pack_into('H',b,0,crc) return b PORT = argv[1] UNIT = int(argv[2]) FC = int(argv[3]) ADD = int(argv[4]) LEN = int(argv[5]) lLEN = LEN & 0x00FF mLEN = LEN >> 8 if (FC < 3): BYT = (lambda x: x/8 if (x%8==0) else x/8+1)(LEN) #Round off the no. of bytes else: BYT = LEN*2 lADD = ADD & 0x00FF mADD = (ADD & 0xFF00)>>8 s = Serial('/dev/'+PORT, timeout=0.5) s.baudrate = 9600 s.parity = "E" s.databits = 8 s.stopbits = 1 s.handshake = "none" s.datatype = "raw" cmd = array('B', [UNIT,FC,mADD,lADD,mLEN,lLEN]) cmd.extend(CRC(cmd)) #lcrc = crc & 0x00FF #mcrc = (crc & 0xFF00)>>8 #cmd = array('B', [UNIT,FC,mADD,lADD,mLEN,lLEN,lcrc,mcrc]) while 1: s.write(cmd) print cmd sleep(1) read = s.read(255)
UPDATE_10_sec= "$PMTK220,10000*2F\r\n" #Update Every 10 Seconds UPDATE_5_sec= "$PMTK220,5000*1B\r\n" #Update Every 5 Seconds UPDATE_1_sec= "$PMTK220,1000*1F\r\n" #Update Every One Second UPDATE_200_msec= "$PMTK220,200*2C\r\n" #Update Every 200 Milliseconds #This set is used to set the rate the GPS takes measurements MEAS_10_sec = "$PMTK300,10000,0,0,0,0*2C\r\n" #Measure every 10 seconds MEAS_5_sec = "$PMTK300,5000,0,0,0,0*18\r\n" #Measure every 5 seconds MEAS_1_sec = "$PMTK300,1000,0,0,0,0*1C\r\n" #Measure once a second MEAS_200_msec= "$PMTK300,200,0,0,0,0*2F\r\n" #Meaure 5 times a second #Set the Baud Rate of GPS BAUD_57600 = "$PMTK251,57600*2C\r\n" #Set Baud Rate at 57600 BAUD_9600 ="$PMTK251,9600*17\r\n" #Set 9600 Baud Rate serialPort.write(BAUD_57600) time.sleep(1) serialPort.baudrate = 57600 serialPort.write(UPDATE_200_msec) time.sleep(1) serialPort.write(MEAS_200_msec) time.sleep(1) serialPort.flushInput() serialPort.flushOutput() serialPort.close() subprocess.call(['gpsctl', '-c', '0.2']) print "done" gpsd = None #seting the global variable
class Parser(): #Initializes fields in the class #contains a serial object for receiving #data from the radio module def __init__(self, dict={}): #self.ser._baudrate=115200 #number of items left in queue self.ser = Serial() self.dataItemsAvailable = 0 self.dataDict = dict def open_port(self, portName): ''' Opens serial port which was initialized with given name -For windows, name will be like 'COM4' or 'COM5' -For pi, the name will be something like '/dev/tty.usbserial' @param: portName the name of the serial port to be opened @return: a boolean indicating whether the port was opened successfully or not ''' try: self.ser = Serial(portName, timeout=2, baudrate=baudrate) #open serial port self.ser.reset_input_buffer() self.is_open = True if (not self.input.closed): self.input.close() except: print "Going into file mode" #TESTING FOR NOW self.input = open(inputFile, "r") self.ser.close() self.is_open = False #raise IllegalSerialAccess("No serial port with name: " + portName) self.output = open(outputFile, "w") #returns whether or not the port is open return self.ser.isOpen() def update(self): ''' Checks If data is waiting in the serial port then, if it is, parses it and adds it to the data queues @requires: serial port is open. @raise IllegalStateException: if the serial port is not open ''' temp = self.input.readline().strip() timestamp = time.time() if len(temp) > 0: #write input to output file self.output.write(temp + " " + time.asctime(time.localtime()) + "\n") self.output.flush() #Parse the input parsed_output = self.parse_string_multiple(temp) if parsed_output != None: for data_string in parsed_output: if (data_string[0] == '$'): #check if its a gps string str_vec = data_string.split(",") # check which kind of gps string if (str_vec[0] == "$GPRMC"): #assert(len(str_vec) == 12) if (str_vec[2] != 'A'): # not a valid gps read continue lat = str_vec[3] if (str_vec[4] == 'S'): lat *= -1 lon = str_vec[5] if (str_vec[6] == 'E'): lon *= -1 elif (str_vec[0] == "$GPGGA"): #assert(len(str_vec) == 15) if (str_vec[2] != 'A'): # not a valid gps read continue lat = str_vec[3] if (str_vec[4] == 'S'): lat *= -1 lon = str_vec[5] if (str_vec[6] == 'E'): lon *= -1 else: print "Unknown GPS token: " + str_vec[0] continue # Add the data to the Queues self.add_to_queue('LA', lat) self.add_to_queue('LO', lon) elif (data_string[0] == '!'): #check if it's data #take away the side markers data_string = re.sub('[!;]', '', data_string) #split down middle vals = data_string.split(':') #ONLY TO DEAL WITH ERROR WITH SPACE ERROR if (len(vals) == 1): vals = data_string.split(' ') type = vals[0] #create a tuple of the data type and the timestamp measurement = (vals[1], timestamp) if (vals[1] == '6.24B'): print "stop" #Add the measurement to the queue self.add_to_queue(type, measurement) else: print "Unrecognized string: " + data_string def is_empty(self, queue): return len(queue) == 0 def parse_string(self, string): ''' Parses string of data @param: takes in a string of the form "'NAME+ID':'double'" @return: returns a dictionary of data names and their values or None if data cannot be extracted ''' #Should check for multiple data points? type, measurement = string.strip().split(":") return type[1:], measurement[:-1] def parse_string_multiple(self, string): ''' Parses an input to make a list of well formed data values. @requires string is not None @param takes in a string of multiple data values which are concatenated and of the form !X:DATAXXXXX; @return: A list of strings of the form !TYPE:DATA; Returns None if no usable data points could be parsed ''' string = string.strip() parse_list = re.findall(regex, string) temp = re.findall(gpsregex, string) parse_list += temp if (parse_list == []): return None return parse_list def add_to_queue(self, dataType, value): ''' Adds a value to the end of the queue for the given name @param: takes in the name of the queue to be added to and a value @modifies: if the queueName is not None and is not in the dictionary of queues, add it to the dictionary and update; ''' if not self.dataDict.has_key(dataType): #add empty queue of new data type temp = {dataType: deque([])} self.dataDict.update(temp) if (value != None): self.dataDict.get(dataType).append(value) self.dataItemsAvailable += 1 def is_available(self): ''' Says whether or not a queue has at least on element available @return: returns a boolean indicating whether or not any of the queues in the dictionary contain at least one value ''' return self.dataItemsAvailable > 0 def get(self, dataType): ''' Gets the first value in the queue of the given Name @param: takes in the name of a data type for which the user wants to receive data. @return: if the name is not None and is in the dictionary, returns the first value in the queue converted to a float if there exists one. Otherwise, return None @deprecated: Use get_data_tuple instead. ''' if (self.dataDict.get(dataType) == None or self.is_empty(self.dataDict.get(dataType))): return None else: data = self.dataDict.get(dataType).pop() self.dataItemsAvailable -= 1 return float(data[0]) def get_data_tuple(self, dataType): ''' Gets the first value in the queue of the given Name @param: takes in the name of a data type for which the user wants to receive data. @return: if the name is not None and is in the dictionary, return the first object in the queue if there exists one. Otherwise, return None ''' if (self.dataDict.get(dataType) == None or self.is_empty(self.dataDict.get(dataType))): return None else: data = self.dataDict.get(dataType).pop() self.dataItemsAvailable -= 1 return data def close(self): print "Clean Up" try: self.ser.close() except: print "Serial is not open" try: self.output.close() except: print "Output is not open" try: self.input.close() except: print "input closed" def change_baudrate(self, new_rate): self.ser.baudrate(new_rate)
__author__ = 'greyexpert' import struct from time import sleep from serial import Serial from protocol import Protocol ser = Serial() ser.port = "/dev/tty.usbmodemfd1331" ser.baudrate = 155200 arduino = Protocol(ser) arduino.start() channel, data = arduino.waitForPackage() # Wait for initial package # Blinking for x in range(10): sleep(1) arduino.send(1, struct.pack("B", x % 2)) sleep(1) # Sleep 1 second before exit
from serial import Serial ser = Serial('/dev/ttyS0') ser.baudrate = 100000 def parse(): while ser.readable(): byte = ser.read(1) print(hex(byte[0])) parse() ''' def parse(self): # reset the parser state if too much time has elapsed self.calculate_sbus_time() if self._sbus_time > SBUSConsts.SBUS_TIMEOUT_MS: self._parse_state = 0 header = SBUSConsts.SBUS_HEADER[0] mask = SBUSConsts.SBUS2_MASK[0] footer = SBUSConsts.SBUS_FOOTER[0] footer2 = SBUSConsts.SBUS2_FOOTER[0] # see if serial data is available while self._ser.readable(): self._sbus_time = 0 self._cur_byte = self._ser.read(1)
dest="enable", default=False, help="output enable") (options, args) = parser.parse_args() if options.voltage and options.voltageDac: sys.stderr.write("-v and -o conflicts") raise SystemExit(1) if options.current and options.currentDac: sys.stderr.write("-i and -u conflicts") raise SystemExit(1) labpidserial = Serial() labpidserial.baudrate = 115200 labpidserial.port = options.port labpidserial.timeout = 0.5 #make sure that the alive event can be checked from time to time labpidserial.open() labpid = Labpid(bus=labpidserial) ps = TwoChannelPowersupply(labpid, 0) if options.channel > 3 or options.channel < 1: labpidserial.close() sys.stderr.write("Invalid Channel\n") if options.voltage: sys.stdout.write("Voltage %f\n" % options.voltage) ps.setVoltage(options.channel, options.voltage)
#**********************Программа****************************************** from serial import Serial, SerialException, EIGHTBITS, PARITY_NONE import time import logging logger = logging.getLogger(__name__) logging.basicConfig(filename='cmplr.log', filemode='w', level=logging.DEBUG) SERIAL_PORT = 'COM7' SERIAL_SPEED = 9600 ser = Serial() ser.port = SERIAL_PORT ser.baudrate = SERIAL_SPEED ser.bytesize = EIGHTBITS #number of bits per bytes ser.timeout = 1 #non-block read ser.writeTimeout = 2 #timeout for write ser.xonxoff = False #disable software flow control ser.rtscts = False #disable hardware (RTS/CTS) flow control ser.dsrdtr = False #disable hardware (DSR/DTR) flow control try: """ Пытаемся открыть серийный порт """ ser.open() except SerialException as e:
from serial import Serial import math from time import sleep from colorsys import rgb_to_hls SERIAL_PORT = "/dev/ttyACM0" BAUD_RATE = 9600 TOTAL_LEDS = 12 PRIMARY_RADIUS = 250 LED_RADIUS = 40 WINDOW_SIZE = 600 TAU = 2 * math.pi ser = Serial() ser.port = SERIAL_PORT ser.baudrate = BAUD_RATE def get_colour(): return "#" + ser.read(3).hex() def get_start_signal(): signal = b"" zeros = 0 while zeros < 3: signal = ser.read() if signal == b"\0": zeros += 1 else: zeros = 0 root = Tk()
if ((len(argv)<2) or (argv[1]=='?') or (argv[1]=='--help')): print "---usage: python "+argv[0]+" port" exit() stop = False read = False msg = "" bd = [115200,9600,1200] fr = ord('0') to = ord('z') + 1 for i in range(fr,to): msg = msg + chr(i) def clean(s): s.flushInput() s.flushOutput() try: ser = Serial('/dev/'+argv[1], timeout=0.5) for i in range(3): ser.baudrate = bd[i] print "\nAt baudrate %s:\n Writing: %s" %(bd[i],msg) ser.write(msg) read = ser.read(to-fr) if (read != msg): print "\nError in loopback, check hardware connection, jumper terminals 2 & 3 and repeat the test\n" clean(ser) exit() else: print " Reading: %s" %read print "\nLoopBack Test Done Successfully\n" clean(ser) except SerialException: print argv[1],": port does not exist" exit()
def main(): # DEBUG port ('/dev/ttyUSB3', 'COM6', etc.), typically the last one. port = sys.argv[1] # Recovery directory (recovery protocol version 2). recovery_dir = sys.argv[2] # Device capabilities file (with matching device id). device_caps = sys.argv[3] recovery_1bl = os.path.join(recovery_dir, "recovery-1bl-rtm.bin") recovery_runtime = os.path.join(recovery_dir, "recovery-runtime.bin") recovery_manifest = os.path.join(recovery_dir, "recovery.imagemanifest") # XXX: These sizes are hardcoded in the 'ServerMessageType.ImageRequestAck' # messages below. assert_file_size(device_caps, 0x188) assert_file_size(recovery_runtime, 0xeda4) assert_file_size(recovery_manifest, 0x5d8) timeout = 2 serial = Serial( port=port, baudrate=115200, parity=PARITY_NONE, bytesize=8, stopbits=1, rtscts=0, timeout=timeout) # Check that the board is in recovery mode. # If you open the port directly and hit the RESET button, you should see: # RECOVERY # 0000362000008A01020A00008FC8C833 # CCC # # 'C's mean that this is XMODEM with CRC-16 and the receiver is ready to # receive data. # http://web.mit.edu/6.115/www/amulet/xmodem.htm serial.timeout = 10 output = read(serial, 10) serial.timeout = timeout # If you're getting an error here: # - the board is not in recovery mode # - you connected too early, try again # - something is wrong with the serial port (try opening it in ExtraPutty, # it supports XMODEM too). assert b"CC" in output # Send the recovery 1BL over XMODEM. print(yellow("[<] Sending recovery 1BL")) stream = open(recovery_1bl, "rb") xmodem_send(serial, stream, timeout) # Output: b'+GOOD\r\n' readline(serial) # Output: b'[1BL] BOOT: INIT\r\n' # or # Output: b'[1BL] BOOT: 28030000/00000010/07000000\r\n' # The postcode (the last three numbers) might be different. # # In C# code: 'WaitForRecoveryBoot', 'VerifyBootMessage', 'DeviceResponses'. readline(serial) # Output: b'\x02\x89\x02\x01\x02\x85\x02\x01\x01\x01\x81006fe629beb69fc3bb06cf8494ccc25461f597aae076aa0d1f9b49656d60b63557becad65b338a1a5b4104f769649aaa35340eca1f1899df610305506cd7bee8\x03\xbe\x03\x00 (repeated)' # # Format: # \x02\x89\x02\x01\x02\x85\x02\x01\x01\x01\x81 # 006...bee8 -- Device ID # \x03\xbe\x03 # \x00 -- end of packet # # COBS uses the NULL byte as the packet delimiter. # Decoded: b'\x89\x00\x01\x00\x85\x00\x01\x00\x00\x00006fe629beb69fc3bb06cf8494ccc25461f597aae076aa0d1f9b49656d60b63557becad65b338a1a5b4104f769649aaa35340eca1f1899df610305506cd7bee8\x00\xbe\x03' # # Format: # \x89\x00 -- packet size (137, little-endian) # \x01\x00 -- ClientMessageType.Initialization (1, little-endian) # \x85\x00 -- data size (133, little-endian) # \x01\x00\x00\x00 -- version (1, little-endian) # 006...bee8 -- Device ID # \x00 -- NULL terminator # \xbe\x03 -- unk (probably CRC-16). output, leftovers = read_decode(serial) # In C# code: 'ServerMessageType', 'ControlProtocol'. # # Format (case for payload length == 0): # The array that CRC-16 is calculated on: # 04 00 a0 00 00 00 # \x04\x00 -- size # \xa0\x00 -- ServerMessageType.InitializationAck (0x00A0) # \x00\x00 -- end of the message. # # CRC-16 value: 0xecd7. # # The final array should be: # 02 04 02 a0 01 01 03 d7 ec 00 # last \x00 -- packet delimiter. # # b"\x02\x04\x02\xa0\x01\x01\x03\xd7\xec\x00" write_encode(serial, b"\xa0\x00\x00\x00") # Format: # \x0b\x00 -- ClientMessageType.RecoveryEvent # \x01\x00 -- payload size (1, little-endian) # \x01 -- RecoveryEventType.BLInitializationComplete output, leftovers = smart_decode(serial, leftovers) assert output == b"\x0b\x00\x01\x00\x01" # Format: # \t\x00 -- ClientMessageType.LogConfigQuery (0x0009) # \x00\x00 -- payload size (0, little-endian) output, leftovers = smart_decode(serial, leftovers) assert output == b"\t\x00\x00\x00" # Sending: b'\x02\x05\x02\xa3\x02\x01\x01\x03!\x8a\x00' # # In C# code: 'BuildResponse', 'SimpleAckResponse'. # Format: # \xa3\x00 -- ServerMessageType.SimpleQueryAck (0x00a3) # \x01\x00 -- payload size (1, little-endian) # \x00 -- ackResponse (0 or 1) # XXX: Try sending 1 here as ackResponse. write_encode(serial, b"\xa3\x00\x01\x00\x00") # In C# code: class 'RequestFileBase'. # # Format: # \x04\x00 -- ClientMessageType.ImageRequestCapability (0x0004) # \x08\x00 -- payload size (8, little-endian) # \x00\x00\x00\x00 -- index? # \xff\xff\xff\xff -- file size? output, leftovers = smart_decode(serial, leftovers) assert output == b"\x04\x00\x08\x00\x00\x00\x00\x00\xff\xff\xff\xff" # Format: # \xa4\x00 -- ServerMessageType.ImageRequestAck (0x00a4) # \x0c\x00 -- payload size (12, little-endian) # \x00\x00\x00\x00 -- start index? # \x88\x01\x00\x00 -- send size? # \x88\x01\x00\x00 -- total size? write_encode( serial, (b"\xa4\x00" + b"\x0c\x00" + b"\x00\x00\x00\x00" + b"\x88\x01\x00\x00" + b"\x88\x01\x00\x00")) # Send device capabilities over XMODEM. print(yellow("[<] Sending device capabilities")) stream = open(device_caps, "rb") xmodem_send(serial, stream, timeout) # Format: # \x0b\x00 -- ClientMessageType.RecoveryEvent (0x000b) # \x01\x00 -- payload size (1, little-endian) # \x02 -- RecoveryEventType.BLCapabilityImageReceived output, leftovers = smart_decode(serial, leftovers) assert output == b"\x0b\x00\x01\x00\x02" # Format: # \x0b\x00 -- ClientMessageType.RecoveryEvent (0x000b) # \x01\x00 -- payload size (1, little-endian) # \x03 -- RecoveryEventType.BLCapabilityImageLoaded output, leftovers = smart_decode(serial, leftovers) assert output == b"\x0b\x00\x01\x00\x03" # Format: # \x07\x00 -- ClientMessageType.ImageRequestByFilename # \x1d\x00 -- size (29, little-endian) # \x00\x00\x00\x00 -- index? # \xff\xff\xff\xff -- file size? # recovery-runtime.bin -- filename # \x00 -- terminator output, leftovers = smart_decode(serial, leftovers) assert output == b"\x07\x00\x1d\x00\x00\x00\x00\x00\xff\xff\xff\xffrecovery-runtime.bin\x00" # Format: # \xa4\x00 -- ServerMessageType.ImageRequestAck (0x00a4) # \x0c\x00 -- payload size (12, little-endian) # \x00\x00\x00\x00 -- start index? # \xa4\xed\x00\x00 -- send size? # \xa4\xed\x00\x00 -- total size? write_encode( serial, (b"\xa4\x00" b"\x0c\x00" b"\x00\x00\x00\x00" b"\xa4\xed\x00\x00" b"\xa4\xed\x00\x00")) # Send the recovery runtime over XMODEM. print(yellow("[<] Sending recovery runtime")) stream = open(recovery_runtime, "rb") xmodem_send(serial, stream, timeout) # Format: # \t\x00 -- ClientMessageType.LogConfigQuery (0x0009) # \x00\x00 -- payload size (0, little-endian) output, leftovers = smart_decode(serial, leftovers) assert output == b"\t\x00\x00\x00" # Format: # \xa3\x00 -- ServerMessageType.SimpleQueryAck (0x00a3) # \x01\x00 -- payload size (1, little-endian) # \x00 -- ackResponse (0 or 1) write_encode(serial, b"\xa3\x00\x01\x00\x00") # Format: # \x0b\x00 -- ClientMessageType.RecoveryEvent (0x000b) # \x01\x00 -- payload size (1, little-endian) # \x06 -- RecoveryEventType.RABootComplete output, leftovers = smart_decode(serial, leftovers) assert output == b"\x0b\x00\x01\x00\x06" # Format: # \x03\x00 -- ClientMessageType.BaudrateSwitchQuery (0x0003) # \x00\x00 -- payload size (0, little-endian) output, leftovers = smart_decode(serial, leftovers) assert output == b"\x03\x00\x00\x00" # Format: # \xa3\x00 -- ServerMessageType.SimpleQueryAck (0x00a3) # \x01\x00 -- payload size (1, little-endian) # \x01 -- ackResponse (0 or 1) # # Baudrate settings: # { # PortMode.Bootloader, # new SerialPortConfiguration() # { # BaudRate = 115200, # Parity = Parity.None, # DataBits = 8, # StopBits = StopBits.One, # Handshake = Handshake.None # } # }, # { # PortMode.ImagingMt3620, # new SerialPortConfiguration() # { # BaudRate = 3000000, # Parity = Parity.None, # DataBits = 8, # StopBits = StopBits.One, # Handshake = Handshake.RequestToSend # } # }, # { # PortMode.ImagingMt3620LowSpeed, # new SerialPortConfiguration() # { # BaudRate = 115200, # Parity = Parity.None, # DataBits = 8, # StopBits = StopBits.One, # Handshake = Handshake.RequestToSend # } # } # write_encode(serial, b"\xa3\x00\x01\x00\x01") # XXX: doesn't work write_encode(serial, b"\xa3\x00\x01\x00\x00") # serial.baudrate = 3000000 # XXX: doesn't work serial.baudrate = 115200 serial.parity = PARITY_NONE serial.bytesize = 8 serial.stopbits = 1 serial.rtscts = 1 # Format: # \x0b\x00 -- ClientMessageType.RecoveryEvent (0x000b) # \x01\x00 -- payload size (1, little-endian) # \x07 -- RecoveryEventType.RAEraseFlashStarted output, leftovers = smart_decode(serial, leftovers) assert output == b"\x0b\x00\x01\x00\x07" # Format: # \x0b\x00 -- ClientMessageType.RecoveryEvent (0x000b) # \x01\x00 -- payload size (1, little-endian) # \x08 -- RecoveryEventType.RAEraseFlashComplete print("[i] Waiting for flash erase to complete") while True: try: output, leftovers = smart_decode(serial, leftovers) break except EmptyOutputError: continue assert output == b"\x0b\x00\x01\x00\x08" # Format: # \x07\x00 -- ClientMessageType.ImageRequestByFilename # \x1f\x00 -- size (31, little-endian) # \x00\x00\x00\x00 -- index? # \xff\xff\xff\xff -- file size? # recovery.imagemanifest -- filename # \x00 -- terminator output, leftovers = smart_decode(serial, leftovers) assert output == b"\x07\x00\x1f\x00\x00\x00\x00\x00\xff\xff\xff\xffrecovery.imagemanifest\x00" # Format: # \xa4\x00 -- ServerMessageType.ImageRequestAck (0x00a4) # \x0c\x00 -- payload size (12, little-endian) # \x00\x00\x00\x00 -- start index? # \xd8\x05\x00\x00 -- send size? # \xd8\x05\x00\x00 -- total size? write_encode( serial, (b"\xa4\x00" + b"\x0c\x00" + b"\x00\x00\x00\x00" + b"\xd8\x05\x00\x00" + b"\xd8\x05\x00\x00")) # Send the recovery manifest over XMODEM. print(yellow("[<] Sending recovery manifest")) stream = open(recovery_manifest, "rb") xmodem_send(serial, stream, timeout) # Format: # \x0b\x00 -- ClientMessageType.RecoveryEvent # \x01\x00 -- payload size (1, little-endian) # \x09 -- RecoveryEventType.RAManifestReceived output, leftovers = smart_decode(serial, leftovers) assert output == b"\x0b\x00\x01\x00\t"
def addDevice(self, device): tty = Serial(device, 9600) tty.baudrate = 115200 endPointWrapper = EndPointWrapper(tty, self.switchEventQueue) endPointWrapper.ensureID() self.endPoints[endPointWrapper.id] = endPointWrapper
__author__ = 'paweber' from Crc import CRCCCITT from serial import Serial # Board connection board = Serial("COM11") board.baudrate = 115200 #crc calculator crcCalculator = CRCCCITT() packetLength = 13; # Header preamble = 0x55 version = 0x01 # Modes mode = {} mode['read'] = 0x00 mode['write'] = 0x01 mode['conn check'] = 0x02 mode['ack'] = 0x03 # Channels channel = {} channel['none'] = 0x00 channel['one'] = 0x01 channel['two'] = 0x02 channel['three'] = 0x03
from serial import Serial # connect just computer port to wavemeter using RS232 adapter # not used for arduino ser = Serial() ser.port = 'COM7' ser.baudrate = 19200 ser.open() print(ser.is_open) #ser.write(b"*IDN?\n") #ser.write("*IDN?\n".encode()) # end of line (EOL) character is \n #print(ser.read(39)) # number of bytes, if larger than output will run loop ### Communicating read and write no matter how long ### ser.write(b":READ:POWer:WAVelength?\n") ser_bytes = ser.readline() decoded_bytes = ser_bytes[0:len(ser_bytes) - 1].decode() print(decoded_bytes) ser.write(b"*IDN?\n") ser_bytes2 = ser.readline() decoded_bytes2 = ser_bytes2[0:len(ser_bytes2) - 1].decode() print(decoded_bytes2) ### Loop ### while True: try: ser.write(b":READ:POWer:WAVelength?\n") ser_bytes = ser.readline()
def run(self) -> None: Logger.log("d", "Auto detect baud rate started.") wait_response_timeouts = [3, 15, 30] wait_bootloader_times = [1.5, 5, 15] write_timeout = 3 read_timeout = 3 tries = 2 programmer = Stk500v2() serial = None try: programmer.connect(self._serial_port) serial = programmer.leaveISP() except ispBase.IspError: programmer.close() for retry in range(tries): for baud_rate in self._all_baud_rates: if retry < len(wait_response_timeouts): wait_response_timeout = wait_response_timeouts[retry] else: wait_response_timeout = wait_response_timeouts[-1] if retry < len(wait_bootloader_times): wait_bootloader = wait_bootloader_times[retry] else: wait_bootloader = wait_bootloader_times[-1] Logger.log( "d", "Checking {serial} if baud rate {baud_rate} works. Retry nr: {retry}. Wait timeout: {timeout}" .format(serial=self._serial_port, baud_rate=baud_rate, retry=retry, timeout=wait_response_timeout)) if serial is None: try: serial = Serial(str(self._serial_port), baud_rate, timeout=read_timeout, writeTimeout=write_timeout) except SerialException: Logger.logException("w", "Unable to create serial") continue else: # We already have a serial connection, just change the baud rate. try: serial.baudrate = baud_rate except ValueError: continue sleep( wait_bootloader ) # Ensure that we are not talking to the boot loader. 1.5 seconds seems to be the magic number successful_responses = 0 serial.write(b"\n") # Ensure we clear out previous responses serial.write(b"M105\n") start_timeout_time = time() timeout_time = time() + wait_response_timeout while timeout_time > time(): line = serial.readline() if b"ok" in line and b"T:" in line: successful_responses += 1 if successful_responses >= 1: self.setResult(baud_rate) Logger.log( "d", "Detected baud rate {baud_rate} on serial {serial} on retry {retry} with after {time_elapsed:0.2f} seconds." .format(serial=self._serial_port, baud_rate=baud_rate, retry=retry, time_elapsed=time() - start_timeout_time)) serial.close( ) # close serial port so it can be opened by the USBPrinterOutputDevice return serial.write(b"M105\n") sleep(15) # Give the printer some time to init and try again. self.setResult(None) # Unable to detect the correct baudrate.
def _establish_connection(self, port): """ Helper method to be used by the BoardCommunicator only to connect to the arduino board. Tells the arduino to home upon connection. """ cxn = Serial() cxn.baudrate = 115200 self._logger.log("Connecting to arduino board at %s" % port) cxn.port = port #Attempt to connect at the previously stored port. try: cxn.open() except (SerialException, OSError): cxn.close() self._logger.log("Failed connection to stored port %s" % port) if cxn.isOpen(): sleep(3) while cxn.inWaiting() > 0: cxn.read() #Send the handshake message cxn.write("connection") sleep(3) msg = cxn.read(cxn.inWaiting()).strip() self._logger.log("Handshake string received from arduino: %r" % msg) if msg == "main": self._logger.log("Main Arduino control unit found at port %s" % port) self._connection = cxn if self.send("h") == 0: self._logger.log("Homing of camera successful") return else: self._logger.log("Homing failed upon connection") raise SerialException("Homing Error, please check machine") else: self._logger.log("Connection at port %s was not the Arduino" + " control unit") cxn.close() #If the stored port fails, search available ports, trying the handshake #at each one else: self._logger.log("Searching available ports for the Arduino " "control unit") cxn.close() for searched_port in list_ports.comports(): cxn.port = searched_port[0] try: cxn.open() except (SerialException, OSError): self._logger.log("Failed connection to searched port %s" % searched_port[0]) if cxn.isOpen(): sleep(3) while cxn.inWaiting() > 0: cxn.read() cxn.write("connection") sleep(3) msg = cxn.read(cxn.inWaiting()).strip() self._logger.log( "Handshake string received from arduino: %r" % msg) if msg == "main": self._logger.log( "Main Arduino control unit found at port %s" % searched_port[0]) self._connection = cxn utils.update_config_dict( "CameraCommunicator", dict(arduino_port=searched_port[0])) if self.send("h") == 0: self._logger.log("Homing of camera successful") return else: self._logger.log("Homing failed upon connection") raise SerialException( "Homing Error, please check machine") else: self._logger.log( ("Connection at port %s was not the Arduino" + " control unit") % searched_port[0]) cxn.close() if self._connection is None: self._logger.log("Did not connect to the Arduino Board after " + "searching all ports") raise SerialException("Did not connect to the Arduino Board")
# David Chatting - github.com/davidchatting/Approximate # MIT License - Copyright (c) February 2021 # # Adapted from: http://www.mikeburdis.com/wp/notes/plotting-serial-port-data-using-python-and-matplotlib/ import matplotlib.pyplot as plt import matplotlib.animation as animation from matplotlib import style import numpy as np import random from serial import Serial #initialize serial port ser = Serial() ser.port = '/dev/tty.SLAB_USBtoUART' #ESP32 serial port ser.baudrate = 9600 ser.timeout = 10 #specify timeout when using readline() ser.open() if ser.is_open==True: # Create figure for plotting fig = plt.figure() ax = fig.add_subplot(1, 1, 1) xs = [] ys = [] # This function is called periodically from FuncAnimation def animate(i, xs, ys): line=ser.readline().strip() line_as_list = line.split(b'\t') if len(line_as_list)==52:
import sys import pynmea2 from serial import Serial ser = Serial() ser.baudrate = 9600 ser.port = '/dev/ttyUSB0' ser.open() if not ser.isOpen(): print("Unable to open serial port!") raise SystemExit reader = pynmea2.NMEAStreamReader() while True: raw = ser.readline() if raw[0] == 36: gps = raw.decode("ascii") msg = pynmea2.parse(gps) print("MSG: {0}/{1}".format(msg.talker, msg.sentence_type))
def run(self, args): self.discover() port = args.serial_port or self.e.guess_serial_port() board = self.e.board_model(args.board_model) protocol = board['upload']['protocol'] if protocol == 'stk500': # if v1 is not specifid explicitly avrdude will # try v2 first and fail protocol = 'stk500v1' if not os.path.exists(port): raise Abort("%s doesn't exist. Is Arduino connected?" % port) # send a hangup signal when the last process closes the tty file_switch = '-f' if platform.system() == 'Darwin' else '-F' ret = subprocess.call([self.e['stty'], file_switch, port, 'hupcl']) if ret: raise Abort("stty failed") # pulse on DTR try: s = Serial(port, 115200) except SerialException as e: raise Abort(str(e)) s.setDTR(False) sleep(0.1) s.setDTR(True) s.close() # Need to do a little dance for Leonardo and derivatives: # open then close the port at the magic baudrate (usually 1200 bps) first # to signal to the sketch that it should reset into bootloader. after doing # this wait a moment for the bootloader to enumerate. On Windows, also must # deal with the fact that the COM port number changes from bootloader to # sketch. if board['bootloader']['path'] == "caterina": caterina_port = None before = self.e.list_serial_ports() if port in before: ser = Serial() ser.port = port ser.baudrate = 1200 ser.open() ser.close() # Scanning for available ports seems to open the port or # otherwise assert DTR, which would cancel the WDT reset if # it happened within 250 ms. So we wait until the reset should # have already occured before we start scanning. if platform.system() != 'Darwin': sleep(0.3) elapsed = 0 enum_delay = 0.25 while elapsed < 10: now = self.e.list_serial_ports() diff = list(set(now) - set(before)) if diff: caterina_port = diff[0] break before = now sleep(enum_delay) elapsed += enum_delay if caterina_port == None: raise Abort("Couldn’t find a Leonardo on the selected port. " "Check that you have the correct port selected. " "If it is correct, try pressing the board's reset " "button after initiating the upload.") port = caterina_port # call avrdude to upload .hex subprocess.call([ self.e['avrdude'], '-C', self.e['avrdude.conf'], '-p', board['build']['mcu'], '-P', port, '-c', protocol, '-b', board['upload']['speed'], '-D', '-U', 'flash:w:%s:i' % self.e['hex_path'], ])
def run(self, args): self.discover(args.board_model) board = self.e.board_model(args.board_model) if args.board_model.startswith('teensy'): post_compile = self.e[board['build']['post_compile_script']] reboot = self.e[board['upload']['avrdude_wrapper']] # post_compile script requires: # .hex filename w/o the extension filename = os.path.splitext(self.e.hex_filename)[0] # full path to directory with the compiled .hex file fullpath = os.path.realpath(self.e.build_dir) # full path to the tools directory tooldir = self.e.find_arduino_dir('', ['hardware', 'tools']) subprocess.call([ post_compile, '-file=' + filename, '-path=' + fullpath, '-tools=' + tooldir ]) # reboot to complete the upload # NOTE: this will warn the user if they need to press the reset button subprocess.call([ reboot ]) exit(0) port = args.serial_port or self.e.guess_serial_port() protocol = board['upload']['protocol'] if protocol == 'stk500': # if v1 is not specifid explicitly avrdude will # try v2 first and fail protocol = 'stk500v1' if not os.path.exists(port): raise Abort("%s doesn't exist. Is Arduino connected?" % port) # send a hangup signal when the last process closes the tty file_switch = '-f' if platform.system() == 'Darwin' else '-F' ret = subprocess.call([self.e['stty'], file_switch, port, 'hupcl']) if ret: raise Abort("stty failed") # pulse on DTR try: s = Serial(port, 115200) except SerialException as e: raise Abort(str(e)) s.setDTR(False) sleep(0.1) s.setDTR(True) s.close() # Need to do a little dance for Leonardo and derivatives: # open then close the port at the magic baudrate (usually 1200 bps) first # to signal to the sketch that it should reset into bootloader. after doing # this wait a moment for the bootloader to enumerate. On Windows, also must # deal with the fact that the COM port number changes from bootloader to # sketch. touch_port = \ board['upload'].get('use_1200bps_touch') == 'true' or \ board['upload']['protocol'] == 'avr109' if touch_port: new_port = None before = self.e.list_serial_ports() if port in before: ser = Serial() ser.port = port ser.baudrate = 1200 ser.open() ser.close() # Scanning for available ports seems to open the port or # otherwise assert DTR, which would cancel the WDT reset if # it happened within 250 ms. So we wait until the reset should # have already occured before we start scanning. if platform.system() != 'Darwin': sleep(0.3) elapsed = 0 enum_delay = 0.25 while elapsed < 10: now = self.e.list_serial_ports() diff = list(set(now) - set(before)) if diff: new_port = diff[0] break before = now sleep(enum_delay) elapsed += enum_delay if not new_port: raise Abort("Couldn’t find a board on the selected port. " "Check that you have the correct port selected. " "If it is correct, try pressing the board's reset " "button after initiating the upload.") port = new_port # call avrdude to upload .hex subprocess.call([ self.e['avrdude'], '-C', self.e['avrdude.conf'], '-p', board['build']['mcu'], '-P', port, '-c', protocol, '-b', board['upload']['speed'], '-D', '-U', 'flash:w:%s:i' % self.e['hex_path'], ])
def run(self) -> None: Logger.log("d", "Auto detect baud rate started.") wait_response_timeouts = [3, 15, 30] wait_bootloader_times = [1.5, 5, 15] write_timeout = 3 read_timeout = 3 tries = 2 programmer = Stk500v2() serial = None try: programmer.connect(self._serial_port) serial = programmer.leaveISP() except ispBase.IspError: programmer.close() for retry in range(tries): for baud_rate in self._all_baud_rates: if retry < len(wait_response_timeouts): wait_response_timeout = wait_response_timeouts[retry] else: wait_response_timeout = wait_response_timeouts[-1] if retry < len(wait_bootloader_times): wait_bootloader = wait_bootloader_times[retry] else: wait_bootloader = wait_bootloader_times[-1] Logger.log("d", "Checking {serial} if baud rate {baud_rate} works. Retry nr: {retry}. Wait timeout: {timeout}".format( serial = self._serial_port, baud_rate = baud_rate, retry = retry, timeout = wait_response_timeout)) if serial is None: try: serial = Serial(str(self._serial_port), baud_rate, timeout = read_timeout, writeTimeout = write_timeout) except SerialException: Logger.logException("w", "Unable to create serial") continue else: # We already have a serial connection, just change the baud rate. try: serial.baudrate = baud_rate except ValueError: continue sleep(wait_bootloader) # Ensure that we are not talking to the boot loader. 1.5 seconds seems to be the magic number successful_responses = 0 serial.write(b"\n") # Ensure we clear out previous responses serial.write(b"M105\n") start_timeout_time = time() timeout_time = time() + wait_response_timeout while timeout_time > time(): line = serial.readline() if b"ok " in line and b"T:" in line: successful_responses += 1 if successful_responses >= 3: self.setResult(baud_rate) Logger.log("d", "Detected baud rate {baud_rate} on serial {serial} on retry {retry} with after {time_elapsed:0.2f} seconds.".format( serial = self._serial_port, baud_rate = baud_rate, retry = retry, time_elapsed = time() - start_timeout_time)) serial.close() # close serial port so it can be opened by the USBPrinterOutputDevice return serial.write(b"M105\n") sleep(15) # Give the printer some time to init and try again. self.setResult(None) # Unable to detect the correct baudrate.
__author__ = 'greyexpert' import struct from time import sleep from serial import Serial from protocol import Protocol ser = Serial() ser.port = "/dev/tty.usbmodemfd1331" ser.baudrate = 155200 arduino = Protocol(ser) arduino.start() channel, data = arduino.waitForPackage() # Wait for initial package # Blinking for x in range(10): sleep(1) arduino.send(1, struct.pack("B", x % 2)) sleep(1) # Sleep 1 second before exit
# !/usr/bin/env python3 # _*_ coding: utf-8 _*_ # create on 2017.3.1 # author:fan import struct import binascii import time from serial import Serial # 导入模块 t = Serial('com2') # 创建Serial实例 t.baudrate = 115200 # 设置参数(参数设置请以实际为准) t.bytesize = 7 t.stopbits = 1 t.parity = 'E' print(''' com = %s baud_rate = %d data_size = %d parity = %s stop_bits = %d''' % (t.port, t.baudrate, t.bytesize, t.parity, t.stopbits)) def watch_com(read_size=4, write_data='ff', sleep_time=0.1): i = 0 while i < 10: i += 1 if i == 32767: i = 0 time.sleep(sleep_time)
print('Connect to Arduino:\t', arduino) print('Connect to Steve:\t', stev) print() print('Trying to activate all possible Connections:') if arduino: com_ports_red = com_ports[:-1] for i, val in enumerate(com_ports_red): if not con_ard_enable: try: 'Serial-Objekt instanziieren' device = Serial() 'Port festlegen' device.port = com_ports[i] 'Baudrate festlegen' device.baudrate = 115200 'Timeout festlegen' device.timeout = 1 device.open() con_ard_enable = True print('Connected to Arduino by', com_ports[i], '.') except SerialException: print('Connection to Arduino by ', com_ports[i], ' not possible, trying ', com_ports[i + 1], '.') if not con_ard_enable: try: i = i + 1 'Serial-Objekt instanziieren'
""" @object: Implementation of a serial server to retrieve and back up data and metadata from a prototype as part of a dual-screen smartphone experience. @author: PECCHIOLI Mathieu """ # IMPORT LIBRAIRIES from serial import Serial from Package.package_serial import decode, readMetadata from os import system # SETTING UP SERIAL PORTS ast1 = Serial() ast2 = Serial() ast1.baudrate = 9600 ast2.baudrate = 9600 ast1.port = '/dev/ttyACM0' ast2.port = '/dev/ttyACM1' # OPEN SERIAL PORTS ast1.open() ast2.open() # RUNNING system('clear') print("SERVER STARTED\n\n") while True: # READ SERIAL PORT 1 while ast1.in_waiting: data = ast1.read(1).decode('utf-8') if data == '$':
def main(argv): port = 8000 configfile = None logfile = None i = 1 while i < len(argv): if argv[i] in ["-c", "-C", "--config-file"]: configfile = argv[i + 1] i += 1 elif argv[i] in ["-l", "-L", "--log-file"]: logfile = argv[i + 1] i += 1 elif argv[i] in ["-h", "-H", "--help"]: displayHelp() elif argv[i] in ["-d", "--debug"]: setDebug() else: try: port = int(argv[i]) except ValueError: displayHelp() i += 1 if logfile: logToFile(logfile) info("Starting XBee %s" % VERSION) # setup serial serial = Serial() serial.port = '/dev/ttyAMA0' serial.baudrate = 9600 serial.timeout = 1 serial.writeTimeout = 1 serial.open() # disregard any pending data in xbee buffer serial.flushInput() # force to show xbee boot menu time.sleep(.5) serial.writelines("\r") time.sleep(.5) # read menu while serial.inWaiting() > 0: debug("%s" % serial.readline()) # trigger bypass automatically serial.writelines("B") # post startup message to other XBee's and at stdout #serial.writelines("RPi #1 is up and running.\r\n") info("RPi #1 is up and running.") try: while True: waitToSend = True # read a line from XBee and convert it from b'xxx\r\n' to xxx and send to webiopi while serial.inWaiting() > 0: try: line = serial.readline().decode('utf-8').strip('\n\r') if line: waitToSend = False debug("Received: %s" % line) try: client = PiHttpClient("127.0.0.1") macro = Macro(client, "setCarInfo") macro.call(line.replace(",", "%2C")) except: exception("setting car info failed!") except KeyboardInterrupt: raise except Exception as e: exception(e) time.sleep(1.) try: time.sleep(1.) client = PiHttpClient("127.0.0.1") macro = Macro(client, "getPitInfo") data = macro.call() if data: debug("Sending: %s" % data) serial.writelines(data + "\n") except KeyboardInterrupt: raise except Exception as e: exception(e) time.sleep(1.) except KeyboardInterrupt: info("*** Ctrl-C keyboard interrupt ***")
def main(argv): port = 8000 configfile = None logfile = None i = 1 while i < len(argv): if argv[i] in ["-c", "-C", "--config-file"]: configfile = argv[i+1] i+=1 elif argv[i] in ["-l", "-L", "--log-file"]: logfile = argv[i+1] i+=1 elif argv[i] in ["-h", "-H", "--help"]: displayHelp() elif argv[i] in ["-d", "--debug"]: setDebug() else: try: port = int(argv[i]) except ValueError: displayHelp() i+=1 if logfile: logToFile(logfile) info("Starting XBee %s" % VERSION) # setup serial serial = Serial() serial.port = '/dev/ttyAMA0' serial.baudrate = 9600 serial.timeout = 1 serial.writeTimeout = 1 serial.open() # disregard any pending data in xbee buffer serial.flushInput() # force to show xbee boot menu time.sleep(.5) serial.writelines("\r") time.sleep(.5) # read menu while serial.inWaiting() > 0: debug("%s" % serial.readline()) # trigger bypass automatically serial.writelines("B") # post startup message to other XBee's and at stdout #serial.writelines("RPi #1 is up and running.\r\n") info("RPi #1 is up and running.") try: while True: waitToSend = True # read a line from XBee and convert it from b'xxx\r\n' to xxx and send to webiopi while serial.inWaiting() > 0: try: line = serial.readline().decode('utf-8').strip('\n\r') if line: waitToSend = False debug("Received: %s" % line) try: client = PiHttpClient("127.0.0.1") macro = Macro(client, "setCarInfo") macro.call(line.replace(",", "%2C")) except: exception("setting car info failed!") except KeyboardInterrupt: raise except Exception as e: exception(e) time.sleep(1.) try: time.sleep(1.) client = PiHttpClient("127.0.0.1") macro = Macro(client, "getPitInfo") data = macro.call() if data: debug("Sending: %s" % data) serial.writelines(data + "\n") except KeyboardInterrupt: raise except Exception as e: exception(e) time.sleep(1.) except KeyboardInterrupt: info("*** Ctrl-C keyboard interrupt ***")
PORT = argv[1] UNIT = int(argv[2]) FC = int(argv[3]) ADD = int(argv[4]) LEN = int(argv[5]) lLEN = LEN & 0x00FF mLEN = LEN >> 8 if (FC < 3): BYT = (lambda x: x / 8 if (x % 8 == 0) else x / 8 + 1)(LEN) #Round off the no. of bytes else: BYT = LEN * 2 lADD = ADD & 0x00FF mADD = (ADD & 0xFF00) >> 8 s = Serial('/dev/' + PORT, timeout=0.5) s.baudrate = 9600 s.parity = "E" s.databits = 8 s.stopbits = 1 s.handshake = "none" s.datatype = "raw" cmd = array('B', [UNIT, FC, mADD, lADD, mLEN, lLEN]) cmd.extend(CRC(cmd)) #lcrc = crc & 0x00FF #mcrc = (crc & 0xFF00)>>8 #cmd = array('B', [UNIT,FC,mADD,lADD,mLEN,lLEN,lcrc,mcrc]) while 1: s.write(cmd) print cmd sleep(1) read = s.read(255)
minutes = seconds // 60 seconds %= 60 goal = current + timedelta(hours=hours, minutes=minutes, seconds=seconds) if not sameday and current.day == goal.day: goal += timedelta(hours=24) hours += 24 print("Alarm Set To:", goal) print("Which is in...") print(hours // 24, "days,") print(hours % 24, "hours,") print(minutes, "minutes,") print(seconds, "seconds") half_days = hours // 12 hours %= 12 seconds = (seconds << 2) | 1 minutes = (minutes << 2) | 2 hours = (hours << 4) | 8 half_days = (half_days << 5) | 16 ser = Serial() ser.port = port ser.baudrate = baud ser.setDTR(False) ser.open() ser.write(bytes([seconds, minutes, hours, half_days, 128])) ser.close()
import struct import time from serial import Serial ser = Serial() ser.port = 'COM8' ser.baudrate = 115200 ser.timeout = 0.5 ser.dtr = 0 ser.open() print("Is Serial Port Open:", ser.isOpen()) var = struct.pack('<BBHHHHHHHdddHHdddHHdHHH', 69,7,1,60,120,250,150,10,200,3.5,2,2.4,5,200,2.5,1.9,2.4,10,8,2,20,120,0) # B for unsigned char, takes an int # d for double, takes a float # < for little-endian, as programmed on FRDM board thru Simulink print("To send (in binary): ", var) print("Size of string representation is {}.".format(struct.calcsize('<BBB'))) #print("To send (in decimal): ", struct.unpack('<BBB',var)) #var = struct.unpack('<BBB',var) print("send1",ser.write(var)) #time.sleep(1) var = struct.pack('<BBHHHHHHHdddHHdddHHdHHH', 69,21,1,60,120,250,150,10,200,3.5,2,2.4,5,200,2.5,1.9,2.4,10,8,2,20,120,0) ser.write(var) #time.sleep(1) print("reading...") values = ser.read(100) print(values) print("Done")
def run(self, args): self.discover() port = args.serial_port or self.e.guess_serial_port() board = self.e.board_model(args.board_model) protocol = board["upload"]["protocol"] if protocol == "stk500": # if v1 is not specifid explicitly avrdude will # try v2 first and fail protocol = "stk500v1" if not os.path.exists(port): raise Abort("%s doesn't exist. Is Arduino connected?" % port) # send a hangup signal when the last process closes the tty file_switch = "-f" if platform.system() == "Darwin" else "-F" ret = subprocess.call([self.e["stty"], file_switch, port, "hupcl"]) if ret: raise Abort("stty failed") # pulse on DTR try: s = Serial(port, 115200) except SerialException as e: raise Abort(str(e)) s.setDTR(False) sleep(0.1) s.setDTR(True) s.close() # Need to do a little dance for Leonardo and derivatives: # open then close the port at the magic baudrate (usually 1200 bps) first # to signal to the sketch that it should reset into bootloader. after doing # this wait a moment for the bootloader to enumerate. On Windows, also must # deal with the fact that the COM port number changes from bootloader to # sketch. if board["bootloader"]["path"] == "caterina": caterina_port = None before = self.e.list_serial_ports() if port in before: # The reset code was only working intermittently... # This is very kludgy, but works to force a reset by # opening and closing the port repeatedly at 1200 baud # until an exception is caught ser = Serial() ser.port = port ser.baudrate = 1200 reset_attempts_remaining = 10 while reset_attempts_remaining > 0: reset_attempts_remaining -= 1 try: ser.open() ser.close() sleep(0.3) except: # Exception means reset is in progress attemptsRemaining = 0 else: if reset_attempts_remaining == 0: print "Could not force reset" # Scanning for available ports seems to open the port or # otherwise assert DTR, which would cancel the WDT reset if # it happened within 250 ms. So we wait until the reset should # have already occured before we start scanning. if platform.system() != "Darwin": sleep(0.3) elapsed = 0 enum_delay = 0.25 while elapsed < 10: now = self.e.list_serial_ports() diff = list(set(now) - set(before)) if diff: caterina_port = diff[0] break before = now sleep(enum_delay) elapsed += enum_delay if caterina_port == None: raise Abort( "Couldn’t find a Leonardo on the selected port. " "Check that you have the correct port selected. " "If it is correct, try pressing the board's reset " "button after initiating the upload." ) port = caterina_port # call avrdude to upload .hex subprocess.call( [ self.e["avrdude"], "-C", self.e["avrdude.conf"], "-p", board["build"]["mcu"], "-P", port, "-c", protocol, "-b", board["upload"]["speed"], "-D", "-U", "flash:w:%s:i" % self.e["hex_path"], ] )
import numpy as np image = cv2.imread("tornado.jpg",0) #image= np.array(ima,dtype = ) print(image.dtype) rows,cols = image.shape print(rows) print(cols) print(image) image.flatten() print(len(image)) serialPort = Serial("/dev/ttyUSB0", timeout=10) serialPort.baudrate=input("Enter Baudrate :") if (serialPort.isOpen() == False): serialPort.open() outStr = '' inStr = '' serialPort.flushInput() serialPort.flushOutput() #for i, a in enumerate(range(33, 126)): # outStr += chr(a) #outStr=input("Enter data to be transmitted: ") #outStr=outStr.encode() serialPort.setRTS(1)
def run(self, args): self.discover() board = self.e.board_model(args.board_model) protocol = board['upload']['protocol'] serialProgrammer = protocol != 'dapa' if protocol == 'stk500': # if v1 is not specifid explicitly avrdude will # try v2 first and fail protocol = 'stk500v1' if serialProgrammer: port = args.serial_port or self.e.guess_serial_port() else: port = args.serial_port or self.e.guess_par_port() if not os.path.exists(port): raise Abort("%s doesn't exist. Is Arduino connected?" % port) if serialProgrammer: # send a hangup signal when the last process closes the tty file_switch = '-f' if platform.system() == 'Darwin' else '-F' ret = subprocess.call([self.e['stty'], file_switch, port, 'hupcl']) if ret: raise Abort("stty failed") # pulse on DTR try: s = Serial(port, 115200) except SerialException as e: raise Abort(str(e)) s.setDTR(False) sleep(0.1) s.setDTR(True) s.close() # Need to do a little dance for Leonardo and derivatives: # open then close the port at the magic baudrate (usually 1200 bps) first # to signal to the sketch that it should reset into bootloader. after doing # this wait a moment for the bootloader to enumerate. On Windows, also must # deal with the fact that the COM port number changes from bootloader to # sketch. if board['bootloader']['path'] == "caterina": caterina_port = None before = self.e.list_serial_ports() if port in before: ser = Serial() ser.port = port ser.baudrate = 1200 ser.open() ser.close() # Scanning for available ports seems to open the port or # otherwise assert DTR, which would cancel the WDT reset if # it happened within 250 ms. So we wait until the reset should # have already occured before we start scanning. if platform.system() != 'Darwin': sleep(0.3) elapsed = 0 enum_delay = 0.25 while elapsed < 10: now = self.e.list_serial_ports() diff = list(set(now) - set(before)) if diff: caterina_port = diff[0] break before = now sleep(enum_delay) elapsed += enum_delay if caterina_port == None: raise Abort("Couldn’t find a Leonardo on the selected port. " "Check that you have the correct port selected. " "If it is correct, try pressing the board's reset " "button after initiating the upload.") port = caterina_port processArgs=[ self.e['avrdude'], '-C', self.e['avrdude.conf'], '-p', board['build']['mcu'], '-P', port, '-c', protocol, '-U', 'flash:w:%s:i' % self.e['hex_path'],] if serialProgrammer: processargs.append('-D') if 'speed' in board['upload']: processArgs.extend(['-b', board['upload']['speed']]) else: if 'speed' in board['upload']: processArgs.extend(['-i', board['upload']['speed']]) # call avrdude to upload .hex subprocess.call( processArgs )
def main(): args = parse_arguments() images = scan_for_images(args.folder) if len(images) == 0: print('Error: found no jpeg images in "%s".' % args.folder) sys.exit(1) print('Found %d images.' % len(images)) serial = Serial(args.port) serial.baudrate = args.baudrate print('Opened serial port %s.' % serial.name) print('Interval between pictures is %d seconds.' % args.interval) width = 0 height = 0 # display random pictures while True: time.sleep(args.interval) if width == 0: # connect to the Arduino and obtain screen size serial.write('C') width = int(serial.readline()) height = int(serial.readline()) print('Display is %dx%d.' % (width, height)) image = random.choice(images) print('Uploading "%s"...' % image) upload_image(image, serial, (width, height))