OOPic Programming Fundamentals

1
OOPic Programming Fundamentals

• Compiled vs. Interpreted programs
• Compiled program converts high level code into
  native machine language
• e.g., yx5
• Machine language runs on the target
• Done in levels
• Cross-compiler ? code program on one machine (PC)
  generate machine code for another machine
  (microcontroller)
• Features
• Fast
• Interpreted program executes high level code on
  the machine that the interpreter is running on
• Each line of code is interpreted and run each
  time each time the program is run
• Fetch token from EEPROM ? wait for fetch complete
  ? decode token (objects that represent an
  action)? locate native code associated with token
  ? execute native code ? advance EEPROM address
• Features
• Easier to write an interpreter than a compiler
• Slow

2
Object Oriented Pic

• Object ? conceptual approach allowing the
  programmer to interact with what appears to be a
  physical object
• Grouping of code and data treated as a single
  unit
• Like pre-written code libraries
• Examples
• oFreq
• oButton
• oLCD
• Why objects?
• More intutive, faster to learn to use
• Functionality built into the objects, so coding
  becomes mostly just manipulating objects (rather
  than reading and writing to memory locations)
• Like having prewritten code libraries
• Ex PWM
• multitasking code objects operate
  continuously rather than line-by-line
• Can link objects together

3
Types (classes) of Objects

• Hardware
• Represents or encapsulates a physically
  implemented piece of hardware
• oDio1
• oA2D10
• Processing
• Retrieves values from other objects, performs
  calculations, stores resulting value in another
  object
• oMath
• Variable
• Stores a value and provides evaluation properties
  about that value
• oByte
• System
• controls one of several system functions
• oOOPic

4
Creating Objects

• Need to create an instance of the particular
  class of object
• oA2D10 light_level new oA2D10
• Identifier Names must begin with a letter
• Identifier Names cannot contain a period.
• Identifier Names must not exceed 32 characters.
• Identifier Names must be unique within the
  application. (Identifier names are case
  insensitive)
• The name of the Identifier is not stored in RAM
  and therefore can be any length (up to 32
  characters) with out affecting the amount of RAM
  that gets allocated for the Identifier's instance
• Not sensitive to case Light_level
  liGHt_LeVEl
• Creates an instance of an oA2D10 object (10 bit
  A/D)
• Must be done at the beginning of the program
• Allocates memory out of the free RAM to hold the
  instance of the Object, and is added to the
  Object list in the order defined
• If object operation is time critical, place next
  to each other
• 86 bytes of object memory available (96 total,
  but OOPic object takes 10 bytes)
• Dont add object that you dont need!
• They will take up memory and operating time
• Operating system steps through the object list
  and executes the defined properties of the object

5
Creating Objects, cont.

• Can create arrays of objects by specifying a
  index value when the object is declared
• Example of array of 3 A2D10 objects
• oA2D10 light_level(3) new oA2D10
• Access using index value
• Zlight_level(1).value
• Some class of some objects have variable size
• Example oGate (provides logic gate functions)
  with two inputs
• oGate 2-input_OR new oGate(2) //declare
  2-input OR gate
• oGate objects can have up to 8 inputs

6
Object Properties

• Properties are things that allow you to customize
  the characteristics of an object and determine
  the value an object holds. Some of the common
  ones
• Result
• A value (number) the result of processing done by
  the object
• Value
• A value (number) specifying the state, content or
  magnitude of an Object
• Flag
• A value (number) that signals the beginning or
  end of an object process
• String
• Allow the value to be represented as a string
• Operate
• Turns the object on (enables it to respond to
  input changes)
• It will hold the state of its last change until
  operate property set to 1
• Syntax to set
• object_name.Propertyexpression
• Ex. oA2D10 light_level new oA2D10
• light_level.IOLine 1 // Map A2D10 object to
  A/D line 1
• light_level.Operate cvTrue // Enable A2D10
  object
• Syntax to determine the state of an object
• Variableobject_name.Property

7
Object Methods

• Methods are actions that objects can perform

8
Object Method Example

• oDio4 Nib1 new oDio4
• oDio4 Nib2 new oDio4
• Const num1 1 // Defines the constant num1
  equal to 1
• Sub void Main (void)
• Nib1.IOGroup 1 //IO lines 8-15
• Nib1.Nibble 0 //IO lines 8-11 (the lower 4
  bits)
• Nib1.Direction cvInput // Digital inputs
  (cvInput 1)
• Nib2.IOGroup 1 //IO lines 8-15
• Nib2.Nibble 1 //IO lines 12-15 (the upper 4
  bits)
• Nib2.Direction 0 // Digital outputs (cvOutput
  0)
• Nib2.Value Nib1.Invert //Nib1 bits are
  inverted and sent out Nib2
• Nib2 Nib1.LShift //Nib1 bits are shifted left
  and sent out Nib2

9
Linking Objects Together

