Andrew McAllister

Camera Path Robot

ö Final Report ö

AdamKim

AndrewMcAllister

ECE246

ADSLSpring 2003

Written: May 4, 2003

Overview of Design and Functionality:

The Camera Path Robot was createdwith the filmmaker in mind.Ê Based on astandard piece of movie-making equipment, the jib arm (the mechanicalparallelogram geometry), this robot replaces the work of physically moving thecamera with gearing and stepping motors to move a camera in the same path anynumber of times.Ê By moving in the samepath repeatedly, visual effects can be achieved in editing that could not bedone moving the camera by hand.

The robot is designed to move infour degrees of motion: jib up/down, jib rotate, pan, and tilt.Ê The director, instead of instructing a cameraoperator, would programs a laptop running windows software to move the motorsover a specified degree of arc over a specified period of time.Ê

Design Details:

There were four major modules tothis project.Ê Each of the projectmodules were created and then connected to the other modules to produce thefinal product.Ê These modules wereconnected according to the following blockdiagram:

a. LaptopSoftware ö Directorâs Interface

The software was developed inVisual Basic to display a directorâs control panel.Ê Here is a screenshot of the controls:

Notice that the director can bothoperate one motor at a time easily, or, in the CPR Code Window, send commandsto multiple motors for more complex movements.Ê

Files for this program are includedon the CD-Rom and are printed and attached in the attachments section of thisdocument.Ê This program is extremelysimple as most of the processing is done on the basic stamp.Ê The code only presents a user interface andgenerates, based on these fields, a command string sent as a packet to thebasic stamp over RS-232.Ê Sending at19200 bps was the best for my application.Ê

The packet encoding is as follows:

<motor>

<arc>

Start Byte (ascii)

A number for the motor:

1 = jib rotate, 2 = jib elevate, 3 = pan, 4 = tilt

Comma de-limiter

A number for direction:

1 = CW/Up,

2 = CCW/Down

Comma delimiter

A number for to arc in degrees from one digit to three digits.

Comma de-limiter

A number for the duration of motion in seconds

Ending Byte (ascii)

This packet is how we ãplugged inäthe laptop to the BasicX microcontroller.

b. BasicXBX-24 Microcontroller RS-232 Translator

For this project, we already had aBasicX BX-24 microcontroller, so we decided to implement it on this project dueto our familiarity with it.Ê We acquireda development board to easily communicate and download programs to thecontroller ö by using a dev board we had a ãboxä which contained the chip so aswe built this portion of the project, we did not have to concern ourselves withpower to the chip or if wires were connected solidly.Ê The dev board was crucial to keeping the chipsafe from breaking during prototyping phases.ÊWe also took steps later in the amp to buffer all signals to thecontroller in case a bad connection was made ö the controller is fragile andmust be protected.

We designed the microcontroller todecode the packets as they arrive on the Comm 1 serial port.Ê The code (attached) copies values into anarrays for each variable depending on the motor the director wishes to operate.Ê After the code is successfully decoded, atask is spawned on the microcontroller depending on which motor is to be run,and the variables are copied to that motorâs variable arrays.Ê This way the motor taskâs variables areisolated and semaphores are not necessary.ÊThe code is in the attachments section at the end of this document.

Interesting features of theprogramming include the linear acceleration envelope and how each motor taskcreates the pulse trains.Ê The linearacceleration envelope causes the stepping motors to start and stop smoothly,although a more parabolic acceleration/deceleration envelope would be more desirable.Ê By smoothing out speed transitions, therecorded video looks more professional as it does not ãwobbleä at the end of amovement.Ê This was a crucial designrequirement.

Each task generates the pulsetrains by outputting ãPutPin()ä commands, thereby bringing a signal linehigh.Ê Then the task sleeps until itneeds to pull a pin low.Ê This makesmultitasking easy.Ê For more informationon how the pulses must be created, see the chassis section about steppingmotors or references for tutorials on how to use stepping motors provided inthe ãreferencesä section.

c. AmplifyingHardware

A stepping motor requires pulses ofa certain voltage in order to move a preset arc, or step.Ê Being 2-phase, our motors require two pulses,one across each coil of the motor.Ê So weneeded hardware to take the logic level pulses from the BX chip and convertthem to the higher voltage, and more importantly, the higher current necessaryto drive the motors.

To accomplish this, we had manycircuit designs.Ê Motor driver ICs provedto accomplish the task, but they required extra components, and moreimportantly, we didnât know if they were using the motors optimally.Ê FETs were a potential solution, but usingthem as switches instead of amps failed to provide enough voltage.Ê Relays were highly effective, but they hadthe problem of potential mechanical failure.ÊFinally, we came across a bipolar transistor amp design that workedwell.Ê This BJT design required only twosignals be generated per motor from the controller and outputted four signalsto each motor by using inverters.ÊConcerns for hardware IC and BJT selection were all based on the currenteach motor would require in operation.

Since the circuitry for just onemotor filled an entire breadboard, which in itself was bulky, we decided tosolder it all to one board.Ê For spaceand time concerns, we custom made several resistor-transistor combinations.Ê With the BX chipâs board mounted above thesolder board, we were able to power the motors, the chip, and the amps all offone power supply using two voltage regulators to provide logic level power.Ê The amp hardware is actually capable of beingseparated from the BX chip and the motors without dismantling it.Ê

