What is an OOPic Application

In this chapter, instructions are given to create a very small program that can be easily implemented. The intent is to familiarize the new users with the procedures involved in the OOPic development environment.

Steps to Creating Your First OOPic Application

There are 5 steps involved in creating an application for the OOPic

1. Start the OOPic Software development kit.
2. Design a hardware interface.
3. Write code.
4. Connect the hardware.
5. Download and run the application.

Starting the OOPic Software Development Kit

The menu provides a set of operations that you will need while writing your application including a file save and load selection for you to save the applications that you have written.

First OOPic Application Concept

The materials required are as follows:

1. 1 OOPic
2. 1 red LED
3. 1 220 ohm resistor.
4. 1 battery connected to the OOPic.
5. 1 OOPic programming cable.

Creating the Hardware Interface.

In our first application, an LED will be repeatedly turned on and off. This will be done by repeatedly outputting a voltage onto the I/O Line that the LED is connected to. A single Digital Input/Output line will be used for this purpose. Starting at the first line of code, type the following statement:

Dim LED As New oDio1

This instructs the OOPic to create an instance of an oDio1 (1-bit digital I/O line) Object with the name "LED". The oDio1 Object is classified as a "Hardware Object". This simply means that the Object will interact with the I/O Lines on the OOPic in some pre-defined way. The function of an oDio1 Object is either to present a voltage onto one of the OOPic’s I/O lines, or to read the voltage that is present on an I/O Line.

Once an instance of an Object has been created, all references to that instance are done by specifying its name, followed by a period, and then the property or method that you want to reference.

To specify which I/O line the LED Object uses for its voltage output, we will set some of its properties. At the bottom of the program, add the following statements:

Sub Main() LED.IOLine = 31 LED.Direction = cvOutput End Sub

The statements SUB MAIN() and END SUB define the beginning and the end of a procedure called MAIN. The procedure called "MAIN" is the procedure that will run first when the OOPic is turned on or reset.

The line "LED.IOLine = 31" sets the IOLine property of the Object named LED to 31 and the line "LED.Direction = cvOutput" sets the Direction property to 1 ( the value of cvOutput). After the execution of these two statement, any value written to LED.Value will now be presented on I/O Line 31. If the Value property of the LED Object is set to 0, 0-Volts will be presented and if it is set to 1, 5-Volts will be presented.

To cycle the LED.Value property at a rate of 1 blink per second, we will add code that continuously assigns it to the OOPic.Hz1 value. (OOPic.Hz1 is a value that cycles once every second). At the bottom of the program, just before the line that reads "END SUB", Insert three lines and add the following statements:

Do LED.Value = OOPic.Hz1 Loop

The first statement sets up a looping construct. The second statement sets the Value property of the LED Object to OOPic.Hz1, which cycles every second. The third statement finishes the looping construct and causes the program flow to return to the Do statement.

Assigning the LED Object's Value property to OOPic.Hz1 when it is currently set to 1, results in the IOLine to be set to 5 Volts and when the OOPic.Hz1 is currently set to 0, the IOLine will be set to 0 Volts.

By using the Do…Loop structure, around the assignment statement, the assignment statement is repeated indefinitely. The result of this is that the LED will turn off and on once every second.

The following code shows the complete code listing written as instructed in the previous paragraphs.

Dim LED As New oDio1 Sub Main() LED.IOLine = 31 LED.Direction = cvOutput Do LED.Value = OOPic.Hz1 Loop End Sub

Connecting the Hardware

Both I/O Line 31 and Ground can be found on the OOPic's 40-Pin I/O connector. A reference to the OOPic's 40-Pin I/O connector can be found at: http://www.oopic.com/con40.htm

Downloading and Running the Application

In order for the executable to be downloaded to the OOPic, the programming cable must be connected to the PC and properly configured. It also needs to be connected to the OOPic's programming connector and an adequate power supply must be attached to the OOPic. See the "Programming Cable" section for more information.

What is a Virtual Circuit

Virtual Circuits are created by progmatically linking together a set of OOPic Objects in the same methodology as one would physically link together a set of electronic components. Once created, each individual part of the virtual circuit can be manipulated or evaluated by the program providing total computerized control of the entire circuit.

Virtual Circuits are used to perform functions that provide continuous processes. A real-world example of a continuous process function would be the electrical circuit between a flashlight's switch and its light bulb. The function of the flashlight's switch is to provide continuous control over its light bulb. In an OOPic application, things that need to be continuously updated or monitored, can be done by using a Virtual Circuit.

