iRobot Create REFERENCES

Create 25-pin Cargo Bay Connector:
1 RXD
2 TXD
3 Power Control Toggle
4 Analog Input
5 Digital input 1
6 Digital input 3
7 Digital output 1
8 Switched 5V (100ma)
9 Vpwr (unregulated, 500ma)
10 Switched Vpwr (1500ma)
11 Switched Vpwr (1500ma)
12 Switched Vpwr (1500ma)
13 Robot charging
14 GND
15 BRC (digital input/baud-rate-change to 19200)
16 GND
17 Digital input 0
18 Digital input 2
19 Digital output 0
20 Digital output 2
21 GND
22 Low side driver 0 (500ma)
23 Low side driver 1/IR LED (500ma)
24 Low side driver 2 (1500ma)
25 GND

This is how I calculate my running x,y coordinates using the Create  Distance and Angle sensor data:

/********************************
  currentX, currentY - uint16_t globals to maintain current coordinates
 targetX, targetY - uint16_t globals hold the coordinates we want to head toward
 targetAngle - uint16_t global holds the direction we should head (line-ofsite) to reach targetX,targetY
 targetDistance - uint16_t global holds the distance (line-of-site) to targetX,targetY
********************************/
void CalcNewPosition(int16_t dist, int16_t angl)
{ // calculate new position using dist and angl
 double x,y,h;
 
 // update current x,y coordinats
 // radians = angl/57.296
 // newx = dist * sin(radians)
 // newy = dist * cos(radians)
 currentX += ( dist * sin( angl / 57.296 ));
 currentY += ( dist * cos( angl / 57.296 ));

 // calculate heading to targetX,targetY from currentX,currentY
 // (solve: tan t = opposite/adjacent 
 // == atan2(adjacent,opposite) - convert 0..3.14159 radians to to 0..359 degrees
 targetAngle=(atan2(currentX-targetX, currentY-targetY)*1000) / 17.4533;
 targetAngle+=180;
 if(targetAngle>359)
  targetAngle-=360;
 
 // calculate distance directly to target
 // (solve for the hypotenuse of the triangle) hypotenuse=sqrt(x^2 + y^2)
 if(currentX>targetX)
  x=currentX-targetX;
 else
  x=targetX-currentX;
 if(currentY>targetY)
  y=currentY-targetY;
 else
  y=targetY-currentY; 
 h=sqrt(x*x+y*y);
 targetDistance=h;
}

Here's how Create transitions between the states in packet 21, under
normal conditions:

  Charge requested?
  |
  Battery hot?
  |   |
  N   Y
  |   |
  |   WAITING
  |   |
  Voltage very low?
  |  |
  N  Y
  |  RECONDITIONING
  |           |
  FULL CHARGE |
  |           |
  Battery hot ?
  |   |
  N   Y
  |   |
  |   WAITING
  |   |
  TRICKLE

The FAULT state is entered whenever a problem occurs during charge

Here's an overview of how the scheduling remote formats and transmits schedule packets:

Scheduling remote opcode format

total schedule packet is 11 bytes long, in the following format:
bytes 0-2  => current time
byte  3    => schedule days
bytes 4-10 => schedule


current time is 3 bytes long, in the following format:
[ days   ][ hours  ][ mins   ][seconds ]
[ 3 bits ][ 5 bits ][ 8 bits ][ 8 bits ]

schedule days stores whether each day is in use.  It is one byte long, in
the following format:
[day 0][day 1] ... [day 6][unused]
[bit 0][bit 1] ... [bit 6][bit 7 ]


schedule is 7 bytes long, in the following format:
[  day 0 ] ... [  day 6 ]
[ 8 bits ] ... [ 8 bits ]

Each day of a schedule is one byte long, in the following format:
[ hours  ][ minutes ][ weekly or once ]
[ 5 bits ][ 2 bits  ][ 1 bit          ]


Sending the Packet

Constants:
initial crc = 0x5555
nop = 128
download = 142
packet length = 11
escape char = 128

Variable:
crc (16 bits long)

