CS452 - Real-Time Programming - Fall 2011

Lecture 2 - Introduction

Pubilc Service Annoucements

1. Due date for assignment 0
2. Combination to trains lab
3. Ubuntu 10.10
4. How to compile and run your first program

Practical Details: pdf

Embedded Systems

Artifacts that use computation to manipulate the real-world, including user interfaces, have a structure that can be described in one of two different ways.

1. Computation measures the response of sensors to determine the correct state for its internal model of the world, and that model is used to calculate appropriate activator responses.
2. Actvators are manipulated according to the state of the artifacts internal model of the world,after which computation reads sensors to calculate the effect of their action on the world.

Most of the mediation between the internal representations and the real-world is done by embedded systems

• invisible computing
• sense and control
• billions and billions sold

What is real-time programming?

Actually real-world programming, which means

• World is measured in seconds, metres, etc.
• Programs manipulate bits, bytes, words, which must be translated into into real-world measures.
  For example,
  • formatted output: translate from int, which computers manipulate, to decimal, which humans read
    • out in the open: i2a( ), printf( )
    • hidden: print, cout
  • Banking: int translates into, e.g., number of cents
    • program says dispense( 10000 ), which means `put five twemties into the hopper'.
    • microcontrollers start
      • activating motors
      • sensing forces
      • reading digitized video
      • etc.
  • Train control: contents of messages map into change speed, switch turn-out, sensor triggered

What is important for real-time?

1. Throughput
   • e.g., number of frames per second in a game
   • e.g., frequency of sensor sampling in process control
   • no solution except
     1. getting better hardware
     2. getting better algorithms
     3. restructuring the task
2. Response time
   • e.g., time from button press to gun firing in game
   • e.g., time from sensor reading to control code executing in provess control
   • several programming techniques exist
     1. busy-wait
     2. polling loop

     tension between flexibility and performance

In cs452 we take guaranteed response time as the defining quality of real-time computation.

Assignment 0

Objective

Go beyond busy-waiting to maintain several synchronized activities simultaneously.

To be specific

Output to the terminal

1. Write the current time on the display of the terminal
   • will need cursor addressing
2. Display of the state of the train-set on the display of the terminal
3. Prompt and echo for input

Input from the terminal

1. User commands for the train-set

Output to the train-set

1. Give speed commands
2. Switch turn outs
3. Request sensor data

Input from the train-set

1. Sensor reports

Output to the timer

1. Initialization

Input from the timer

1. Current count

Software Design

No operating system services available, including

1. input output
2. dynamic memory
3. hardware abstractions
4. file system

Polling loop design

Generalization of busy-waiting

Sending a byte onto a 115,200 bps serial line

• 10 bits per byte
• 11,520 = 10,000 bytes per second
• ready sets after 100 microseconds
• software could
  • test the byte 200 times (busy wait), OR
  • test the byte less frequently and do something else with the extra time (polling loop).

The polling loop

while( true ) {
    if( transmit ready bit set )
        if( NOT output buffer empty )
            write next byte
    if( receive ready bit set )
        read next byte into buffer
    if( timer has counted down )
        increment time
    ...
}

This generalizes to

while( true ) {
    if( condition1 )
        do action1
    if( condition2 )
        do action2
    ...
    if( condition-n )
        do action-n
    ...
}

Attractive feature of a polling loop

• You can calculate the worst case response time

Unattractive feature of polling loop

• The worst case response time is very pessimistic

Hardware Available

Timers

Generic timer

Three registers

1. Command register
2. Load register
3. Read register

The generic timer

• counts down from the loaded value
• reloads and keeps counting when it hits zero
• sets an interrupt when it reaches zero

In a polling loop the interrupt is not used.

Find out the details in the EP9302 documentation. Of the five, or is it six, timers on the EP9302 SoC use the 32-bit one.

UARTs

Generic UART

Three wires

1. transmit (XMIT)
2. receive (RCV)
3. ground

(Transmit and receive must be crossed.)

Two registers

1. Command/status register
   • read to get the state of the UART
   • write to give commands to the UART
2. Data register
   • read when receiving a byte
   • write when sending a byte

Common added features

• Separate command & status registers
• Separate (readable) register for setting line parameters such as bps, start bits, parity, etc
• Separate register for reading error conditions, of which the important ones are
  • framing
  • overrun

Generic UART with hardware flow control

Two extra wires, usually

1. request to send (RTS) an output
2. clear to send (CTS) an input

(Like XMIT and RCV, RTS and CTS must be crossed.)

Assert RTS when you are ready to receive a character. Read CTS to ensure that the receiver is ready before you transmit a character.

Notes.

1. Find the details in the EP9302 documentation.
2. If you examine the TS-7200 circuit diagram you will see that there is a third UART available. The connector called COM3 does not have this UART attached to it, but rather some digital I/O bits and some other random stuff.

Return to:

• Bill Cowan's Fall 2011 CS452 page
• Bill Cowan's CS452 page
• Bill Cowan's teaching page
• Bill Cowan's home page