Steps to Creating Your First Virtual Circuit

There are 5 steps involved in creating an application for the OOPic

1. Create an OOPic application
2. Identify functions applicable to Virtual Circuits
3. Work out the Virtual Circuits schematic
4. Add and link the Virtual Circuit to the application

Creating an OOPic Application

In this chapter, instructions are given on how to modify the application in chapter 2 to use a Virtual Circuit to do some of the work.

Identify Functions Applicable to Virtual Circuits

One of the OOPic's Processing Objects, the oGate Object, is capable of providing that same function that the OOPic application is now doing with code, thus modifying the program to use a Virtual Circuit with this Object will allow the application's program to go do other things.

Work out the Virtual Circuit Schematic

For our First Virtual Circuit, an oGate Object will be used to update an oDio1 Object's Value property to the value of the OOPic.Hz1 property.

Begin the schematic by drawing the Icon for the OOPic, Next draw the icon for an oGate Object, and lastly, draw the Icon for the oDio1 Object.

Next, draw arrows between the Object's properties to represent the data flow between the Objects.

First draw an arrow from the OOPic Object to the oGate Object. Label this arrow "Hz1" on the OOPic Object and "Input" on the oGate Object. Next draw an arrow from the oGate Object to the oDio1 Object. Label this arrow "Output" on the oGate Object and "Value" on the oDio1 Object.

Add and Link the Virtual Circuit to the Application

Because this application is a modification of the "First OOPic Application" found in Chapter 2, the final code listing for the OOPic application in Chapter 2, as shown below, will need to be modified.

Dim LED As New oDio1 Sub Main() LED.IOLine = 31 LED.Direction = cvOutput Do LED.Value = OOPic.Hz1 Loop End Sub

As previously detailed, the Virtual Circuit will use an oGate Object to provide the same function that the OOPic application is now doing with code. Starting at the first line of code, insert a blank line and type the following statement:

Dim WIRE As New oGate

This instructs the OOPic to create an instance of an oGate Object with the name "WIRE". The oGate Object is classified as a "Processing Object". This simply means that the Object will manipulate the values of other Objects in some pre-defined way. The function of an oGate Object is to read a property from one or more Objects, perform a specified logic function, and store the resulting value of that function into yet another Object's property

Next, the application's Do…Loop structure needs to be removed because its function is going to be replaced by the Virtual Circuit. Beginning with the Do statement, remove the following 3 lines of code.

Do LED.Value = OOPic.Hz1 Loop

Replace them with the following 3 lines of code.

WIRE.Input1.Link(OOPic.Hz1) WIRE.Output.Link(LED.Value) WIRE.Operate = cvTrue

The first line, "WIRE.Input1.Link(OOPic.Hz1)", instructs the "WIRE" Object to link its Input1 property to the OOPic.Hz1 property. The second line, "WIRE.Output.Link(LED.Value)", instructs the "WIRE" Object to link its Output property to the Value property of the "LED" Object. And the third line, "WIRE.Operate = cvTrue", sets the "WIRE" Object's Operate property to 1 (the value of cvTrue) which instructs it to start operating.

After the program executes these 3 lines of code, the Virtual Circuit begins to operate in the following manner;

1. The value of the OOPic.Hz1 property will be loaded by the oGate Object.
2. The oGate will then use that value in a logical OR operation with its other inputs. In this application, only one input was used, so the result of the logical OR function will always equal the input.
3. The LED.Value is set to the result of the logical OR function.

This procedure operates in the background and will continue to operate until the WIRE.Operate property is set back to a value of 0 (cvOff).

The following code shows the complete code listing written as instructed in the previous paragraphs.

Dim WIRE As New oGate Dim LED As New oDio1 Sub Main() LED.IOLine = 31 LED.Direction = cvOutput WIRE.Input1.Link(OOPic.Hz1) WIRE.Output.Link(LED.Value) WIRE.Operate = cvTrue End Sub

Downloading and Running the Virtual Circuit Application

Pressing the F5 key will compile the program and then download the "oex" file to the OOPic. If any errors are encountered, they will be reported and the compilation will stop. If no errors were encountered, an "oex" (OOPic Executable) file is generated. If you have not saved the program or you have changed it since the last time you have saved it, the compiler will ask you to save it. If this is the first time the program is going to be saved, the compiler will ask you for a program name. In this case, let's call the program "FirstVC". Type "FirstVC" in the "File name" area of the "Save As" dialog box and hit Enter.