Here is a photo of the finalassembly:

The BX Development Board is on topconnected by DB9 (top center) to the laptop, and the rainbow ribbon cable (topleft) connects the dev board to the amplifying hardware on the bottomlayer.Ê Wires exiting the right of thepicture connect the amp to the motor leads on the robot.

d. MechanicalJib-Arm Chassis with Stepping Motors

The chassis took the most time inthis project and went through many redesigns.ÊUsing AutoCAD, we drafted a prototype chassis to be created out ofaluminum.Ê Having never taken TAM or anymechanical engineering courses, we had to learn a lot as we went about gearratios, pros and cons of certain types of gears, what gearing meant for speedand torque characteristics, and other issues such as frictionâs effect ongearing ratios, etc.Ê We first designed ajib arm with four equal arms, two on each side.ÊThis would have been quite heavy, so Craig Z. from the machine shop inEveritt Lab suggested going with a channel.ÊLooking to industry designs, sure enough, this was a good solution; thechannel is a long box of aluminum roughly 2ä by 1ä by the length of the arm.Ê We were concerned with being able to lift thecamera, and we did not want our structural members to bend under the weight öthis was not a concern, however, compared to the ãyard stick wobbleäproblem.Ê By using a channel, we wereable to avoid any lateral wobbling while also decreasing the weight of thechassis and also increasing the camera payload capability.Ê

Stepping motors from OrientalMotors were selected due to their easy availability.Ê We purchased them from Servo Systems, a bulkdistributor.Ê The motors we selectedopearate at +7.5 V and .4 Amps, are 2-phase, and unipolar.Ê Note this camera payload was limited in ourdesign by the small stepping motors selected.ÊStepping motors with torque four times larger would be crucial for amore successful stepping motor design.ÊSee the ãlimitationsä section for other ideas on how to improve thisaspect of the design.

The chassis was designed to bemodular also: the jib arm can detach from the pivot box, and the pivot box canbe attached to any standard tripod.Ê Avery sturdy tripod is required, however, because the weight of the arm with thecamera is around 17 pounds.

The stepping motors are interestingdevices as they give control of all poles on the stator to the operator.Ê A switched signal in a phased pattern overfour lines is required to properly turn the stepping motor.ÊÊ Each stepping motor was connected back tothe amplifying hardware using ribbon cables and long wires (approximately 1.5meters, max) to carry the signal.Ê Thedesign required the amplifying hardware and BasicX microcontroller to be nearthe base of the chassis.Ê By doing this,the pulse signals would not be adversely affected much by noise.Ê

The laptop can be connected at upto 30 feet away using RS-232 standard connections.Ê The chassis is powered by a +7.5 DCV, 5 Amppower supply that would require a standard power extension chord connecting to120V A/C power:

Design schematics are attached, andalthough these designs were not used, the overall dimensions are still thesame.

How to Make It Work:

1. Connectthe RS-232 cable from the laptop serial port to the corresponding port on theBX chip board.

2. Connectthe BasicX development board power to a 7.5-V power supply.Ê This will power all the motors and logic; thereis no need for another separate power supply.Ê All voltage levels are regulated.

3. Wiremotors to board.Ê Center pins are power,surrounding pins are pulses, paired by inverted phases.Ê Note, if motors vibrate and do not rotate,these wires are likely connected incorrectly.

4. StartCamera Path Robot program.

5. Turnon power supply.Ê Window should say, ãCPRis ready.ä

6. Tocontrol a simple movement, input arc length and time for completion, then clickmovement type (rotate, elevate, pan, tilt).

7. Formultiple simultaneous movements, click the copy to window checkbox, then inputas per simple movements.Ê Click Run onceall commands are input.

8. Ifnecessary, click emergency stop.Ê Robotwill halt with a brief slowdown period.

9. Iferror occurs, click reset button on BX board.ÊRepeat until window shows ãCPR is ready.ä

10. Repeatsteps 5-9 as necessary.

11. Whenfinished, shut down the power supply and close the program.

Helpful Notes:

á Helpful Things:

The robotâs weight was a majorfactor in this project that we did not understand enough at the beginning toconsider.Ê By going through many designiterations on the chassis early in the semester, we were able to get the weightdown a bit, however not enough.Ê The 2pound camera had a very small range of motion the robot was capable ofarticulating it in even with the counterweight.ÊConsider lightening the main aluminum channel on the jib arm withweight-reduction holes ö doing so will not limit the camera payload and willnot increase any ãwobbleä (like a yardstick does).

á Limitations and Solutions to Limitations forNext Design Iteration:

The robot was very slow.Ê This speed can be improved by implementing afeedback control system with optical encoders and DC motors.Ê This should allow for a larger range ofspeeds attainable by the system.Ê Notethat a camera usually moves very slowly if it is ãon the airä so this is not aterrible limitation.Ê Perhaps consideringa smaller gear ratio on the jib motions along with these motors will alsoincrease speed.

Specifically, motor top speeds dueto stepping motor limitations amplified by high gear ratios cause these roboticspeed limitations:

Motion	10 Deg Arc Min Time (sec)	Max Deg/Sec	BX Calculation Constant
Rotate	3-4	3.33	0.12
Elevate	5-6	1.82	0.12
Pan	3	3.33	0.19
Tilt	3 (up) 2(down)	2.5 (up) 5 (down)	0.14

Another limitation was that the BasicXchip was only able to multitask my code to run two motors simultaneously.Ê Better code may achieve all four motorsmultitasking, however I think a better microcontroller is required to pulse allfour motors at the same time.Ê Theamplifying hardware is a separate module, so plugging a new microcontroller (ajava stamp?) into this hardware would be simple.Ê No modifications would be necessary as allinputs are buffered on the amplifying hardware.
Table of Attachments:

Code:

ÊÊÊÊÊÊÊÊÊÊÊ LaptopCode

ÊÊÊÊÊÊÊÊÊÊÊ BasicXBX-24 Microcontroller Code

Amplifying Hardware Sketch

Chassis Schematics

ÊÊÊÊÊÊÊÊÊÊÊ Tableof Contents

ÊÊÊÊÊÊÊÊÊÊÊ MainSchematic

ÊÊÊÊÊÊÊÊÊÊÊ ArmDetail

ÊÊÊÊÊÊÊÊÊÊÊ JibPivot ö Base

ÊÊÊÊÊÊÊÊÊÊÊ JibPivot Detail ö Fulcrum

ÊÊÊÊÊÊÊÊÊÊÊ PlatformDetail ö Pan/Tilt detail

Datasheets

ÊÊÊÊÊÊÊÊÊÊÊ BasicXSummary

ÊÊÊÊÊÊÊÊÊÊÊ MPS6560(BJT)

ÊÊÊÊÊÊÊÊÊÊÊ SN74F04Hex Inverters

ÊÊÊÊÊÊÊÊÊÊÊ 74HC367Hex Buffer

ÊÊÊÊÊÊÊÊÊÊÊ 7805AVoltage Regulator

Various other information

II. References:

http://www.pontech.com/products/vexta/index.htm

http://www.microdolly.com/index3.html

http://www.embedded.com/story/OEG20030410S0057

http://www.cs.uiowa.edu/~jones/step/circuits.html

http://www.solarbotics.net/library/pieces/parts_mech_steppers.html

http://www.ece.uiuc.edu/eshop/parts/

http://www.ti.com

http://www.google.com

http://courses.ece.uiuc.edu/ece345/resources.htm

http://www.basicx.com/

http://www.servosystems.com

http://www.orientalmotors.com

http://fred.unis.no/StampII3Mx/Default.htm

Code for the project:

The Laptop Code (Visual Basic6.0):

Private Function TooFast(MotorAs Integer, _

ÊÊÊÊÊÊÊ Arc As Integer, Duration As Integer, _

ÊÊÊÊÊÊÊ Direction As Integer) As Boolean

ÊÊÊ TooFast = False

ÊÊÊ Select Case Motor

ÊÊÊÊÊÊÊ Case 1

ÊÊÊÊÊÊÊÊÊÊÊ If (CSng((Arc / Duration)) >3.33) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ TooFast = True

ÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊ Case 2

ÊÊÊÊÊÊÊÊÊÊÊ If (CSng((Arc / Duration)) >1.82) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ TooFast = True

ÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊ Case 3

ÊÊÊ ÊÊÊÊÊÊÊÊIf (CSng((Arc / Duration)) > 3.33)Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ TooFast = True

ÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊ Case 4

ÊÊÊÊÊÊÊÊÊÊÊ If ((CSng((Arc / Duration)) >2.5) And _

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ (Direction = 1)) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ TooFast = True ' cw/UP CASE

ÊÊÊ ÊÊÊÊÊÊÊÊEnd If

ÊÊÊÊÊÊÊÊÊÊÊ If ((CSng((Arc / Duration)) > 5)And _

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ (Direction = 2)) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ TooFast = True ' ccw/DOWN CASE

ÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊ End Select

End Function

Private Sub Clear_Click()

ÊÊÊ CodeWindow.Text = ""

End Sub

Private Sub Command1_Click()

ÊÊÊ If SingleFrame.Enabled = True Then

ÊÊÊÊÊÊÊ EnableButton (False)

ÊÊÊ Else

ÊÊÊÊÊÊÊ EnableButton (True)

ÊÊÊ End If

End Sub

Private Sub Command2_Click()

ÊÊÊ Text3.Text = MSComm1.Input

ÊÊÊ MSComm1.InBufferCount = 0

End Sub

Private Sub Bad_Click()

ÊÊÊ EnableButton (False)

ÊÊÊ MSComm1.Output = "t1,1"

End Sub

Private Sub Command3_Click()

ÊÊÊ MSComm1.Output = "s"

End Sub

Private Sub ElevateJib_Click()

ÊÊÊ If (CopyMode.value = False) Then

ÊÊÊÊÊÊÊ Call TransmitSingle_Click(2, 1)

ÊÊÊ Else

ÊÊÊÊÊÊÊ Call TransmitSingle_Click(2, 2)

ÊÊÊ End If

End Sub

Private Sub CopytoWindow(MotorAs Integer)

End Sub

Private Sub RotateJib_Click()

ÊÊÊ If (CopyMode.value = False) Then