• Virtual Circuit is a way to link objects together
  so that the state of one object can signal or
  modify the state of another object, like two
  elements connected in an electronic circuit
• Can have any number of objects in the circuit
• Need at least one Processing object to accomplish
  the link
• Processing object retrieve their input values and
  store their output values in the properties of
  other Objects
• Fast!
• Multitasking functionality (output continues to
  update the objects connected as long as
  processing objects operating bit is set

10
Linking Objects Together, cont.

• Link Method
• Uses pointers to point to the appropriate
  property is located
• Flag pointer
• Flags signal an object to begin or end processing
• Ex. oDIO1s Value property is a 1-bit flag
• Any flag output from any object can be linked to
  any flag input of another object using a
  processing object such as
• oGate (2 no. of inputs) bytes
• oWire (3 bytes)
• oFanout (2 no. of outputs) bytes
• oOneShot (3 bytes)
• oFlipFlop (5 bytes)
• oEvent (3 bytes)
• Object pointer
• These link the default values between objects via
  a processing object
• e.g., usually between hardware objects and
  processing objects
• oMath (4 bytes)
• oBus (3 bytes)

11
Linking Objects Together, cont.

• Link Method syntax
• Processing_object_name.Input.Link(other_object_nam
  e)
• Processing_object_name.Output.Link(other_object_na
  me)

12
Object Linking Example

• Problem Acquire the light level from two
  photoresistors, PR1 and PR2. If the light level
  on PR1 is higher than that for PR2, output a
  high on pin B7. If the light level for PR2 is
  higher than that for PR1, output a logic low on
  pin B7.

// Procedural Approach oA2D10 PR1 new
oA2D10 // 3 bytes oA2D10 PR2 new oA2D10 // 3
bytes oDIO1 OUT1 new oDIO1 // 1 byte ? total
7 bytes (79 left) Sub void Main
(void) PR1.IOLine 1 // Map A2D10 object to
A/D line 1 PR1.Operate cvTrue // Enable A2D10
object PR2.IOLine 2 // Map A2D10 object to
A/D line 2 PR2.Operate cvTrue // Enable A2D10
object While (1) If (PR1.Value gt
PR2.Value) OUT1 1 else OUT1
0
// Virtual Circuit Approach oA2D10 PR1 new
oA2D10 // 3 bytes oA2D10 PR2 new oA2D10 //
3 bytes oDIO1 OUT1 new oDIO1 // 1 byte oWire
W new oWire // 3 bytes oCompare COMP new
oCompare // 4 bytes ? total 14 bytes (72
left) Sub void Main (void) PR1.IOLine 1 //
Map A2D10 object to A/D line 1 PR1.Operate
cvTrue // Enable A2D10 object PR2.IOLine
2 // Map A2D10 object to A/D line 2 PR2.Operate
cvTrue // Enable A2D10 object COMP.Input.Link
(PR1) // Link PR1 to Input of oCompare
object COMP.Fuzziness 10 // Set deadband to
10 COMP.ReferenceIn1.Link(PR2) // Link PR2
value to ReferenceIn1 input of oCompare OUT1.Iol
ine15 // Set OUT1 to line 15 pin
B7 OUT1.DirectioncvOutput // Make OUT1 a
digital output W.Input.Link(COMP.Above) // Link
Above flag to input of oWire object W.Output.Link
(OUT1) // Link output of oWire to oDIO1 object
13
VC Graphical Layout
14
Procedures
// Example of a procedure passing an argument //
from OOPic manual Dio1 A New oDio1 Sub void
main(void) A.IOLine 31 A.Direction
cvOutput Blink(5) Sub void Blink(Byte
xTimes) While (xTimes.Value gt 0)
A.Value cvON OOPic.Wait 100 A.Value
cvOff OOPic.Wait 100 xTimes
xTimes - 1

• // Example of a procedure
• // from OOPic manual
• oDio1 A New oDio1
• Sub void main(void)
• A.IOLine 31
• A.Direction cvOutput
• Blink()
• Blink()
• Sub void Blink(void)
• A.Value cvON
• OOPic.Wait 100
• A.Value cvOff
• OOPic.Wait 100

15
Functions

• Functions can return a value

Function lttypegt ltfunnamegt(ltarglistgt)
ltstatementsgt return ltreturnvaluegt
Function Byte GetMyVal(void) If (SW.Value
cvPressed) GetMyVal A1.Value
Else GetMyVal A2.Value
16
Events

• An event is defined as any change in state that
  is recognized by an Object. An Event Driven
  Program is a program where any change in 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.
• In normal operation, when an oEvent Object's
  Operate property transitions from 0 to 1 the
  program flow is interrupted with a call to a Sub
  procedure specified by the oEvent Object's name.
  While the Sub procedure is executing the oEvent
  Object ignores the Operate property and waits for
  the program flow to return from the Sub
  procedure. When the program flow returns from the
  Sub procedure the oEvent Object resumes watching
  for the Operate property to transition from 0 to 1