In order for the executable to be downloaded to the OOPic, the programming cable must be connected to the PC and properly configured. It also needs to be connected to the OOPic's programming connector and an adequate power supply must be attached to the OOPic. See the "Programming Cable" section for more information.

What is an Event Driven Program

In Event Driven Programs, the OOPic’s oEvent Object is used to execute code in response to an event.

Steps to Creating Your First Event Driven Program

There are 4 steps involved in creating an application for the OOPic

1. Create an OOPic application
2. Identify functions applicable to events
3. Add the Event Object to the application
4. Create the Event Object's Subprocedure.

Creating an OOPic Application

In this chapter, instructions are given on how to modify the application in chapter 3 to be Event Driven.

Identify Functions Applicable to Events

The change in state of the OOPic.Hz1 property can be recognized as an event by the program. Modifying the program to be Event Driven will allow the application's program to call a subprocedure which in turn can do more complex processing.

Add the Event Object to the Application

Because this application is a modification of the "First Virtual Circuit" application, found in Chapter 3, the final code listing for the OOPic application in Chapter 3, as shown below, will need to be modified.

Dim WIRE As New oGate Dim LED As New oDio1 Sub Main() LED.IOLine = 31 LED.Direction = cvOutput WIRE.Input1.Link(OOPic.Hz1) WIRE.Output.Link(LED.Value) WIRE.Operate = cvTrue End Sub

As previously detailed, this application will use an oEvent Object to provide more complex processing. Starting at the first line of code, insert a blank line and type the following statement:

Dim BLINK As New oEvent

This instructs the OOPic to create an instance of an oEvent Object with the name "BLINK". The function of an oEvent Object is to call a subprocedure when its Operate property is set to 1.

Next, the Virtual Circuit needs to be changed. In the Chapter 3 application, the "WIRE" Object's output was linked to the oDio1 Object's Value property. This needs to be changed so that it is linked to the oEvent Object's Operate property.

Locate the line that reads "WIRE.Output.Link(LED.Value)", and change it to read as show:

WIRE.Output.Link(BLINK.Operate)

This instructs the "WIRE" Object to link its Output property to the Operate property of the "BLINK" Object.

After the program executes this line of code, the Virtual Circuit begins to operate in the following manner; and will continue to operate until WIRE.Operate is set back to a value of 0;

1. The value of the OOPic.Hz1 property will be loaded by the oGate Object.
2. The oGate will then use that value in a logical OR operation with its other inputs. In this application, only one input was used, so the result of the logical OR function will always equal the input.
3. The BLINK.Operate property is set to the result of the logical OR function.
4. Each time the BLINK.Operate property changes from 0 to 1, the "BLINK" Object's Subprocedure is executed.

The following code shows the complete code listing written as instructed in the previous paragraphs.

Dim BLINK As New oEvent Dim WIRE As New oGate Dim LED As New oDio1 Sub Main() LED.IOLine = 31 LED.Direction = cvOutput WIRE.Input1.Link(OOPic.Hz1) WIRE.Output.Link(BLINK.Operate) WIRE.Operate = cvTrue End Sub

Create the Event Object's Subprocedure

At the bottom of the program add the following lines of code:

Sub BLINK_CODE() LED.Value = 1 LED.Value = 0 LED.Value = 1 LED.Value = 0 LED.Value = 1 LED.Value = 0 End Sub

The following code shows the complete code listing written as instructed in the previous paragraphs.

Dim BLINK As New oEvent Dim WIRE As New oGate Dim LED As New oDio1 Sub Main() LED.IOLine = 31 LED.Direction = cvOutput WIRE.Input1.Link(OOPic.Hz1) WIRE.Output.Link(BLINK.Operate) WIRE.Operate = cvTrue End Sub Sub BLINK_CODE() LED.Value = 1 LED.Value = 0 LED.Value = 1 LED.Value = 0 LED.Value = 1 LED.Value = 0 End Sub

Downloading and Running the Virtual Circuit Application

Pressing the F5 key will compile the program and then download the "oex" file to the OOPic. If any errors are encountered, they will be reported and the compilation will stop. If no errors were encountered, an "oex" (OOPic Executable) file is generated. If you have not saved the program or you have changed it since the last time you have saved it, the compiler will ask you to save it. If this is the first time the program is going to be saved, the compiler will ask you for a program name. In this case, let's call the program "FirstEV". Type "FirstEV" in the "File name" area of the "Save As" dialog box and hit Enter.