ÊÊÊÊÊÊÊ Call TransmitSingle_Click(1, 1)

ÊÊÊ Else

ÊÊÊÊÊÊÊ Call TransmitSingle_Click(1, 2)

ÊÊÊ End If

End Sub

Private Sub Pan_Click()

ÊÊÊ If (CopyMode.value = False) Then

ÊÊÊÊÊÊÊ Call TransmitSingle_Click(3, 1)

ÊÊÊ Else

ÊÊÊÊÊÊÊ Call TransmitSingle_Click(3, 2)

ÊÊÊ End If

End Sub

Private Sub RunCPRCode_Click()

ÊÊÊ EnableButton (False)

ÊÊÊ MSComm1.Output = CodeWindow.Text

End Sub

Private Sub Tilt_Click()

ÊÊÊ If (CopyMode.value = False) Then

ÊÊÊÊÊÊÊ Call TransmitSingle_Click(4, 1)

ÊÊÊ Else

ÊÊÊÊÊÊÊ Call TransmitSingle_Click(4, 2)

ÊÊÊ End If

End Sub

Private Sub Good_Click()

ÊÊ ÊDimExampleGood As String

ÊÊÊ ExampleGood ="g1,1,13,122#g2,1,45,234" & "#"

ÊÊÊ EnableButton (False)

ÊÊÊ CPRCodeWindow.Text = ExampleGood

ÊÊÊ MSComm1.Output = ExampleGood

End Sub

Private SubTransmitSingle_Click(Motor As Integer, _

ÊÊÊÊÊÊÊ Mode As Integer)

ÊÊÊ Dim RotDirection As String

ÊÊÊ Dim NeedCRLF As String, FastMsg As String,_

ÊÊÊÊÊÊÊ FastTitle As String, junk As Variant

ÊÊÊ FastMsg = "Try a longer duration orless arc, because the speed you selected is too fast."

ÊÊÊ FastTitle = "Woah there, Commander!"

ÊÊÊ NeedCRLF = ""

ÊÊÊ If (Dir(0).value = True) Then

ÊÊÊÊÊÊÊ RotDirection = 1 ' CW

ÊÊÊ Else

ÊÊÊÊÊÊÊ RotDirection = 2 ' CCW

ÊÊÊ End If

ÊÊÊ If (TooFast(Motor, Text2.Text, _

ÊÊÊÊÊÊÊÊÊÊÊ Text4.Text, CInt(RotDirection)))Then

ÊÊÊÊÊÊÊ junk = MsgBox(FastMsg, vbOKOnly,FastTitle)

ÊÊÊÊÊÊÊ GoTo SkipMotorMove

ÊÊÊ End If

ÊÊÊ If (Mode = 1) Then

ÊÊÊÊÊÊÊ MSComm1.Output = "g" &Motor & "," & _

ÊÊÊÊÊÊÊÊÊÊÊ RotDirection & ","& Text2.Text & "," & _

ÊÊÊÊÊÊÊÊÊÊÊ Text4.Text & "#"

ÊÊÊÊÊÊÊ EnableButton (False)

ÊÊÊ Else

ÊÊÊ ÊÊÊÊIf (CodeWindow.Text <> "")Then

ÊÊÊÊÊÊÊÊÊÊÊ NeedCRLF = vbCrLf

ÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊ CodeWindow.Text = CodeWindow.Text &NeedCRLF _

ÊÊÊÊÊÊÊÊÊÊÊ & "g" & Motor& "," & _

ÊÊÊÊÊÊÊÊÊÊÊ RotDirection & ","& Text2.Text & "," & _

ÊÊÊÊÊÊÊÊÊÊÊ Text4.Text & "#"

ÊÊÊ EndIf

SkipMotorMove:

ÊÊÊÊÊÊÊ ' Motor: 1 = JR, 2 = JE, 3 = Pan, 4 =Tilt

ÊÊÊÊÊÊÊ ' Rot. Dir: 1 = CW, 2 = CCW

'------------------------------------------------------

'|"g"|motor(1)|,|rotDir(1)|,|Arc(2)|,|Duration(2)|#(1)|

'------------------------------------------------------

End Sub

Private Sub Form_Load()

ÊÊÊ Call EnableButton(False)

ÊÊÊ ' Open the serial port

ÊÊÊ MSComm1.CommPort = 1

ÊÊÊ MSComm1.Settings = "19200,N,8,1"

ÊÊÊ MSComm1.RThreshold = 1

ÊÊÊ MSComm1.InBufferCount = 0Ê ' clear inBuffer

ÊÊÊ If MSComm1.PortOpen = False ThenMSComm1.PortOpen = True

ÊÊÊ Text3.Text = "Laptop is Ready"

ÊÊÊ

End Sub

Private Sub FormClose()

ÊÊÊ MSComm1.PortOpen = False

End Sub

Public Sub MSComm1_OnComm()

ÊÊÊ 'when the com port hears a character,decode it

ÊÊÊ If MSComm1.CommEvent > 0 Then

ÊÊÊÊÊÊÊ DecodeInput (MSComm1.Input)

ÊÊÊ End If

End Sub

Public SubDecodeInput(decodeThis As String)

ÊÊÊ If (InStr(decodeThis, "11")) Then

