Any of you who is using EPOS from MAXON motor and LabVIEW Real-Time might face the same problem with me. The RS232 -IMHO- is not fast enough to achieve real-time communication between the EPOS and RT controller, also I am using the LV-RT for the main program, thus it will be difficult to synchronize between two LVs program from two different computers which mainly caused by the communication overhead. The problem got worse when I knew that we could not download the EPOS dll file onto the RT. After getting my answer from NI forum, I decided to use the CAN Protocol which can reach up to 1Mbps.

For the first trial, we have the IXXAT CAN-USB device. The question is, how to interface USB device to the RT? Because if I use this device, then it will be RT <-> USB <-> CAN, which means that I need a driver for IXXAT CAN-USB for the RT! I emailed the IXXAT company, the engineer replied that they do not support the LV-RT. Anyway I successfully send command through CANOpen with this device on Windows platform, but it took 1 day for me to realize that I need to terminate the final CAN-bus with 120 Ohm. Fiuhh.. alhamdulillah it was working though

Then we bought the NI-CAN PXI 2 Port from NI with the OPENCan library. I successfully controlled the speed of the BLDC motor with the CANOPen using SDO only, but then I realized that there was a big delay between two SDO commands, which resulted almost 100% error (current speed – desired speed), currently I am going to write a new program by using both SDO and PDO.

I -insyaAllah- will continue this writing and explain briefly about SDO & PDO especially in the case of Maxon EPOS.

Monday, 4/feb/2007 @ 20:52 KST

The definition of CAN and CANOpen can be found by yourself in google . I will explain briefly what I have learned, the CANOpen method to control the Maxon Motor using EPOS, for more detail you can read the EPOS Application Note: CANOpen Basic Information (pdf).

In EPOS there is an important dictionary (the source of everything), called Object Dictionary Access. It contains the System parameter (e.g. PID tuning value, velocity, etc), the DataRecorder(Encoder counter, etc), and so on. To control the motor, these parameters need to be changed. We can change the value by 3 methods:

1. Directly click the field (of the column) and enter the desired value
2. Using the Serial communication RS232 protocol
3. CANOpen protocol

In the case of 1, you must be joking, but if you want to do it manually, no one can blame on you =P. The 2nd method, I have explained above, that it is not possible if we want to utilize the LabView RT, because there is a dll file which does not support the RT so it can not be downloaded onto the RT, unless you know how to reverse engineer this file and re-write your own code .

Now the 3rd method, with CANOpen there are 2 ways of writing the object dictionary access:

#1 is SDO (Service Data Object). It is a confirmed service, means that after you send the command, in between the timeout value you specified, there will be a confirmation packet which contains the value whether you successfully write the object or not.

#2 is PDO (Process Data Object). Opposite to the SDO, it is unconfirmed, thus it is very fast. But as a trade off, there are a “little” work to do, which is the PDO mapping.

At first time, I am using the SDO only, the problem is that, there is a big gap between sending the packet and receiving the confirmation packet, thus it become less real-time and worse, the data is not valid (I am writing a quite time critical program) .

Here’s some picture with SDO only:

If you take a look at the picture above the error looks very big, I guess it is caused by the delay of the SDO packets.

And in the above picture the error is very small with PDO packets.

And here is the video, if you need the code just write me a comment or send an email

This is an example program to initialize the Maxon EPOS through CANOpen. To be noted that the maxon UI Interface is always on when the lv program is running. Download here (rename the file to become .zip)!

Another basic article. My first time with LabView Real-Time. I decided to write a program to control an R/C servo motor with LV-RT. With PXI-7358, I decided to use the digital I/O, just by turning on and off the port according to the time constraint. I did not read the manual in detail, so I am afraid I missed something, but when I did a test how long the time took for turning the digital port from on to off was around 1.5 ms, and from on to off took 250 uS. It means that it is not possible to drive the R/C servo with digital I/O when the pulse needed should be between 200-2500 uS.

Here’s the code when I did a measurement on the time of digital I/O switching on-off:

I decided to utilize the PWM port. The algorithm is: turning on 100% PWM -> delay X uS -> turn on 0% PWM -> delay 10 ms (minimum), where X is the delay for the position desired, and then the servo could run smoothly.

Here’s the code:

As usual, for documentary (maybe when I am old I could see what I did in my “spare” time -hopefully not wasting my time-), here’s the video:

Again, still LabVIEW beginner. I am currently reading an ebook titled “LabVIEW based Advanced Instrumentation System” by S. Sumanthi and P. Surekha, and IMHO this is a good book for beginner. I wish I could finish reading this book as soon as possible, because time is what I do not have

Two days ago, I tried to control a stepper motor with ULN2803 and LabVIEW. FYI -again- I am new to LabVIEW, so don’t expect too much from this article. I have NI-PCI 6221 and NI-PXI 7358 with me, the later is specifically manufactured for motion controller but still it has the digital I/O. And in this article I am using the motion controller digital I/O to control the stepper, if you only have DAQmx you also still can use it to drive your stepper motor, because to control stepper motor only need digital output which you can generate from your DAQmx.