Functions (in Lisp):
(defun crc16-8 (crc-in new)
   (loop for bit from 0 to 7
         for new-item = new then (ash new-item -1)
         for prev-crc = crc-in then crc
         for crc = (logxor (ash prev-crc -1)
                           (if (/= (logand new-item 1) (logand prev-crc 1))
                             #x8005
                             0 ) )

         finally (return crc) ) )


(defun send-ir-char-escaped (char)
  (if (or (= char data-packet-escape-char)  ; 128
          (= char remote-opcode-download) ) ; 142
(progn
   (send-ir-char data-packet-escape-char) ; 128
   (send-ir-char (logxor char data-packet-escape-char)) )
(send-ir-char char) ) )


Steps to send the packet:

0) crc = #x5555
1) send NOP
2) send DOWNLOAD
3) crc = crc(crc, remote-opcode-download) // 142
4) send ESCAPED packet length // 11
5) crc = crc(crc, packet length) // 11
6) for i from 0 to 10 (packet length)
     send ESCAPED packet[i]
  crc = crc(crc, packet[i])

7) send ESCAPED low byte of ctc
8) send ESCAPED high byte of crc

Power Consumption:

 When the robot is powered off, it robot consumes ~60ua.
The robot consumes about 140ma while on but not moving.
The Command Module consumes about 40ma with processor running and various LED’s on.

Changing Modes after Charger is detected:

1) Connect your robot to the charger (internal or dock) while it is in full mode.
2) Send opcode "7". This is not an official OI opcode, rather it is an opcode used by Osmo to initiate a soft reset of the robot and force it to run its bootloader.
3) The robot resets. Wait for the bootloader to complete. Do NOT send any opcodes whie the bootloader is running.
4) The robot should start charging. Note that the robot spews some battery-related text if it is charging and not in OI mode. Ignore this text.
5) Enter a Start command to get back into the OI (and stop the spew).

Charging & Docking:

Charging currently triggers only on the rising edge of the charger becoming available, so if you switch to passive mode after the charger is connected (dock or internal charger), the robot does not charge.

Reserved I/O Lines:

Create IR Transmitter/Receiver

An "ON" is a 38khz PWM signal.
Each byte is 8 bits.
Each bit is 4 ms long.
A 0-bit consists of a 1 ms ON followed by 3 ms OFF.
A 1-bit consists of a 3 ms ON followed by 1 ms OFF.
The end of a byte is marked by 4 ms OFF.

I didn't realize what they meant by a "38khz Carrier Frequency" until I tried to implement an IR Transmitter.  A "Carrier Frequency" means when you are transmitting an ON signal, it is actually Pulsed On and Off at 38000 times per second.  If you don't do this, then the receiver will see a single pulsed ON at the beginning of your ON time but then the receiver will interpret the rest as OFF.  When transmitting an OFF signal, simply don't transmit anything.  It's only the ON signals that have to be pulsed at 38khz.

This is a capture of byte 130 (10000010) received from the Create/Roomba remote (forward button).
You can see the 3ms ON and 1ms OFF for the 1-bits, and 1ms ON and 3ms OFF for the 0-bits, then 4ms OFF for the Stop-bit.  (9 bits total including the Stop bit)  The byte is then repeated about 27ms later while the button is held down.  One byte is transmitted every 62ms (begin byte to next being byte) while the remote button is held down.
(NOTE: My ON/OFF's are inverted here, normally you have a high-output and the IR Receiver pulls low when receiving bits)

Make your own Virtual Wall for the Create or Roomba:

The Virtual Walls generate a 1ms ON, 1ms OFF signal continuously.  The 1ms ON is a 38Khz PWM pulse.  I haven't written a program to simulate this, but it should be simple to modify the IR Beacon source code.

A simple RS-232 to TTL Serial Converter:

I wanted to be able to Receive RS-232 data without adding a MAX232 conversion chip so after searching around I found a simple circuit to convert RS-232 to TTL without a chip.

I am using the PC to PIC converter (above) to Receive RS-232 @ 9600 baud on a Propeller Chip with a 10k and a 2.2k resistor (didn't have a 3.3k), a standard PN2222 transistor, and a 1N4001 diode.  I am supplying Vdd with 3.3v.  I haven't needed to try the PIC to PC converter yet.

Capacitor Conversion Chart