ÊÊÊÊÊÊÊ Call EnableButton(True)

ÊÊÊÊÊÊÊ Text3.Text = "CPR is Ready"

ÊÊÊ End If

ÊÊÊ If (InStr(decodeThis, "15")) Then

ÊÊÊÊÊÊÊ Call EnableButton(True)

ÊÊÊÊÊÊÊ Text3.Text = "CommandErrored"

ÊÊÊ End If

ÊÊÊ If (InStr(decodeThis, "20")) Then

ÊÊÊÊÊÊÊ Call EnableButton(True)

ÊÊÊÊÊÊÊ Text3.Text = "StopSuccessful"

ÊÊÊ End If

ÊÊÊ 'CodeWindow.Text = decodeThis

End Sub

Public Sub EnableButton(valueAs Boolean)

ÊÊÊ If (value) Then

ÊÊÊÊÊÊÊ SingleFrame.Enabled = True

ÊÊÊ Else

ÊÊÊÊÊÊÊ Text3.Text = "Executing..."

ÊÊÊÊÊÊÊ SingleFrame.Enabled = False

ÊÊÊ End If

ÊÊÊ

End Sub

'-------------------------------------------------------------------------------

Option Explicit

ÊÊÊÊÊÊÊ Const SlowStartQP As Single = 0.2

ÊÊÊÊÊÊÊ Const StartScalar As Single = 1.3

ÊÊÊÊÊÊÊ Const GreenLED As Byte = 26

ÊÊÊÊÊÊÊ Const RedLED As Byte = 25

ÊÊÊÊÊÊÊ Const LEDon As Byte = 0

ÊÊÊÊÊÊÊ Const LEDoff As Byte = 1

ÊÊÊÊÊÊÊ Const Pound As Integer = 35

ÊÊÊÊÊÊÊ Const Comma As Integer = 44

ÊÊÊÊÊÊÊ Const OKCode As Integer = 11

ÊÊÊÊÊÊÊ Const ErrorCode As Integer = 15

ÊÊÊÊÊÊÊ Const EStopCode As Integer = 20

ÊÊÊÊÊÊÊ Const DegPerStepJib As Single = 0.12

ÊÊÊÊÊÊÊ Const DegPerStepPan As Single = 0.19

ÊÊÊÊÊÊÊ Const DegPerStepTilt As Single = 0.14

ÊÊÊÊÊÊÊ Private M1ControlStack(1 To 40) As Byte

ÊÊÊÊÊÊÊ Private M2ControlStack(1 To 40) As Byte

ÊÊÊÊ ÊÊÊPrivate M3ControlStack(1 To 40) As Byte

ÊÊÊÊÊÊÊ Private M4ControlStack(1 To 40) As Byte

ÊÊÊÊÊÊÊ Private LEDStack(1 To 20) As Byte

ÊÊÊÊÊÊÊ Dim EStop As Boolean

ÊÊÊÊÊÊÊ Dim Motor(1 To 5) As Integer

ÊÊÊÊÊÊÊ Dim Direction(1 To 5) As Integer

ÊÊÊÊÊÊÊ Dim Arc(1 To 5) As Integer

ÊÊÊÊÊÊÊ Dim Duration(1 To 5) As Integer

ÊÊÊÊÊÊÊ ' line declarations for motor signals

ÊÊÊÊÊÊÊ Const JRA As Byte = 13ÊÊÊÊÊÊÊÊÊ ' jib rotate

ÊÊÊÊÊÊÊ Const JRB As Byte = 14

ÊÊÊÊÊÊÊ Const JEA As Byte = 16ÊÊÊÊÊÊÊÊÊ ' jib elevate

ÊÊÊÊÊÊÊ Const JEB As Byte = 15

ÊÊÊÊÊÊÊ Const PanA As Byte = 17 ' pan

ÊÊÊÊÊÊÊ Const PanB As Byte = 18

ÊÊÊÊÊÊÊ Const TiltA As Byte = 20ÊÊÊÊÊÊÊ ' tilt

ÊÊÊÊÊÊÊ Const TiltB As Byte = 19

ÊÊÊÊÊÊÊ Const DelayLine As Byte = 12ÊÊÊ 'dummy delay line (unused I/O)

'-------------------------------------------------------------------------------

Public Sub Main()

ÊÊÊÊÊÊÊ Call OpenSerialPort

ÊÊÊÊÊÊÊ Call PutStr(CStr(OKCode))

ÊÊÊÊÊÊÊ Call PutPin(GreenLED, LEDon)

ÊÊÊÊÊÊÊ EStop = False

ÊÊÊÊÊÊÊ

ÊÊÊÊÊÊÊ Do

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call GetPkt

Ê ÊÊÊÊÊÊÊÊÊÊÊÊÊÊSleep (0)

ÊÊÊÊÊÊÊ Loop

End Sub

'-------------------------------------------------------------------------------

Public Sub PulseEncodeTask1()

ÊÊÊÊÊÊÊ Dim Steps As Integer, Freq As Single,atStep As Integer, QuarterPeriod As Single

ÊÊÊÊÊÊÊ Dim LineA As Byte, LineB As Byte,GoalQP As Single

