The Interactive C Manual for the Handy Board

Fred G. Martin

A PostScript version of this document is available.

Interactive C (IC for short) is a C language consisting of a compiler (with interactive command-line compilation and debugging) and a run-time machine language module. IC implements a subset of C including control structures ( for, while, if,

else), local and global variables, arrays, pointers, 16-bit and 32-bit integers, and 32-bit floating point numbers.

IC works by compiling into pseudo-code for a custom stack machine, rather than compiling directly into native code for a particular processor. This pseudo-code (or p-code) is then interpreted by the run-time machine language program. This unusual approach to compiler design allows IC to offer the following design tradeoffs:

• Interpreted execution that allows run-time error checking and prevents crashing. For example, IC does array bounds checking at run-time to protect against programming errors.
• Ease of design. Writing a compiler for a stack machine is significantly easier than writing one for a typical processor. Since IC 's p-code is machine-independent, porting IC to another processor entails rewriting the p-code interpreter, rather than changing the compiler.
• Small object code. Stack machine code tends to be smaller than a native code representation.
• Multi-tasking. Because the pseudo-code is fully stack-based, a process's state is defined solely by its stack and its program counter. It is thus easy to task-switch simply by loading a new stack pointer and program counter. This task-switching is handled by the run-time module, not by the compiler.

Since IC 's ultimate performance is limited by the fact that its output p-code is interpreted, these advantages are taken at the expense of raw execution speed. Still, IC is no slouch.

IC was designed and implemented by Randy Sargent with the assistance of Fred Martin. This manual covers the freeware distribution of IC \ (version 2.852).

• Contents
• 1 Quick Start
• 2 6811 Downloaders
  • 2.1 Overview
  • 2.2 Putting the Handy Board into Bootstrap Download Mode
  • 2.3 MS-DOS
  • 2.4 Windows 3.1 and Windows 95
  • 2.5 Macintosh
  • 2.6 Unix
• 3 Using IC
  • 3.1 IC Commands
  • 3.2 Line Editing
  • 3.3 The Main Function
• 4 A Quick C Tutorial
• 5 Data Types, Operations, and Expressions
  • 5.1 Variable Names
  • 5.2 Data Types
    • 16-bit Integers
    • 32-bit Integers
    • 32-bit Floating Point Numbers
    • 8-bit Characters
  • 5.3 Local and Global Variables
    • 5.3.1 Variable Initialization
    • 5.3.2 Persistent Global Variables
  • 5.4 Constants
    • 5.4.1 Integers
    • 5.4.2 Long Integers
    • 5.4.3 Floating Point Numbers
    • 5.4.4 Characters and Character Strings
  • 5.5 Operators
    • 5.5.1 Integers
    • 5.5.2 Long Integers
    • 5.5.3 Floating Point Numbers
    • 5.5.4 Characters
  • 5.6 Assignment Operators and Expressions
  • 5.7 Increment and Decrement Operators
  • 5.8 Precedence and Order of Evaluation
• 6 Control Flow
  • 6.1 Statements and Blocks
  • 6.2 If-Else
  • 6.3 While
  • 6.4 For
  • 6.5 Break
• 7 LCD Screen Printing
  • 7.1 Printing Examples
  • 7.2 Formatting Command Summary
  • 7.3 Special Notes
• 8 Arrays and Pointers
  • 8.1 Declaring and Initializing Arrays
  • 8.2 Passing Arrays as Arguments
  • 8.3 Declaring Pointer Variables
  • 8.4 Passing Pointers as Arguments
• 9 Library Functions
  • 9.1 Output Control
    • 9.1.1 DC Motors
      • void fd(int m)
      • void bk(int m)
      • void off(int m)
      • void alloff()
      • void ao()
      • void motor(int m, int p)
    • 9.1.2 Servo Motor
      • void servo_on()
      • void servo_on()
      • int servo(int period)
      • int servo_rad(float angle)
      • int servo_deg(float angle)
  • 9.2 Sensor Input
    • int digital(int p)
    • int analog(int p)
    • 9.2.1 User Buttons and Knob
      • int stop_button()
      • int start_button()
      • void stop_press()
      • void start_press()
      • int knob()
    • 9.2.2 Infrared Subsystem
      • int sony_init(1)
      • int sony_init(0)
      • int ir_data(int dummy)
  • 9.3 Time Commands
    • void reset_system_time()
    • long mseconds()
    • float seconds()
    • void sleep(float sec)
    • void msleep(long msec)
  • 9.4 Tone Functions
    • void beep()
    • void tone(float frequency, float length)
    • void set_beeper_pitch(float frequency)
    • void beeper_on()
    • void beeper_off()
• 10 Multi-Tasking
  • 10.1 Overview
  • 10.2 Creating New Processes
  • 10.3 Destroying Processes
  • 10.4 Process Management Commands
    • kill_all
    • ps
  • 10.5 Process Management Library Functions
    • void hog_processor()
    • void defer()
• 11 Floating Point Functions
• 12 Memory Access Functions
  • int peek(int loc)
  • int peekword(int loc)
  • void poke(int loc, int byte)
  • void pokeword(int loc, int word)
  • void bit_set(int loc, int mask)
  • void bit_clear(int loc, int mask)
• 13 Error Handling
  • 13.1 Compile-Time Errors
  • 13.2 Run-Time Errors
• 14 Binary Programs
  • 14.1 The Binary Source File
    • 14.1.1 Declaring Variables in Binary Files
    • 14.1.2 Declaring an Initialization Program
  • 14.2 Interrupt-Driven Binary Programs
  • 14.3 The Binary Object File
  • 14.4 Loading an ICB File
  • 14.5 Passing Array Pointers to a Binary Program
• 15 IC File Formats and Management
  • 15.1 C Programs
  • 15.2 List Files
  • 15.3 File and Function Management
    • 15.3.1 Unloading Files
• 16 Configuring IC
• About this document ...