CCProbe Source

CCProbe supports sensor and model-based visualization and analysis along with a Lab Notebook for saving and communicating probe data and views. Written in Waba and available under the GPL it runs on PalmOS, WinCE, PocketPC, Windows, MacOS, and Linux.

CCProbe Copyright (c) 2002 by Concord Consortium, All Rights Reserved, available under the GNU General Public License

CCProbe is part of the CCProbeware and OSLET efforts at the Concord Consortium.  

CCProbe Architecture

CCProbe Source Code

---

CCProbe Source Code

The CCProbe source distribution should build on any Unix/Linux/MacOSX system with a minimal set of GNU building tools.

CCProbe Source version: , build: , date:

• CCProbe Source [ ccprobe-src.tar.gz]
• CCBeam Source [ CCBeam.tar.gz]

MacOSX Note: Don't use Stuffit to expand the archive. Use the following shell command instead:

  tar -xzf ccprobe-src.tar.gz

Building CCProbe from the ccprobe-src.tar.gz tarball archive:

  tar -xzf ccprobe-src.tar.gz

  cd ccprobe-src/CCProbe
  make build-local
  cd ../XML2LabBook
  make
  cd ../CCProbe/CCProbeXML
  ./make-xml
  ./make-labbook
  ./ccprobe

*** Problem building CCProbe.prc on MacOSX ***

We were having problems building Pila, the Palm assembler on MacOS X. These problems seem to be fixed. If you are still having problems you can get a complied copy of Pila for MacOSX, copy it to the ccprobe-src/palmtools/bin directory, and make it executable (chmod +x pila).. You can get a copy here:

ftp://www.concord.org/pub/ccprobeware/src/pila-for-macosx/pila

---

CCProbe Architecture

CCProbe is built from several packages (libraries).

Starting from the base.

waba

Waba includes a set of packages that handle input/output(io), user interface(ui), utilties (util), effects (fx), and system (sys). These packages are similar to the java api classes. However they only have very basic functionality. We use three implementations of waba: wabajump for the palm, superwaba for windows CE, and a modified version of the original waba that runs on Java.

wabajump

This consists of the waba classes implemented using Palm system calls. (Peter Carrol, Rod Montrose) These classes access the system calls through Jump. Jump is a tool that compiles the class files to palm assembly code. The compiled classes are linked with Jump's core of PalmOS api functions. The source for Jump is currently not included, we use a slightly modified version which is being folded back into a general distribution of Jump. (Rod Montrose, Peter Dickerson, Ralf) The files needed for our version of Jump are in wj_tools. To create the palm application two other tools are needed: pila and pilrc. pilrc creates palm resources. pila compiles the assembly and resources in a palm application. These tools are located in the palmtools directory.

superwaba

This includes a virtual machine for Pocket PC, and PalmOS devices. It also includes its own implementation of the waba classes.We use wabajump on the palm instead of superwaba, because wabajump is faster and supports larger applications. (Guich)

wabasdk

This is the name we've given to our version of the waba classes that run in a standard java virtual machine. This includes an implementation of SerialPort class that works on Windows, Mac, and Linux

wextras

This collection of packages is derived from a collection put together by Rob Nielson. We have significantly expanded on those original classes. This package includes UI controls, extended stream functionality, math utilities, object property utilities, and java versions of the programs that combine waba classes into "warp" files needed by the waba vm on the pocket pc. The UI controls include: multi-line text, simple vector drawing, popup dialogs, tabbed property panes, scroll bar, tree control, table control, popup lists, and menu bars.

ReleaseSystem

This is a collection of Makefile libraries that handle building the following packages. We'd like to convert this system to Ant. Ant is java based build system.

wgraph

This is a collection of graphing classes. Currently it supports bar and line graphs. The line graphs have a UI that allows the user to drag and zoom the graph.

ProbeLib

This is intended to be a generic api that can support different types of probe systems. Currently only the CC a2d2 version 1 and 2 are supported. It only handles streaming data from the serial port. We'd like to extend it to support data logging devices, and remote probes that send data via TCP/IP. It also contains CCUnit which is a class that provides unit conversion, unit arithmetic, and unit prefixes.

LabBook

This is really three packages in one. The first is a simple object oriented database, that supports supports sessions. The fundamental object of this database is a "dictionary". Each contains an indexed list of pointers to other objects in the database. This database can save its data as a palm catalog, or in a seekable file. Soon it will have built in object versioning, users, and synchronization between two databases. The second package is a user interface api that supports dynamically embedded objects. The third package is a collection of base "objects" that can be stored in the database and implement the embedded object api. These include: Notes, Drawings, Images, and SuperNotes. The first three are obvious. SuperNotes support the creation of compound documents. These document can have any LabBook object embedded in them. They can also have links to LabBook objects.

CCProbe

This is really two packages in one. The first is a collection of of LabBook objects that add probeware functionality to the database. These objects are: Probe, Transform, Graph, DataSet, Annotation, DataCollector, and UnitConvertor. The Probe object saves settings about the different physical probes that are being used. The Graph object saves and displays line and bar graphs. This includes the axis settings, and the data sources of the graph. The DataSet object saves data and its associated Annotations. Annotations are associated with a particular DataSet and piece of data in that set. They contain notes about that data. DataCollector tie together Graphs, and Probes. The UnitConvertor is a tool that can used convert compatible units. The second part of CCProbe is the main application class that registers all these new LabBook objects with the LabBook database.

For more information on the projects that are supporting CCProbe (including descriptions of curriculum and hardware) go to the CCProbeware page.