Skip navigation
> RoadTest Reviews

BitScope Micro Oscilloscope & Analyzer - Review

Scoring

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
  • RoadTest: BitScope Micro Oscilloscope & Analyzer
  • Buy Now
  • Evaluation Type: Independent Products
  • Was everything in the box required?: No - No bnc probe adapters
  • Comparable Products/Other parts you considered: 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:

     

    iPhoto.png

     

     

    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:

    BitScope_DSO_2_7.png

    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:

    DSO_Configuration.png

    And after pressing power its running as if it were a local usb connected Bitscope:

    BitScope_DSO_2_6.png

     

    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:

    iPhoto.pngiPhoto.png


    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.


Comments

Also Enrolling

Enrollment Closes: Aug 16 
Enroll
Enrollment Closes: Jul 28 
Enroll
Enrollment Closes: Aug 10 
Enroll
Enrollment Closes: Jul 31 
Enroll
Enrollment Closes: Jul 26 
Enroll