In order for the executable to be downloaded to the OOPic, the programming cable must be connected to the PC and properly configured. It also needs to be connected to the OOPic's programming connector and an adequate power supply must be attached to the OOPic. See the "Programming Cable" section for more information.

OOP

Object-oriented programming (OOP) is a method of programming that seeks to mimic the way we perceive things in the real world. OOP exploits our natural tendencies to generalize and classify and allows us to group logically related portions of an application. In most OOP languages, the OOP language extensions allow you to create extremely complex Object models that can closely mimic real life Objects. With OOPic however, the greatest advantage of using Object-oriented techniques is the ease at which you can interface with the physical hardware components present within the OOPic itself.

The software industry defines several fundamental principles that qualify a language as Object-oriented. These principles include encapsulation, inheritance, and polymorphism. Although the OOPic manuals do not refer to these principles often, it is useful to understand them.

Encapsulation simply means to group related items together. Rather than treating a number of logically related variables and functions dedicated to manipulating those variables as unrelated pieces of code, encapsulation collects them together in groups called classes. Other parts of the program can then use the variables and functions as a single Object. Once encapsulated, variables are referred to as properties of the Object and the functions are referred to as methods of the Object. Through encapsulation, much of an Object's complexity can be kept internal to the Object. And only the few select methods and properties that need to be available to other parts of a program are exposed. These exposed methods and properties, which can be accessed, are called the Object's interface. The term Data Abstraction refers to the way an Object's interface doesn’t reveal the way the Object stores its data or performs its methods. The result of data abstraction is a simple Object interface that interacts with functionality that is considerably more complex.

Polymorphism is a term borrowed from the Greek language. It means literally "Having many shapes". In OOP this is the effect of being able to invoke an Object's method without knowing the Object's exact type and having the method perform a different action depending on that Object's type.

Inheritance allows you to base one Object type on another and build new derived Objects. Since OOPic's Objects are hardware based and the routines are written in optimized assembly language and stored in PROM, there is no way too physical create a new Object type to inherit the class of another. However, by creating Virtual Circuits, inheritance is accomplished.

Structure of an OOPic Application

The Main procedure. This is the main part of your program. It contains the primary program flow.

Sub-procedures. These provide your program with sections of code that can be executed from several different points in you program.

Objects. Objects can be thought of as self-contained multitasking code that runs in the background with its own set of variables. They are the way in which all OOPic programs interact with the hardware.

Events. Events are actions or situations recognized by an Object that cause subprocedures to get executed in response to the change in an Objects state. For more information on

Virtual Circuits. Virtual Circuits are emulated electronic circuits that run in the background. They can connect to, and manipulate any variable's values.

How an Event-Driven Application Works

Although the oEvent Object is the only Object in the OOPic language that has event capabilities, other Objects can still indirectly trigger events. Other Objects can be linked to the oEvent Object thereby giving any Object event capabilities. When you want your code to respond to an event, you first create an instance of an oEvent Object with the Dim command, write code for that event and point the oEvent Object to that code, and lastly "connect" the oEvent Object to the Object that is triggering the event.

The following example shows how a voltage change on one of the OOPic’s I/O Lines can call an event using an oDio1 Object connected to an event Object to invoke the basic syntax code subprocedure "MYEVENT".

Dim MyEvent As New oEvent Dim ThingA As New oDio1 Dim Wire as New oFanout Sub Main() ThingA.IOLine = 1 ThingA.Direction = cvInput Wire.Input.Link(ThingA) Wire.Output1.Link(MyEvent.Operate) END SUB Sub MyEvent_Code ‘event code goes here’ End Sub

After executing these lines within Sub Main, the applications program flow is idle and you could add code that is free to go and do other things. A "Link" was made when the Input of the oFanout Object was linked to the oDio1 Object and the Output of the oFanout Object was linked to the Operate property of the oEvent Object. Now, if the voltage on the I/O line specified by the oDio1 Object’s property changes from 0 to +5 the Value property of the Object named "ThingA" will change from 0 to 1, and thusly, The subprocedure named "MyEvent_Code" will be executed. When the End Sub statement is encountered at the end of the subprocedure’s code, the program will continue where it left off previously at the time of the event.