ÊÊÊÊÊÊÊ If (Direction(1) = 1) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineA = JRA

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineB = JRB

ÊÊÊÊÊÊÊ Else

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineA = JRB

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineB = JRA

ÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊ Steps = FixI(CSng(Arc(1)) /DegPerStepJib)

ÊÊÊÊÊÊÊ Freq = CSng(Steps) / CSng(Duration(1) -1)

ÊÊÊÊÊÊÊ GoalQP = DelayCalc(Freq)

ÊÊÊÊÊÊÊ QuarterPeriod = SlowStartQP

ÊÊÊÊÊÊÊ For atStep = 1 To Steps Step 1

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineA, 1)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineB, 1)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineA, 0)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineB, 0)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊIf (QuarterPeriod > GoalQP) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ QuarterPeriod =QuarterPeriod / StartScalar

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Else

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ QuarterPeriod = GoalQP

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If (EStop = True) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ GoTo Emerg1

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Sleep (0)

ÊÊÊÊÊÊÊ Next

Emerg1:

ÊÊÊÊÊÊÊ 'Calltask "RedNote",LEDStack

ÊÊÊÊÊÊÊ Call PutStr(CStr(OKCode)) ' CPR is OK-> Laptop

End Sub

'-------------------------------------------------------------------------------

Public Sub PulseEncodeTask2()

ÊÊÊÊÊÊÊ Dim Steps As Integer, Freq As Single,atStep As Integer, QuarterPeriod As Single

ÊÊÊÊÊÊÊ Dim LineA As Byte, LineB As Byte,GoalQP As Single

ÊÊÊÊÊÊÊ If (Direction(2) = 1) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineA = JEA

ÊÊÊÊÊÊ ÊÊÊÊÊÊÊÊÊLineB = JEB

ÊÊÊÊÊÊÊ Else

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineA = JEB

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineB = JEA

ÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊ Steps = FixI(CSng(Arc(2)) /DegPerStepJib)

ÊÊÊÊÊÊÊ Freq = CSng(Steps) / CSng(Duration(2) -1)

ÊÊÊÊÊÊÊ GoalQP = DelayCalc(Freq)

ÊÊÊÊÊÊÊ QuarterPeriod = SlowStartQP

ÊÊÊÊÊÊÊ For atStep = 1 To Steps Step 1

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineA, 1)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineB, 1)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineA, 0)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineB, 0)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If (QuarterPeriod > GoalQP)Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ QuarterPeriod =QuarterPeriod / StartScalar

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Else

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ QuarterPeriod = GoalQP

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If (EStop = True) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ GoTo Emerg2

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Sleep (0)

ÊÊÊÊÊÊÊ Next

ÊÊÊÊÊÊÊ Do Until (QuarterPeriod > SlowStartQP)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineA, 1)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineB, 1)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineA, 0)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊCall PutPin(LineB, 0)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ QuarterPeriod = QuarterPeriod *StartScalar

ÊÊÊÊÊÊÊ Loop

Emerg2:

ÊÊÊÊÊÊÊ 'Calltask "RedNote",LEDStack

ÊÊÊÊÊÊÊ Call PutStr(CStr(OKCode)) ' CPR is OK-> Laptop

End Sub

'-------------------------------------------------------------------------------

Public Sub PulseEncodeTask3()

ÊÊÊÊÊÊÊ Dim Steps As Integer, Freq As Single,atStep As Integer, QuarterPeriod As Single

ÊÊÊÊÊÊÊ Dim LineA As Byte, LineB As Byte,GoalQP As Single

ÊÊÊ ÊÊÊÊIf (Direction(3) = 1) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineA = PanA

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineB = PanB

ÊÊÊÊÊÊÊ Else

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineA = PanB

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineB = PanA

ÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊ Steps = FixI(CSng(Arc(3)) /DegPerStepPan)

ÊÊÊÊÊÊÊ Freq = CSng(Steps) / CSng(Duration(3) -1)

ÊÊÊÊÊÊÊ GoalQP = DelayCalc(Freq)

ÊÊÊÊÊÊÊ QuarterPeriod = SlowStartQP

ÊÊÊÊÊÊÊ For atStep = 1 To Steps Step 1

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineA, 1)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊ ÊÊÊÊÊÊÊCall PutPin(LineB, 1)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineA, 0)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineB, 0)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If (QuarterPeriod > GoalQP)Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ QuarterPeriod =QuarterPeriod / StartScalar

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Else

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ QuarterPeriod = GoalQP

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If (EStop = True) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ GoTo Emerg3

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Sleep (0)

ÊÊÊÊÊÊÊ Next

Emerg3:

ÊÊÊÊÊÊÊ 'Calltask "RedNote",LEDStack

ÊÊÊÊÊÊÊ Call PutStr(CStr(OKCode)) ' CPR is OK-> Laptop

End Sub

'-------------------------------------------------------------------------------

Public Sub PulseEncodeTask4()

ÊÊÊÊÊÊÊ Dim Steps As Integer, Freq As Single,atStep As Integer, QuarterPeriod As Single

ÊÊÊÊÊÊÊ Dim LineA As Byte, LineB As Byte,GoalQP As Single

