LabView and Low-Level Programming

Building a control system is a bit new, I admit. Not completely, but the
models I’ve used in the past are in Python or Octave. And I’ve a bit
of experience with C, Java and Perl in terms of programming.

Once upon a time, many long years ago, I learned LabView. It’s sort of
like Legos, you find the function you want by browsing through icons
(much like sifting through the Lego bin). You plunk it down and wire
it together and you’ve got a program. I do mean wire, by the way. It
looks like the visual representation of spaghetti code. But you can
create your own functions pretty easily which helps cut down on that.

Now, I learned it way back in my first round of college. At that time
I knew Perl and a smattering of C. It’s really good at creating a
scientific-looking UI, with buttons and dials and oscilloscopes. The
back-end… well, I like typing more than I like plunking things down
with the mouse.

But LabView is what we’re using because the hardware we have is from
National Instruments and runs LabView natively. It seems to be the
standard, and not C as I was expecting hoping. But, when in Rome and
all that. (I mean, that’s how I picked up Python, C# a wee bit of
Visual Basic and Ruby. I’m adaptable that way.)

So I’m going low-level with a graphical programming language.

The main thing I’m doing is adapting the control system we have from
one piece of hardware (PXI) to another piece of hardware
(CompactRio). Both are interesting in different ways, and I’ve not
used either of them before. (I’m used to a *nix server based somewhere
in the distance where I move little bits around. Or throw little bits
against other bits in an attempt to break things. But in a systematic
way.)

This, it turns out, is not so easy. Part of it is the learning curve
on my part, I’m sure. It’s an unfamiliar language. And I’m doing
unfamiliar things with it. Even with the Arduino I was mainly using
slightly higher-level C functions. The closest thing to this was
on the Motorola 68k, back a few years ago. I wrote a real time OS
(albeit a simple one), so the concept isn’t unfamiliar.

So I’m spending my time trying to read sensors. I figured it out
pretty well on the PXI – the old hardware. I was reading in sensors
and sending data up to the workstation (my desktop). I could see it
coming through, and I could log it. It was pretty cool.

But the PXI is much like my Windows machine. Things are familiar, more
or less. It has more serial ports, more dedicated functionality, but
there are reasonably high level function boxes to deal with it.

The Compact Rio is a FPGA. Not quite a computer in the same way, I
have discovered. It requires a little special handling. Which, really,
is kind of cool because I get to go down and get my hands dirty in the
nitty-gritty.

Well, as nitty-gritty as you can get in a picture-based view of the
world. This is what I’m working on now. The goal is to get the ROV
back in the water by the end of February. I think it’s achievable. I’m
getting along well, for the most part. Though it would help if I
didn’t run into various LabView bugs. At least I have enough
experience to not spin my wheels too long on these sorts of problems.

That’s what I did last week, in terms of my research project. This
week is pretty much more of the same. I’ll try to make the next post
slightly more interesting, though.#+TITLE: Week 05 – 28 Jan

Leave a Reply