Event-Driven vs. Traditional Programming

In a traditional or "procedural" application, the application itself rather than an event controls the portions of code that execute. Execution starts with the first line of the program and follows a defined path through the application, branching and calling subprocedures as needed.

In comparison with the example above, a traditional application must continuously check the state of the I/O Line in order to determine when to call the subprocedure "MYEVENT_CODE". This takes up processing time for your application and can complicate the program’s flow control.

In event-driven programs, changes in the hardware’s state can cause a subprocedure to be executed even when the program flow was not expecting to do so. Therefore, the order in which your code executes depends on which events occur, which in turn depends on what the hardware does. This is the essence of event-driven programming: your code responds when it needs to.

Because the your program’s flow control does not dictate when an event will occur, your code must make a few assumptions about the "state of the world" when it executes. Your code may trigger additional events in response to its own interaction with the hardware and so, you should try to structure you application so those possibilities are anticipated.

Note: Avoid performing to many events at once. This could cause the stack to overflow.

Code that starts at power up.

In OOPic Basic Syntax, the subprocedure named "MAIN" in your program is designated as the starting point. When your application powers up or is reset, the program will start executing at the first line within this subprocedure. If you want to stop the program and wait for an event to occur, simply drop out of the "MAIN" subprocedure. Another way to stop the program is by setting the OOPic Object’s Operate property to 0 (cvOff). This will also cause the OOPic to shut down all events and go into a low-power mode.

Prior to the "MAIN" subprocedure executing, When the OOPic is powered up or is reset, all of the application's Object will be created and their values initialized allowing the "MAIN" subprocedure to access them.

Ending an Event-Driven program.

An Event-Driven OOPic application stops running when all its oEvent Objects are disconnected from their triggers and no code is executing. Because no code is running and no events will occur that will run a subprocedure, there is no way to re-start the execution of the program code.

Even when no code is running, the Objects will still operate in the background until the power is shut off. Since the Operate property can be set to 0 by another Object, or even by another computer via the I²C network, the code does not need to be running to shut down the power.

Objects

In most basic languages, One would find several Basic language statements and functions whose operations deal with a particular subject and are therefore related. For example, the Peek function and the Poke statement both deal with memory. The Peek function returns the value at a specified location and the Poke statement sets a specified memory location to a specified value as seen in the following example.

V = Peek(128) ‘Old way to read memory location 128 into the variable V. Poke 128,V ‘Old way to write the variable V into memory location 128.

The syntax of these two procedures is completely dissimilar. In OOPic Basic, these two operations are combined into a single Object called "oRAM". With the oRAM Object, a specified memory location is treated as a single unit and is accessed as if it was a variable. The following example demonstrates the use of an oRAM Object dimensioned with the name "MYRAM".

V = MYRAM ‘New way to read a memory location into the variable V. MYRAM = V ‘New way to write the variable V into a memory location.

This code reads better, is more consistent and can be understood more quickly. This language enhancement is one of the benefits of using an Object-oriented language.

In OOPic applications an Object is declared (or an instance of it is created) with the Dim statement as follows:

Dim Object As New type ‘Syntax of the Dim statement

Each Object must have a unique name specified by the programmer. The Object's name is case insensitive and is the identifier that is used by the application to refer to that Object. The same rules apply to naming Objects as are applied to all other identifiers in the OOPic language.

Variables

The OOPic languages, like most programming languages, uses variables for storing values. Variables have a name that you use to refer to the variable. And they have a value, which contains the data. Unlike other programming languages however, OOPic’s variables are also Objects. This gives OOPic applications some advantages. The most important advantage is the presence of properties that can use to control the behavior of the variable. Another great advantage is that since the Value of the variable is also an Object property, It can be linked to a Virtual Circuit and accessed by other Objects as well as other computers via the I²C network.

In OOPic Basic syntax a variable is declared (or an instance of it is created) with the Dim statement as follows:

Dim variable As New type ‘Syntax of the Dim statement

You should notice that this is the same syntax used to create the instances of any other type of Object.

Each variable must have a unique name specified by the programmer. The Object's name is case insensitive and is the identifier that is used by the application to refer to that variable. The same rules apply to naming variables as are applied to all other identifiers in the OOPic languages.

Subprocedures

The Call command instructs the program to branch to the subprocedure. The last line of the subprocedure must be End Sub. The End Sub statement causes the program flow to go back to the next statement following the Call statement.

