USB-based Oscilloscope (beta)

This is NOT considered as an oscilloscope yet. It's just a preparation of making a real PIC18F USB-based oscilloscope. For my initial testing, I used my PIC18F and PyUSB demo, same hardware and firmware for the 18F2550. The only difference is in the GUI, instead of PyQt QDial, I use PyQwt PlotCurve widget.

the Python script: (compatible with my Portable Eric 4 Python IDE (v2))

 #################################  
 # USB-based oscillpscope (beta)  
 # using pyUSB and PyQt/PyQwt  
 #################################  
   
 import sys, usb  
 from PyQt4.QtCore import *  
 from PyQt4.QtGui import *  
 from PyQt4.Qwt5 import *  
 from PyQt4.Qwt5.anynumpy import *  
   
 class UsbPic:  
   def __init__(self, vendor_id, product_id):  
     busses = usb.busses() # enumerate busses  
     self.handle = None  
     for bus in busses:  
       devices = bus.devices  
       for dev in devices:  
         if dev.idVendor==vendor_id and dev.idProduct==product_id: # device matches  
           self.dev = dev  
           self.conf = self.dev.configurations[0]  
           self.intf = self.conf.interfaces[0][0]  
           self.endpoints = []  
           for endpoint in self.intf.endpoints:  
             self.endpoints.append(endpoint)  
           return  
       
   def open(self):  
     if self.handle:  
       self.handle = None  
     try:  
       self.handle = self.dev.open()  
       self.handle.detachKernelDriver(0)  
       self.handle.detachKernelDriver(1)  
       self.handle.setConfiguration(self.conf)  
       self.handle.claimInterface(self.intf)  
       self.handle.setAltInterface(self.intf)  
       return True  
     except:  
       return False  
   
   def write(self, ep, buff, timeout = 100):  
     try:  
       return self.handle.interruptWrite(ep, buff, timeout) #return bytes written  
     except:  
       return 0  
   def read(self, ep, size, timeout = 100):  
     try:  
       return self.handle.interruptRead(ep, size, timeout) # return data read  
     except:  
       return []  
   def getDeviceName(self):  
     return self.handle.getString(2, 40)  
   
 class AmplitudevsTime(QwtPlot):  
   def __init__(self):  
     QwtPlot.__init__(self)  
     self.setTitle("<font size=1 color=darkblue>Potentiometer Position ( 8-bit ADC value )</font>")  
     self.setCanvasBackground(Qt.black)      
     #grid  
     grid = QwtPlotGrid()  
     #grid.enableXMin(True)  
     #grid.enableYMin(True)  
     grid.setMajPen(QPen(Qt.darkGreen, 0, Qt.DotLine))  
     grid.setMinPen(QPen(Qt.darkGreen, 0 , Qt.DotLine))  
     grid.attach(self)  
     # x-axis  
     self.setAxisTitle(QwtPlot.xBottom, "<font size=1 color=darkred>time (seconds)</font>")  
     self.timerange = arange(0.0, 60, 0.2) #60 seconds, 200 ms interval  
     self.amplitudes = zeros(len(self.timerange), Float)  
     # curve  
     self.amplitude_plot = QwtPlotCurve('Amplitude')  
     self.setAxisScale(QwtPlot.yLeft, 0, 255) #amplitude range : 0 to 255  
     self.setAxisScale(QwtPlot.xBottom, 0, 60) #time range: 0 to 60 seconds  
     self.amplitude_plot.setPen(QPen(Qt.yellow))  
     self.amplitude_plot.attach(self)  
     
   def updatePlot(self, new_value=0):  
     # shift amplitude array left and assign new value to z[n-1].  
     self.amplitudes = concatenate((self.amplitudes[1:], self.amplitudes[:1]), 1)  
     self.amplitudes[-1] = new_value  
     self.amplitude_plot.setData(self.timerange, self.amplitudes)  
     self.replot()  
   
 class MyForm(QDialog):  
   def __init__(self, parent = None):  
     super(MyForm, self).__init__(parent)  
     self.setWindowTitle("USB-based Oscilloscope (Beta) - pYUSb + PIC18F2550")  
     self.setMinimumSize(560, 300)      
     # create widgets/controls  
     self.connect_btn = QPushButton('Connect')  
     self.toggle1_btn = QPushButton('Toggle LED1')  
     self.toggle2_btn = QPushButton('Toggle LED2')  
     self.status_label = QLabel('press "Connect" button')  
     self.update_timer = QTimer()  
       
     self.display = AmplitudevsTime()  
       
     layout = QGridLayout()  
     layout.addWidget(self.display, 0, 0, 10, 15)  
     layout.addWidget(self.toggle1_btn, 2, 15)  
     layout.addWidget(self.toggle2_btn, 2, 16)  
     layout.addWidget(self.connect_btn, 7, 15)  
     layout.addWidget(self.status_label, 4, 15, 2, 2)  
     self.setLayout(layout)  
     # widgets initial condition  
     self.toggle1_btn.setEnabled(False)  
     self.toggle2_btn.setEnabled(False)  
     # signals  
     self.connect(self.connect_btn, SIGNAL("clicked()"), self.DeviceConnect)  
     self.connect(self.toggle1_btn, SIGNAL("clicked()"), self.toggleLED1)  
     self.connect(self.toggle2_btn, SIGNAL("clicked()"), self.toggleLED2)  
     self.connect(self.update_timer, SIGNAL("timeout()"), self.updateDisplay)  
     
   def DeviceConnect(self):  
     self.device = UsbPic(0x04d8, 0x0204) # Microchip Vendor ID and Product ID  
     if self.device.open():  
       self.toggle1_btn.setEnabled(True)  
       self.toggle2_btn.setEnabled(True)  
       self.update_timer.start(200) # update every 200ms  
       self.status_label.setText('Connected to:\n %s' %self.device.getDeviceName())  
     else:  
       self.toggle1_btn.setEnabled(False)  
       self.toggle2_btn.setEnabled(False)  
       self.update_timer.stop()  
       self.status_label.setText('Warning:\n No Device Found!')  
   def toggleLED1(self):  
     self.device.write(1, [0x80], 1000)      
   def toggleLED2(self):  
     self.device.write(1, [0x82], 1000)  
   def updateDisplay(self):  
     self.device.write(1, [0x81])  
     byteread = self.device.read(0x81, 64)  
     if len(byteread)>1:  
       self.display.updatePlot(byteread[1])  
   
 if __name__ == "__main__":  
   app = QApplication(sys.argv)  
   form = MyForm()  
   form.show()  
   sys.exit(app.exec_())  

Right now, my problem is on the 18F2550 side. I still don't know how to use both the USB and ADC interrupts together. My first modification on PIC's firmware was no success. When I enabled the ADC interrupt routine, the whole program response slows down. I still have to read properly the datasheet(plus application notes), and ask for help of the 'masters'. What I'm currently doing on the code is reading a single byte of ADC value every 200ms (very slow!). From what I've understand, the PIC can (it should) send 64 bytes for every USB interrupt read request. I don't know how fast it is, but it will surely improve the PIC18F USB-based oscilloscope.