BitScope Micro Oscilloscope & Analyzer - Review

Table of contents

RoadTest: BitScope Micro Oscilloscope & Analyzer

Author: gpolder

Creation date:

Evaluation Type: Independent Products

Did you receive all parts the manufacturer stated would be included in the package?: True

What other parts do you consider comparable to this product?: Benchtop scopes, PicoScope

What were the biggest problems encountered?: limited analog input range. limited AWG software.

Detailed Review:

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:

 

 

 

General remarks

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.

 

Running on the Raspberry Pi

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.

 

Using the GUI program

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 <support@bitscope.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.

 

Using the bitscope server

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 <support@bitscope.com>
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:

 

Using Python

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:

 

  • download and unzip python-bindings from bitscope downloads

 

$ 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.
     

  • success!!!!


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[0]
  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:

    Raspberry Pi Bitscope Data (Solar Panel voltage during eclipse of March 20)

 

 

This concludes my review, thanks for reading, and if there are any questions left, please add a comment below.

Anonymous