Each subprocedure must have a unique name specified by the programmer. The subprocedure's name is case insensitive and is the identifier that is used by the application to refer to that subprocedure. The only required subprocedure name is "MAIN" which is the subprocedure that is executed when the OOPic is powered up or reset.

All variables in OOPic Basic syntax are global. This means that any subprocedure can modify any variable that appears anywhere in the entire program.

Functions

newvalue = Sin(oldvalue)

Control Structures

Flow Control

Flow Control statements allow the program to change the point of execution.

The Flow Control structures that OOPic Basic syntax supports are:

• Goto
• Call

Decision Structures

Decision Structures are statements that can test conditions and then, depending on the result of that test, perform different operations. The condition is usually a comparison, but it can be any expression that evaluates to a numeric value. The evaluation interprets this value as True or False; a value of 0 is False and a value of not 0 is True. The constants cvTrue and cvFalse can be used in your code in place of 0 or 1.

The decision structures that OOPic Basic syntax supports are:

• If…Then…Else
• Select Case

Loop Structures

Loop structures allow you to execute one or more lines of code repetitively.

The loop structures that OOPic Basic syntax supports are:

• For…Next
• Do...Loop

Adding Comments to Your Code

OOPic's Hardware Interface

The OOPic is designed to be used in embedded applications. these are applications in which a stand-alone processor is required to control some form of hardware. To accommodate this, the OOPic has thirty-one I/O lines that can be used in various ways. Each of the thirty-one physical I/O lines can both sink and source 25mA. I/O Lines 8 – 15 have an internal pull-up resistor that can be activated with the Pullup property of the OOPic Object. and I/O Lines 16 – 31 are Schmidt Trigger type inputs when in the input mode. These I/O lines are controlled by a set of special Objects referred to as Hardware Objects.

The Following table shows the electrical characteristics for all the OOPic's I/O lines.

Output Voltage when I/O line is set to output 0.	0 Volts
Max current supplied when I/O line is set to output 0.	25 Ma
Output Voltage when I/O line is set to output 1.	+5 Volts
Max current supplied when I/O line is set to output 1.	25 Ma
Max current supplied on all I/O lines combined	200 Ma

The voltage regulator on the OOPic is a TO-92 case 7805 +5 Volt regulator and is rated at 100 Ma. If more power is needed, a +5 voltage source can be supplied on the +5 lines of the 40 Pin I/O connector.

Hardware Objects are Objects that encapsulate the functionality of the physical hardware circuits within the OOPic. They interface with the physical hardware circuits connected to the OOPic and provide an application program with a hardware interface that has the capability of controlling and respond to that hardware.

Hardware Objects are the one and only method the OOPic uses to provide hardware I/O.

Using Hardware Objects

There are 11 Classes of Hardware Objects built into the OOPic. The following list shows the 11 different types of Hardware Objects available.

1. 1-Bit Digital Input / Output
2. 4-Bit Digital Input / Output
3. 8-Bit Digital Input / Output
4. 16-Bit Digital Input / Output
5. 16-Bit multiplexed Digital Input / Output
6. Analog to Digital Converter
7. Pulse Width Modulator
8. Serial Transmitter / Receiver
9. High Speed Timer
10. Matrix Keypad Decoder
11. RC Servo Controller

Although more that one instance of any hardware Object is allowed, Only one instance of a Hardware Object will properly interact with any one specific hardware circuit at any given time.

1-Bit Digital I/O

Each dimensioned instance of the oDio1 Object has an IOLine property that specifies which one of the OOPic's thirty-one physical I/O lines it is to use. This property must be set prior to any other property being set. Setting the IOLine property to 0 results in the oDio1 Object entering an dormant state.

The following table shows the possible values for the IOLine property.

The Value property of the oDio1 Object continuously reflects the electrical state of the I/O Line specified by the IOLine property. If the Direction property is set to cvInput, then the Value property reflects the physical I/O Line and if the Direction property is set to cvOutput, then the physical I/O Line reflects the Value property.

The following table shows the possible values for the Value property.

For more information on the oDio1 Object, See the oDio1 Technical Information.

4-Bit Digital I/O

Each dimensioned instance of the oDio4 Object has an IOGroup and a Nibble property that specifies which one of the six possible I/O line configurations it is to use. These property must be set prior to any other property being set. Setting the IOGroup property to 0 results in the oDio4 Object entering an dormant state.

