To initialize the UART, please use this code. It is already done for you by default in the Axon source code.

uartInit(); // initialize the UART (serial port)
uartSetBaudRate(0, 38400); //set UARTE speed
uartSetBaudRate(1, 115200); //set UARTD speed, for USB
uartSetBaudRate(2, 38400); //set UARTH speed
uartSetBaudRate(3, 38400); //set UARTJ speed

To declare which UART port to use, here is an example. The last UART to get initialized is the one to be used:

rprintfInit(uart0SendByte);
rprintf(" UART 0");
rprintfInit(uart1SendByte);//USB
rprintf(" UART 1");
rprintfInit(uart2SendByte);
rprintf(" UART 2");
rprintfInit(uart3SendByte);
rprintf(" UART 3");

The Axon is set up to immediately send out analog data over the USB at 115200bps. You can easily output data in code by using this line:

rprintf("Hello, World! Data: %d", variable);

To receive a character from the UART:

temp=uart3GetByte();//get a single character

Additional code will be included soon for capturing data streams.

Please view the rprintf.h and uart4.h source code for further documentation.

The Axon has 6 timers with resolution as follows: 16-bit Timers on 1,3,4,5 8-bit Timers on 0, 2

To initialize a timer:

timer0Init(); //initialize the timer0 system
timer2Init(); //initialize the timer2 system

To reset the timer and overflow counter:

//clears timer, reset overflow counter
reset_timer_0();//reset timer 0
reset_timer_2();//reset timer 2

To retrieve timer value:

//read timer0's overflow counter
//255 is count before overflow, dependent on clock
elapsed_time=timer0GetOverflowCount()*255+TCNT0;

//configure which ports are analog, digital, etc.
configure_ports();

More information and settings for port configuration can be found in SoR_Utils.h.

//initialize analog to digital converter
a2dInit();
//configure ADC scaling
a2dSetPrescaler(ADC_PRESCALE_DIV32);
//configure ADC reference voltage
a2dSetReference(ADC_REFERENCE_AVCC);

Then to read an analog port, do this:

int se0, se1, se2;

//read pin0 through pin2, store as variables
se0=a2dConvert8bit(0);
se1=a2dConvert8bit(1);
se2=a2dConvert8bit(2);

rprintf("%d %d %d\n",se0,se1,se2);

if (se0<100)
	robot_move_();
else if (se0>150)
	robot_stop();
else
	robot_turn();

If you look in sensors.c, you will find additional functions that convert ADC sensor values to real world measurements. For example, to get a measurement in centimeters for a Sharp IR rangefinder, use this code:

//read ADC pin 0, and convert
//the value into centimeters
distance=sharp_IR_interpret_GP2D12(a2dConvert8bit(0));

//read ADC pins, and convert
//the value into degrees rotation
accel_X=accelerometer_ACCM3D(a2dConvert8bit(0));
accel_Y=accelerometer_ACCM3D(a2dConvert8bit(1));
accel_Z=accelerometer_ACCM3D(a2dConvert8bit(2));

Refer to a2d.h and sensors.c in the source code to learn more about the ADC functions.

The first way offers the maximum time resolution possible. This method should be used if you do not require exact timing, but works well enough for servos and general wait commands:

delay_cycles(65500);

The second method involves using a timer interrupt on timer0. Typically this is the 'correct' wait for doing a delay, but could potentially cause conflicts if you are using other timer interrupts or have other time-sensitive algorithms running simultaneously.

delay_us(1000);//delay for 1000us
delay_ms(1000);//delay for 1000ms

delay_cycles uses a long int, so you can't delay more than 2^16 = 65536 (for 0 to 65535). Just do something like this to delay longer:

delay_cycles(65500);
delay_cycles(65500);
delay_cycles(65500);

Refer to timer640.h for more documentation on the timer. Note that the compiler will ignore delay_cycles if you turn on compiler optimization.

The green LED can be controlled by a simple function call.

LED_on();  //turn green LED on
LED_off(); //turn green LED off

The button is used with a digital port:

