|Product Performed to Expectations:||8|
|Specifications were sufficient to design with:||10|
|Demo Software was of good quality:||8|
|Product was easy to use:||9|
|Support materials were available:||9|
|The price to performance ratio was good:||9|
|TotalScore:||53 / 60|
First of all thanks to element14 and bitscope for giving me the opportunity to roadtest the BitScope Micro.
In this review I will give some brief general remarks on the hardware, and then as promised in the application focus on using it with the Raspberry Pi.
We all had to wait some while after closing of the RoadTest, but on januari 29 I found this box in my mail:
BitScope Micro is a tiny mixed signal scope in probe featuring a mixed signal oscilloscope, test and measurement system. It's USB powered and like all BitScopes fully user programmable. It comes with a set of ten mixed signal mini-grabber test probes and powerful software for Windows, Mac OS X, Linux and Raspberry Pi. It's the ideal diagnostic and debugging tool for any analog, digital or logic circuit.
Last year I reviewed the Picoscope 2205A (http://www.element14.com/community/roadTestReviews/1705) which is a little bit similar device, although the 2205A doesn't support logic i/o. The Bitscope is much more flexible compared to the Picoscope, mainly due to its open software structure, with support for a broad range of platforms and possibilities to program it yourself.
Hardware wise the Picoscope is better compared to the bitscope. Although the BitScope Micro is advertised as a real dual channel digital oscilloscope with fully compensated 1MΩ / 20pF analog inputs, a standard BNC connector for connecting a common probe needs to be ordered separately (MP01 and MP02 probe adaptors). Furthermore, the maximum input range is -7.5 V ~ +10.8 V (1:1 probe), compared to +/- 20V for the Picoscope.
Some remarks on the software: Although the Bitscope is equipped with an arbitrary waveform generator (AWG), from the software it is not possible to design your own output trace, or output captured data, like you can with for instance the PicoScope. You only can output a sine, rectangle or ramp, and change the duty cycle.
There is chart recorder software available (bitscope-chart) but it is not very flexible, since the samplerate only can be set to slow, mid, fast and fastest. For my application where I needed a time interval of 60s I wrote my own Python software with output directly to the web via plot.ly. See below for details.
Looking at value for money the bitscope wins, because of its high flexibility and affordable price.
I was very curious how the Bitscope performs on a raspberry Pi. Currently I didn't have the Pi 2 available, so everything is tested on a Pi model B.
As I already told above the bitscope is rather flexible, which is definitely the case for running it on the Pi. Three approaches are available. First by using the GUI program on the Pi desktop. Second by running the Pi as a Bitscope server, and running the GUI on a connected computer and last but not least by writing your own program and calling Bitscope API functions, which I tested with Python.
First the software needs to be installed on the Pi. Go to Free BitScope Downloads. where you can download all available software for the Raspberry Pi. After downloading you can install the software using dpkg:
pi@zolderpi ~/bitscope_pi $sudo dpkg -i bitscope-dso_2.7.EA17H_armhf.deb pi@zolderpi ~/bitscope_pi $dpkg --info bitscope-dso_2.7.EA17H_armhf.deb new debian package, version 2.0. size 4606936 bytes: control archive=1468 bytes. 63 bytes, 2 lines conffiles 997 bytes, 24 lines control 1130 bytes, 16 lines md5sums 185 bytes, 7 lines * postinst #!/bin/sh 160 bytes, 5 lines * postrm #!/bin/sh Package: bitscope-dso Version: 2.7.EA17H Architecture: armhf Maintainer: BitScope Designs <email@example.com> Installed-Size: 8435 Depends: libatk1.0-0 (>= 1.12.4), libc6 (>= 2.13-28), libcairo-gobject2 (>= 1.10.0), libcairo2 (>= 1.2.4), libgdk-pixbuf2.0-0 (>= 2.22.0), libglib2.0-0 (>= 2.12.0), libgtk2.0-0 (>= 2.24.0), libpango1.0-0 (>= 1.14.0), libx11-6 Section: non-free/X11 Priority: extra Homepage: http://bitscope.com/software/dso Description: BitScope Virtual Test Instrument Application . BitScope DSO is a suite of high performance mixed signal virtual test, measurement and data acquisition instruments including: . * Digital Storage Oscilloscope * Mixed Signal Oscilloscope * Logic State Analyzer * Waveform Generator * Spectrum Analyzer * Data Recorder . It is designed for use with a BitScope but can also be used without one to replay data (previously captured with a BitScope) or connect remotely; see http://bitscope.com/software/?p=demo for details. pi@zolderpi ~/bitscope_pi $ pi@zolderpi ~/bitscope_pi $bitscope-dso
After installation the command: bitscope-dso starts the application:
Here you see the output of the arbitrary waveform generator (AWG) measured at channel A.
When running the Bitscope on the Raspberry Pi, often we want to access it remote. Actually in the example above this is what I did, since the Pi I'm using doesn't have a screen and keyboard connected. In I used my PC's screen and keyboard by remotely login and an X11 client for graphical display. Mac OS X Quartz in this case. While this solutions work in many cases it's not always ideal; not everyone has an X server based host and VNC can be tricky to use in some situations. Here is where the bitscope server solution comes in. Details can be found on the website of Bitscope (BitScope Server | Shared remote access for any BitScope.).
First I installed and started the server software:
pi@zolderpi ~/bitscope_pi $ sudo dpkg -i bitscope-server_1.0.EA20A_armhf.deb Selecting previously unselected package bitscope-server. (Reading database ... 69844 files and directories currently installed.) Unpacking bitscope-server (from bitscope-server_1.0.EA20A_armhf.deb) ... Setting up bitscope-server (1.0.EA20A) ... Processing triggers for desktop-file-utils ... Processing triggers for menu ... pi@zolderpi ~/bitscope_pi $ dpkg --info bitscope-server_1.0.EA20A_armhf.deb new debian package, version 2.0. size 541520 bytes: control archive=1302 bytes. 27 bytes, 1 lines conffiles 577 bytes, 15 lines control 1262 bytes, 17 lines md5sums 185 bytes, 7 lines * postinst #!/bin/sh 160 bytes, 5 lines * postrm #!/bin/sh Package: bitscope-server Version: 1.0.EA20A Architecture: armhf Maintainer: BitScope Designs <firstname.lastname@example.org> Installed-Size: 1341 Depends: libc6 (>= 2.13-28) Section: non-free/network Priority: extra Homepage: http://bitscope.com/software/dso Description: BitScope Device Server . BitScope Server makes BitScopes available as network connected devices via UDP or TCP transport layers in the same way that Network BitScopes do natively. It allows USB and Serial BitScopes to be accessed via the network when connected to a PC or embedded system (e.g. Raspberry Pi). pi@zolderpi ~/bitscope_pi $ pi@zolderpi ~/bitscope_pi $ bitscope-server --help Usage: bitscope-server <options> -h,-?,--help | print this help -v,--verbose | verbose output, for debugging -c,--count N | open up to N devices (default:1) -p,--port P | open starting at port P (default:16385) -l,--latency L | assign server latency L in ms (default:8) -d,--daemon | start in daemon mode (from command line) -i,--install | register the daemon. This has no effect under unix. -u,--uninstall | unregister the daemon. This has no effect under unix. -r,--run | start the daemon. Windows does this. Do not do it manually. Assign a larger latency for lower CPU load if necessary. Use verbose from command line only. Note that only -h and -v are implemented in this beta release. pi@zolderpi ~/bitscope_pi $ bitscope-server
Now I started Bitscope-dso on the remote PC and selected the Pi as input device:
And after pressing power its running as if it were a local usb connected Bitscope:
In my opinion the most interesting mode is to use the application programming interface (API) and program the Bitscope directly from Python.
In order to do so the following actions need to be done:
$ sudo apt-get install python-dev $ sudo python setup-bitlib.py install $ rm -r build $ python test-bitlib.py Starting: Attempting to open one device... Library: 2.0 DK06A (Python DC01L) Link: USB:/dev/ttyUSB0 BitScope: BS000500 (DL28MS13) Channels: 10 (2 analog + 8 logic) Modes: FAST DUAL MIXED LOGIC STREAM Capture: 12288 @ 40000000Hz = 0.000307s (LOGIC) Offset: +2.017V to -5.317V POD: 11.00V 5.20V 3.50V 1.10V 0.52V Data(5): 0.128906, 0.085938, 0.085938, 0.128906, 0.085938 Finished: Library closed, resources released.
I wrote a small program which measures the output voltage of a solar pannel with an interval of 60s.
The output is graphed at plot.ly.
Here is a picture of the setup:
And the Python code:
# quick and dirty bitscope/plotly test # Gerrit Polder, february, 2015 import plotly.plotly as py from plotly.graph_objs import * import time import datetime from bitlib import * MY_DEVICE = 0 # one open device only MY_CHANNEL = 0 # channel to capture and display MY_PROBE_FILE = "" # default probe file if unspecified MY_MODE = BL_MODE_FAST # preferred capture mode MY_RATE = 1000000 # default sample rate we'll use for capture. MY_SIZE = 1 # number of samples we'll capture (simply a connectivity test) TRUE = 1 SAMPLE_RATE = 60 # in seconds MODES = ("FAST","DUAL","MIXED","LOGIC","STREAM") SOURCES = ("POD","BNC","X10","X20","X50","ALT","GND") layout = Layout( title='Raspberry Pi Bitscope Data' ) # # Open the first device found (only) # print "Starting: Attempting to open one device..." if BL_Open(MY_PROBE_FILE,1): # # Open succeeded (report versions). # print " Library: %s (%s)" % ( BL_Version(BL_VERSION_LIBRARY), BL_Version(BL_VERSION_BINDING)) # # Select this device (optional, it's already selected). # BL_Select(BL_SELECT_DEVICE,MY_DEVICE) # # Report the link, device and channel information. # print " Link: %s" % BL_Name(0) print "BitScope: %s (%s)" % (BL_Version(BL_VERSION_DEVICE),BL_ID()) print "Channels: %d (%d analog + %d logic)" % ( BL_Count(BL_COUNT_ANALOG)+BL_Count(BL_COUNT_LOGIC), BL_Count(BL_COUNT_ANALOG),BL_Count(BL_COUNT_LOGIC)) # # Determine which modes the device supports. # print " Modes:" + "".join(["%s" % ( (" " + MODES[i]) if i == BL_Mode(i) else "") for i in range(len(MODES))]) # # Report canonic capture specification in LOGIC (if supported) or FAST mode (otherwise. # BL_Mode(BL_MODE_LOGIC) == BL_MODE_LOGIC or BL_Mode(BL_MODE_FAST) print " Capture: %d @ %.0fHz = %fs (%s)" % ( BL_Size(),BL_Rate(), BL_Time(),MODES[BL_Mode()]) # # Report the maximum offset range (if the device supports offsets). # BL_Range(BL_Count(BL_COUNT_RANGE)); if BL_Offset(-1000) != BL_Offset(1000): print " Offset: %+.4gV to %+.4gV" % ( BL_Offset(1000), BL_Offset(-1000)) # # Report the input source provided by the device and their respective ranges. # for i in range(len(SOURCES)): if i == BL_Select(2,i): print " %s: " % SOURCES[i] + " ".join(["%5.2fV" % BL_Range(n) for n in range(BL_Count(3)-1,-1,-1)]) # # Set up to capture MY_SIZE samples at MY_RATE from CH-A via the POD input using the highest range. # BL_Mode(MY_MODE) # prefered capture mode BL_Intro(BL_ZERO); # optional, default BL_ZERO BL_Delay(BL_ZERO); # optional, default BL_ZERO BL_Rate(MY_RATE); # optional, default BL_MAX_RATE BL_Size(MY_SIZE); # optional default BL_MAX_SIZE BL_Select(BL_SELECT_CHANNEL,MY_CHANNEL); # choose the channel BL_Trigger(BL_ZERO,BL_TRIG_RISE); # optional when untriggered */ BL_Select(BL_SELECT_SOURCE,BL_SOURCE_POD); # use the POD input */ BL_Range(BL_Count(BL_COUNT_RANGE)); # maximum range BL_Offset(BL_ZERO); # optional, default 0 BL_Enable(TRUE); # at least one channel must be initialised #the main sensor reading loop printurl = True while True: # # Perform an (untriggered) trace (this is the actual data capture). # BL_Trace() # # Acquire (i.e. upload) the captured data (which may be less than MY_SIZE!). # DATA = BL_Acquire() print " Data(%d): " % MY_SIZE + ", ".join(["%f" % DATA[n] for n in range(len(DATA))]) sensor_data = DATA trace = Scatter( x=datetime.datetime.now(), y=sensor_data, mode='lines+markers' ) fig = Figure(data=[trace], layout=layout) url = py.plot(fig, filename='Raspberry Pi Bitscope Values', fileopt='extend') if printurl: print url printurl = False time.sleep(SAMPLE_RATE) # # Close the library to release resources (we're done). # BL_Close() print "Finished: Library closed, resources released." else: print " FAILED: device not found (check your probe file)."
Which results in:
This concludes my review, thanks for reading, and if there are any questions left, please add a comment below.