ÊÊÊÊÊÊÊ If (Direction(4) = 1) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineA = TiltA

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊLineB = TiltB

ÊÊÊÊÊÊÊ Else

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineA = TiltB

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LineB = TiltA

ÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊ Steps = FixI(CSng(Arc(4)) /DegPerStepTilt)

ÊÊÊÊÊÊÊ Freq = CSng(Steps) / CSng(Duration(4) -1)

ÊÊÊÊÊÊÊ GoalQP = DelayCalc(Freq)

ÊÊÊÊÊÊÊ QuarterPeriod = SlowStartQP

ÊÊÊÊÊÊÊ For atStep = 1 To Steps Step 1

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineA, 1)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineB, 1)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineA, 0)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call PutPin(LineB, 0)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(QuarterPeriod)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If (QuarterPeriod > GoalQP)Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ QuarterPeriod =QuarterPeriod / StartScalar

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Else

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ QuarterPeriod = GoalQP

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If (EStop = True) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ GoTo Emerg4

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Sleep (0!)

ÊÊÊÊÊÊÊ Next

Emerg4:

ÊÊÊÊÊÊÊ 'Calltask "RedNote",LEDStack

ÊÊÊÊÊÊÊ Call PutStr(CStr(OKCode)) ' CPR is OK-> Laptop

End Sub

'-------------------------------------------------------------------------------

Public Sub GetPkt()

ÊÊÊÊÊÊÊ 'get 6 bytes from buffer with"g" as start char

ÊÊÊÊÊÊÊ Dim bCh As Byte

ÊÊÊÊÊÊÊ Dim byteOK As Boolean

ÊÊÊÊÊÊÊ Dim i As Integer

ÊÊÊÊÊÊÊ For i = 1 To 4 Step 1

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call TaskVarZero(i)

ÊÊÊÊÊÊÊ Next

ÊÊÊÊÊÊÊ

ÊÊÊÊÊÊÊ Do

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ EStop = FalseÊ ' reset emerg stop if necessary

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Arc(5) = 0

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Direction(5) = 0

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Motor(5) = 0

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Duration(5) = 0

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ bCh = 32

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 'Do Until (Semaphore(Gate))

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 'ÊÊÊÊÊÊ sleep(0.3)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 'Loop

ÊÊÊÊÊÊÊ

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call GetByte(bCh,byteOK)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If ((bCh =Asc("g")) And (byteOK = True)) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 'Motor Number

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ CallGetByte(bCh, byteOK)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If ((CInt(bCh)> 47) And (CInt(bCh) < 58)) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊMotor(5) = CInt(bCh - 48) 'convert to integer

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Else

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 'datais messed up - drop packet

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊÊÊÊÊÊÊÊÊÊÊÊGoTo GarbledPkt

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ CallGetByte(bCh, byteOK)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If (CInt(bCh)<> Comma) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ'Success = FalseÊ -- expectedcomma, pkt messed up, discard packet

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ GoToGarbledPkt

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 'DirectionInput

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ CallGetByte(bCh, byteOK)

ÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊIf ((CInt(bCh) > 47) And(CInt(bCh) < 58)) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊDirection(5) = CInt(bCh - 48) 'convert to integer

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Else

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 'datais messed up - drop packet

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ GoToGarbledPkt

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ CallGetByte(bCh, byteOK)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If (CInt(bCh)<> Comma) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊÊÊÊÊÊGoTo GarbledPkt '-- expected comma, pktmessed up, discard packet

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 'Arc Input

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ bCh = 0

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊÊÊDo Until (CInt(bCh) = Comma)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ CallGetByte(bCh, byteOK)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If(((CInt(bCh) > 47) And (CInt(bCh) < 58)) Or (CInt(bCh) = Comma)) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊÊÊIf ((CInt(bCh) <> Comma)) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊArc(5) = Arc(5) * 10 + CInt(bCh - 48)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊEnd If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Else'the packet is garbled - discard the packet

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊGoTo GarbledPkt

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Loop

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 'Duration Input

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Do

ÊÊÊÊÊ ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊCallGetByte(bCh, byteOK)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If(((CInt(bCh) > 47) And (CInt(bCh) < 58)) Or (CInt(bCh) = Pound)) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊIf ((CInt(bCh) <> Pound)) Then

ÊÊÊ ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊDuration(5)= Duration(5) * 10 + CInt(bCh - 48)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊElse

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ'Success = TrueÊ -- we found theend of packet

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊGoTo EndSuccess

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊEnd If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Else'the packet is garbled - discard the packet

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊÊÊÊÊÊGoTo GarbledPkt

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Loop

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ' These labelsare how this loop can end

GarbledPkt:

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ CallPutStr(CStr(ErrorCode)) ' this is an error code - garbled packet

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ GoToEndThis

EStopMsg:

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ CallPutStr(CStr(EStopCode)) ' on an Estop, this is sent to computer

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊÊGoTo EndThis