//returns 0 if button not pushed, 1 if pushed
button_pressed();

This is an example of how to pause your code until a button is pushed:

//wait until button is pushed to proceed
while(!button_pressed());

Example code on how to add to a variable when a button is pushed:

//wait until button is pushed to proceed
int counter;
while(1)
	{
	if(button_pressed())
		{
		counter++;
		//must add a debounce delay
		delay_ms(20);
		}
	//do stuff for different counter values here
	}

Remember that you must debounce the button in software! If not, a single button push could result in counter being incremented multiple times. The delay time is up to you.

The quick way to command a servo would be to use this code:

servo(PORTA,7,360);

where A is the port letter, 7 is the pin number, and 360 is the servo pulse duration in cycles.

However, when programming robots, it is easier to refer to pins and ports by using plain English. For example, it is easier to remember that a servo is 'Left_Wheel_Servo' as opposed to 'A7'.

To configure your hardware naming scheme, open up the file hardware.c. Add this below line into the code. You may see other examples already there.

#define Left_Wheel_Servo( position )	servo(PORTA,7,position)

And then in your main code, just use this line to use that servo:

Left_Wheel_Servo(600);//command this servo

Remember to NOT send a command to a servo more than once every 10 to 20ms, or it could potentially damage the servo. Adding a few ms delay after your servo code would be a quick safe solution, but isn't always needed.

delay_ms(10);

People ask all the time for the code used to center the servo. Well, here you go!

while(1)
	{
	wheel_left(700);
	delay_ms(20);
	}

By default, all Axon digital ports are set as outputs (for use with servos). But you can also make them input pins.

First, you must declare the pin a digital input. Look at the file SoR_Utils.h for examples, and read the comments for instructions.

You can also do it quick and dirty in control.c like this:

cbi(DDRG, PG5);  //set G5 as input pin

Then, just like in the button code, you'd want to read the pin:

bit_is_clear(PING, 5);  //returns a 1 or 0
bit_is_set(PING, 5);  //returns a 1 or 0

Make sure you turn on resistor pull-ups before using I2C. SCL is on port D0 and SDA is on D1. By default, the I2C uses the Axon USB to output debug information.

i2cInit();  //initialize I2C interface
i2cSetBitrate(2);  //set I2C transaction bit rate in kHz

//set local device address and allow
// response to general call
i2cSetLocalDeviceAddr(LOCAL_ADDR, TRUE);

//set the Slave Receive Handler function
// this function will run whenever a
// master somewhere else on the bus
// writes data to us as a slave
i2cSetSlaveReceiveHandler(i2cSlaveReceiveService);

//set the Slave Transmit Handler function
// this function will run whenever a master
// somewhere else on the bus
// attempts to read data from us as a slave)
i2cSetSlaveTransmitHandler(i2cSlaveTransmitService);

//Send I2C start condition in Master mode
i2cSendStart();

//Send I2C stop condition in Master mode
i2cSendStop();

//Wait for current I2C operation to complete
i2cWaitForComplete();

//Send (address|R/W) combination or a data byte over I2C
i2cSendByte(data);

//Receive a data byte over I2C  
// ackFlag = TRUE if recevied data should be ACK'ed
// ackFlag = FALSE if recevied data should be NACK'ed
i2cReceiveByte(ackFlag);

//Pick up data that was received with i2cReceiveByte()
i2cGetReceivedByte();

//Get current I2c bus status from TWSR
i2cGetStatus();

All sensor code, and full documentation with datasheets, may be found in sensors.c. Below code are examples of how to get data from a particular sensor.

Control Sabertooth 2x5, 2x10, and 2x25 from Dimension Engineering by serial:

//send command to (motor 1, motor 2)
sabertooth(60,198);//default at UART2, 38400 baud
//swap back to your uart here

Control Syren 10, 20, and 25 from Dimension Engineering by serial:

//send command to (motor)
syren(198);//default at UART2, 38400 baud
//swap back to your uart here

Random Numbers

//sets random seed to current timer value
srandom(TCNT0);
//returns random number between 0 and 32767
random_number = rand();