current community

your communities

more stack exchange communities

Stack Exchange
tour help
stack overflow careers
Take the 2-minute tour ×
Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no registration required.
up vote 0 down vote favorite
1

I'm working on a little project using the MaxSonar EZ1 ultrasonic range sensor and Arduino Diecimila.

Using the MaxSonar playground code, I have Arduino writing the number of inches to serial every .5 seconds, along with a delimiter. When monitoring the serial data, the output looks similar to:

5.13.15.12.123.39.345...

On the Python side, I have a basic Flask app with a /distance route that returns a JSON object with the serial value:

from flask import Flask
from flask import render_template
import serial
import json
import random

app = Flask(__name__,
            static_folder="public",
            template_folder="templates")

port = "/dev/tty.usbserial-A6004amR"
ser = serial.Serial(port,9600)

@app.route("/")
def index():
  return render_template('index.html')

@app.route("/distance")
def distance():
  distance = read_distance_from_serial()
  return json.dumps({'distance': distance})

def read_distance_from_serial():
  x = ser.read();
  a = '';
  while x is not '.':
    a += x;
    x = ser.read()

  print(a)

  return a
  # return random.randint(1, 100)

if __name__ == "__main__":
  app.debug = True
  app.run()

And index.html is a basic site with some JS that polls /distance every half second for a new reading. With the value, I should be able to build an interesting UI that changes based on how close/far I am from the sonar.

$(document).ready(function() {

  window.GO = function() {

    this.frequency = 500; // .5 seconds

    this.init = function() {
      window.setInterval(this.update_distance, 500);
    }

    this.update_distance = function() {
      $.get('/distance', function(response) {
        var d = response.distance;
        $('#container').animate({"width": d + "%"});
      }, 'json')
    }
  }

  go = new GO();
  go.init();
});

The Question

The issue I'm running into is that there is no guarantee that when python reads from serial, that there will be a value. Often times, when it polls, I get either an empty value or a partial value, while other times it is spot on.

How can I change my technique such that I am able to consistently poll the serial data and receive the last good reading from the Arduino serial output?

share|improve this question

1 Answer 1

up vote 0 down vote

You want to set your serial reading to happen in the background and not on demand. You can use threading and Queue. You add your serial values to the Queue once you determine you have a valid value, and then your socket call simply pulls from the Queue. It'll be something like this:

from flask import Flask
from flask import render_template
import serial
import json
import random

import threading, Queue

import logging
logging.basicConfig(filename=__file__.replace('.py','.log'),level=logging.DEBUG,format='%(asctime)s [%(name)s.%(funcName)s] %(levelname)s: %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p', filemode='a')

class maxSonarSerialThread(threading.Thread):
  def __init__(self, dataQ, errQ, port=None, baudrate=None):
    self.logger = logging.getLogger('sonarSerialThread')
    self.logger.debug('initializing')
    threading.Thread.__init__(self)
    self.ser = serial.Serial()
    self.ser.timeout = 1
    if port is None:
      self.ser.port = "/dev/tty.usbserial-A6004amR"
    else:
      self.ser.port = port
    if baudrate is None:
      self.baudrate = 115200
    else:
      self.baudrate = baudrate
    #self.ser.flushInput()
    self.readCount = 0
    self.sleepDurSec = 5
    self.waitMaxSec = self.sleepDurSec * self.ser.baudrate / 10
    self.dataQ = dataQ
    self.errQ = errQ
    self.keepAlive = True
    self.stoprequest = threading.Event()
    self.setDaemon(True)
    self.dat = None
    self.inputStarted = False
    self.ver = ver

  def run(self):
    self.logger.debug('running')
    dataIn = False
    while not self.stoprequest.isSet():
      if not self.isOpen():
        self.connectForStream()

      while self.keepAlive:
        dat = self.ser.readline()
        //some data validation goes here before adding to Queue...
        self.dataQ.put(dat)
        if not self.inputStarted:
          self.logger.debug('reading')
        self.inputStarted = True
      self.dat.close()
      self.close()
      self.join_fin()

  def join_fin(self):
    self.logger.debug('stopping')
    self.stoprequest.set()

  def connectForStream(self, debug=True):
    '''Attempt to connect to the serial port and fail after waitMaxSec seconds'''
    self.logger.debug('connecting')
    if not self.isOpen():
      self.logger.debug('not open, trying to open')
      try:
        self.open()
      except serial.serialutil.SerialException:
        self.logger.debug('Unable to use port ' + str(self.ser.port) + ', please verify and try again')
        return
    while self.readline() == '' and self.readCount < self.waitMaxSec and self.keepAlive:
        self.logger.debug('reading initial')
        self.readCount += self.sleepDurSec
        if not self.readCount % (self.ser.baudrate / 100):
          self.logger.debug("Verifying MaxSonar data..")
          //some sanity check

    if self.readCount >= self.waitMaxSec:
        self.logger.debug('Unable to read from MaxSonar...')
        self.close()
        return False
    else:
      self.logger.debug('MaxSonar data is streaming...')

    return True

  def isOpen(self):
    self.logger.debug('Open? ' + str(self.ser.isOpen()))
    return self.ser.isOpen()

  def open(self):
    self.ser.open()

  def stopDataAquisition(self):
    self.logger.debug('Falsifying keepAlive')
    self.keepAlive = False

  def close(self):
    self.logger.debug('closing')
    self.stopDataAquisition()
    self.ser.close()

  def write(self, msg):
    self.ser.write(msg)

  def readline(self):
    return self.ser.readline()


app = Flask(__name__,
            static_folder="public",
            template_folder="templates")

port = "/dev/tty.usbserial-A6004amR"
dataQ = Queue.Queue()
errQ = Queue.Queue()
ser = maxSonarSerialThread(dataQ, errQ, port=port, ver=self.hwVersion)
ser.daemon = True
ser.start()

@app.route("/")
def index():
  return render_template('index.html')

@app.route("/distance")
def distance():
  distance = read_distance_from_serial()
  return json.dumps({'distance': distance})

def read_distance_from_serial():
  a = dataQ.get()
  print str(a)
  return a

You'll need to add a method to join the thread for a graceful exit, but that should get you going

share|improve this answer
    
Won't the background thread face the same problem of potentially being out of sync with when arduino writes to serial? –  doremi Sep 12 '13 at 4:59
    
The background thread is constantly reading from the socket, which means you'll get everything the Arduino puts in rather than whatever is in whatever buffer at the time you poll it. Instead, you're polling the Queue of valid values. If the Queue is empty when you request a value, then you're ahead of the Arduino. Or you know it has had some problem. You can also log in the serial thread to see what's happening. Regardless, your server will have available all the Arduino data between requests for the next rather than an arbitrary chunk of it. –  wwwslinger Sep 12 '13 at 5:48
    
And if you want to control some sort of sampling rate, simply add a count based on the native sampling rate and only add to the dataQ every 1000 reads, for example. You can also read to the end of the dataQ for your output to empty it and control sampling that way. You just have far more control if you don't read from the serial on demand. –  wwwslinger Sep 15 '13 at 4:14

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.