The following table shows the possible values for the IOLine property.

The Value property of the oDio4 Object reflects the electrical state of the I/O Lines specified by the IOGroup and Nibble properties. If the Direction property is set to cvInput, then the Value property reflects the physical I/O Lines and if the Direction property is set to cvOutput, then the physical I/O Lines reflect the Value.

The following table shows the possible values for the Value property.

For more information on the oDio4 Object, See the oDio4 Technical Information.

8-Bit Digital I/O

Each dimensioned instance of the oDio8 Object has an IOGroup property that specifies which one of the three possible I/O line configurations it is to use. This property must be set prior to any other property being set. Setting the IOGroup property to 0 results in the oDio8 Object entering an dormant state.

The following table shows the possible values for the IOLine property.

The Value property of the oDio8 Object reflects the electrical state of the I/O Lines specified by the IOGroup property. If the Direction property is set to cvInput, then the Value property reflects the physical I/O Lines and if the Direction property is set to cvOutput, then the physical I/O Lines reflect the Value.

The following table shows the possible values for the Value property.

For more information on the oDio8 Object, See the oDio8 Technical Information.

16-Bit Digital I/O

Each dimensioned instance of the oDio16 Object has an IOGroup property that specifies if it is using its predetermined I/O line configuration. This property must be set prior to any other property being set. Setting the IOGroup property to 0 results in the oDio16 Object entering an dormant state.

The following table shows the possible values for the IOLine property.

The Value property of the oDio16 Object reflects the electrical state of the I/O Lines specified by the IOGroup property. If the Direction property is set to cvInput, then the Value property reflects the physical I/O Lines and if the Direction property is set to cvOutput, then the physical I/O Lines reflect the Value.

The following table shows the possible values for the Value property.

For more information on the oDio16 Object, See the oDio16 Technical Information.

16-Bit Digital I/O Expansion

For more information on the oDio16x Object, See the oDio16x Technical Information.

Analog to Digital Converter

The analog-to-digital converter (A/D) module allows conversion of an analog input signal to a corresponding 8-bit digital number. The A/D module has four analog inputs available on the OOPic’s I/O lines 1 – 4, which are multiplexed into a single sample and hold register. The sample and hold register is the input into the converter, which generates the result via successive approximation. The ExtVRef property of the OOPic Object determines the analog reference voltage, which is selectable to either 5 volts or the voltage level supplied on the OOPic’s I/O line 4.

For more information on the oA2D Object, See the oA2D Technical Information.

Pulse Width Modulator

The Pulse-Width-Modulator (PWM) module provides an output that rapidly switches between on and off. The ratio between the On time and the Off time is controllable. The larger the ratio is, the more current will flow from the output and the smaller the ration is, the less current will flow from the output. This creates an output who's output current is controllable.

For more information on the oPWM Object, See the oPWM Technical Information.

Serial Transmitter / Receiver

The serial communication (SC) module provides a high-speed serial communication port capable of communicating at 1200, 2400, 9600 and 31250 BPS. It can be configured as full duplex asynchronous or synchronous and can communicate with serial devices such as CRT terminals and personal computers. It uses the standard non-return-to-zero (NRZ) format asynchronous mode, (one start bit, eight data bits and one stop bit). The SC module transmits and receives the lowest significant bit first. The SC module’s transmitters and receiver are functionally independent but use the same data format and baud rate.

The outputs of the SC module are TTL levels. To convert the TTL serial signals of 0 - 5 Volts to the RS232 Serial signals of +/- 12 Volts, any TTL to RS232 chip such as the SN75188 or the MAX203 can be used.

For more information on the oSerial Object, See the oSerial Technical Information.

High Speed Timer

The Timer module provides a 16 bit hardware counter who's input can be configured as an input line on the OOPic. The input line can be used a standard TTL level input or can be configured to drive a crystal.

For more information on the oTimer Object, See the oTimer Technical Information.

Keypad Input

The Keypad Matrix Controller module provides the matrix scanning pattern needed to read a 4 x 4 matrix keypad.

For more information on the oKeypad Object, See the oKeypad Technical Information.

Servo Controller

The Servo Motor (SM) control module provides the PWM control pulse that is required to electrically refresh a servo motor's position. The SM control module can output the PWM control pulse on any of the OOPic's 31 I/O Lines specified by the IOLine property.

For more information on the oServo Object, See the oServo Technical Information.