Here’s the LV source code:

This is the front panel where user can specify the speed, direction, number full step. In this case, I am using 1.8 degree stepper motor, which means for one full rotation I need 360/1.8 = 200 steps, then 200 steps/4 = 50 times iteration.

This is the source code when all condition is true:

This is the source code when all condition is false:

Here’s the video for the trial:

and I tried to test the accurateness of this stepper motor for one full cycle (50 iterations) you can watch here:

This stepper motor is not that accurate, for 2-3 trials it was okay but the next trial it lost its position, I tried several times and it still can not maintained its previous position, even though I used slower speed.

And here is the electronic connection I used for the ULN2803 you can find here.

Yesterday, I tried to control a stepper motor using the L297 IC driver, but then I realized that I need another IC which could drive high current to the motor, similar to darlington transistor arrays. The ICs are being purchased at the moment for the need of lab experiment taught by my friend.

Oh well, I decided to learn how to generate a simple PWM in PCI-6221 on LabView -as you know I am always new in this, too many functions available, and I am not used to graphical programming-.

I utilized the counter 0 (DevX/ctr0) to turn on a LED (light emitting diode) that it will flicker according to the signal given. For this card the LED is located on PFI 12 (pin number 2).

Here is the front panel, where user can interact with the program:

and here is the back panel for the main flow program:

I still not yet have the LabView Real-Time with me, my boss said it will arrive tomorrow. This program is written with LV 8.2 with the minimum delay is 1 ms. If you analyze the back panel above, when there’s a value change in the control form (the meter and vertical bar) for different duty cycle or frequency, the value will be updated inside the case structure. You can experiment by changing the duty cycle and frequency, and then look at the flicker rate and intensity of the LED.

If you removed the timed loop and changed with while loop, a problem will occur if the value change in the control form is faster that one period of loop cycle, thus LabView Run-Time will generate an error message. The reason is that, the changing is lot faster that one cycle loop which is 1 ms. With this timed loop, unnecessary changing is discarded, only values which are between the right time slot considered as input. If error happened the LED on front panel will be on.

If you don’t understand my explanation, you can download the vi program here (remove the .pdf extension).

AFAIK, NI provides three ways of programming for the instruments they produce, they are:

1. LabView, a graphical based programming
2. LabWindows/CVI, a GUI programming based on C language
3. Object Oriented Programming based language (C++, I am using MSVS2005)

You can see my desktop of these 3 “programming style:”

Programmers who used to code by writing programming syntax need to adapt the “programming style” if they choose the 1st method (graphical), and this is my reason to try all these methods by writing a small program for turning on a LED at line Port0/Line0, so that I could find the most comfortable and fastest way to develop a program.

I like the MSVS2005 programming environment because of the easiness provided by the IDE, rather than CVI which I am not used to it, but AFAIK, the MSVS2005 doesn’t provide a complete library compared to CVI and LabView and to my surprise I found in CVI sample code a goto syntax! oh..no

It looks like my whole program will be based on graphical programming, then I really need to design the states using FSM or statechart, otherwise it will be very difficult to debug the program, and oh yeah…documentation!!! Hope I am not lazy to do this

Old memory, I learned assembly first time when I were in Senior High School, 2nd grade. I learned how to write a .com program using debug. And now, after several struggle I managed to dig in my brain and wrote the tiny program

C:\>DEBUG
-A 100
0B32:0100 MOV AH,02
0B32:0102 MOV DL,41
0B32:0104 MOV CL,1A
0B32:0106 INT 21
0B32:0108 INC DL
0B32:010A LOOP 106
0B32:010C INT 20H
0B32:010E
-RCX
CX 0000
:E
-N C:\ABC.COM
-W
Writing 0000E bytes
-G
ABCDEFGHIJKLMNOPQRSTUVWXYZ
Program terminated normally
-Q

C:\>DIR ABC.COM
Volume in drive C is WINDOWS
Volume Serial Number is C012-9F20

Directory of C:\

09/10/2007 06:12 PM 14 ABC.COM
1 File(s) 14 bytes
0 Dir(s) 11,225,669,632 bytes free

C:\>ABC
ABCDEFGHIJKLMNOPQRSTUVWXYZ
C:\>

I cannot remember which service interrupt used to put a single character into screen, well, here’s the reference:

Category: DOS kernel

INT 21 - DOS 1+ - WRITE CHARACTER TO STANDARD OUTPUT

	AH = 02h
	DL = character to write
Return: AL = last character output (despite the official docs which state
		nothing is returned) (at least DOS 2.1-7.0)
Notes:	^C/^Break are checked, and INT 23 executed if pressed
	standard output is always the screen under DOS 1.x, but may be
	  redirected under DOS 2+
	the last character output will be the character in DL unless DL=09h
	  on entry, in which case AL=20h as tabs are expanded to blanks
	if standard output is redirected to a file, no error checks (write-
	  protected, full media, etc.) are performed
SeeAlso: AH=06h,AH=09h

~Still remembering the first time I cracked a commercial software =P, lol, it was fun. Thx for the tutorial writer, sorry I forgot your name =D