EndSuccess:

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ CallTaskVarMove(Motor(5))

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ SelectCase Motor(5)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊCase 1

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊÊÊÊÊÊÊÊÊÊCallTask"PulseEncodeTask1", M1ControlStack

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊCase 2

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊCallTask "PulseEncodeTask2", M2ControlStack

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊCase 3

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊCallTask "PulseEncodeTask3", M3ControlStack

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊCase 4

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊCallTask "PulseEncodeTask4", M4ControlStack

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ EndSelect

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ CallSleep(0.01) 'give the task time to startup

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Else

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ If (bCh =Asc("s")) Then

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ'Emergency Stop

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ EStop =True

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Sleep(0.5)

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ GoToEStopMsg

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ ÊÊÊÊÊÊÊÊIf (byteOK = True) Then ' case wherethe pkt began with something other than g

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ GoToGarbledPkt

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

EndThis:

ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Call Sleep(0!)'give other tasks a chance to run

'ÊÊÊÊÊÊÊÊÊÊÊÊÊÊ End If

ÊÊÊÊÊÊÊ Loop

End Sub

'---------------------------------------------------------------------------

Private Sub TaskVarMove(ByValInMotor As Integer)

ÊÊÊÊÊÊÊ Motor(InMotor) = Motor(5)

ÊÊÊ ÊÊÊÊDirection(InMotor) = Direction(5)

ÊÊÊÊÊÊÊ Arc(InMotor) = Arc(5)

ÊÊÊÊÊÊÊ Duration(InMotor) = Duration(5)

End Sub

'-----------------------------------------------------------------------------

Private Sub TaskVarZero(ByValInMotor As Integer)

ÊÊÊÊÊÊÊ Motor(InMotor) = 0

ÊÊÊÊÊÊÊ Direction(InMotor) = 0

ÊÊÊÊÊÊÊ Arc(InMotor) = 0

ÊÊÊÊÊÊÊ Duration(InMotor) = 0

End Sub

'-------------------------------------------------------------------------------

Option Explicit

' This module is used totransfer data to and from the serial port.

Private Const BaudRate As Long= 19200

Private Const InputBufferSizeAs Integer = 50ÊÊ ' buffer.

Private Const OutputBufferSizeAs Integer = 20Ê ' buffer.

Private InputBuffer(1 ToInputBufferSize) As Byte

Private OutputBuffer(1 ToOutputBufferSize) As Byte

Private Const ASCII_LFÊÊÊÊ As Byte = 10

Private Const ASCII_CRÊÊÊÊ As Byte = 13

Private Const ASCIIplusÊÊÊ As Byte = 43

Private Const ASCIIminusÊÊ As Byte = 45

Private Const ASCIIdecimal AsByte = 46

Private Const ASCIIzeroÊÊÊ As Byte = 48

'-------------------------------------------------------------------------------

Public Sub OpenSerialPort()

' Opens a serial port at thespecified baud rate.

ÊÊÊ Call OpenQueue(InputBuffer,InputBufferSize)

ÊÊÊ Call OpenQueue(OutputBuffer,OutputBufferSize)

ÊÊÊ Call OpenCom(1, BaudRate, InputBuffer,OutputBuffer)

End Sub

'-------------------------------------------------------------------------------

Public Sub PutByte( _

ÊÊÊ ByVal Value As Byte)

' Sends one byte of binarydata to the serial port. The byte is sent

' directly without translatingit to a string.

ÊÊÊ Call PutQueue(OutputBuffer, Value, 1)

End Sub

'-------------------------------------------------------------------------------

Public Sub GetByte( _

ÊÊÊ ByRef Value As Byte, _

ÊÊÊ ByRef Success As Boolean)

' Inputs a byte from theserial port, if available. Returns regardless.ÊThe

' Success flag is setdepending on whether a byte is available.

' The byte is in direct binaryformat -- it is not in string format.

ÊÊÊ ' Find out if anything is in the queue.

ÊÊÊ Success = StatusQueue(InputBuffer)

ÊÊÊ ' If data is in the queue, extract it.

ÊÊÊ If (Success) Then

ÊÊÊÊÊÊÊ Call GetQueue(InputBuffer, Value, 1)

ÊÊÊ Else

ÊÊÊÊÊÊÊ Value = 0

ÊÊÊ End If

End Sub

'-------------------------------------------------------------------------------

Public Sub NewLine()

' Outputs a <CR><LF> to the serial port.

ÊÊÊ Call PutByte(ASCII_CR)

ÊÊÊ Call PutByte(ASCII_LF)

End Sub

'-------------------------------------------------------------------------------

Public Sub PutLine( _

ÊÊÊ ByVal Tx As String)

' Outputs a String type,followed by <CR> <LF>. Output is to the serial

' port.

ÊÊÊ

ÊÊÊ Call PutStr(Tx)

ÊÊÊ

ÊÊÊ Call NewLine

End Sub

'-------------------------------------------------------------------------------

Public Sub PutStr( _

ÊÊÊ ByVal Tx As String)

' Outputs a String type to theserial port.

ÊÊÊ Dim Length As Integer, Ch As String * 1,bCh As Byte

ÊÊÊ Dim I As Integer

ÊÊÊ Length = Len(Tx)

ÊÊÊ For I = 1 To Length

ÊÊÊÊ ÊÊÊCh = Mid(Tx, I, 1)

ÊÊÊÊÊÊÊ bCh = Asc(Ch)

ÊÊÊÊÊÊÊ Call PutByte(bCh)

ÊÊÊ Next

End Sub

'-------------------------------------------------------------------------------