PI2 ported to arduino

[joop]

I have grabbed the code for PI2, instead of using a PIC12F1840 I changed the code so it runs on arduino (atmega328 in my case). There are quite a bit of differences from the PIC code:

• Each instruction takes 1 clock cycles. Time resolution is 0.0625us.
• Timer2 controls the main loop (8 bits).
• Timer1 controls delays (16 bits).

Timer0 needs to be disabled, or it will mess up your timings. This means you can not use any of the delay functions, nor can you use serial output. Digital outputs used are D13 for the txpulse, D12 for the sample pulse and D11 for the PWM audio. The delay pot is read at analog input 5 (A5). I have added comments in the code to clarify things.

One thing that puzzles me... using Timer1Delay, the smallest possible delay is 15 us. This is much larger than when using the PIC. I don't know the reason for this. Maybe I can find a solution for this one day.


//------------------------------------------------------------------------------
// Arduino PI Firmware
//------------------------------------------------------------------------------
// This project uses the Arduino Uno
// Clock is run off the internal 16MHz oscillator
// Each instruction takes 1 clock cycles so time resolution is 0.0625us
// Timer2 controls the main loop, has 8 bits plus prescaler.
// Timer1 controls delays, has 16 bits plus prescaler.

//--- Defines ---
#define TxPulse 13
#define SamplePulse 12
#define PWMPulse 11
#define DelayPot A5

#define period 47 // 255-208 -> 1664us (~600 Hz)
#define TxPulseWidth 63935 // 65535 - 1600 -> 100 uS
#define SampleWidth 65295 // 65535 - 240 -> 15 uS
#define AudioDelay 65135 // 65535 - 400 -> 25 uS
#define AudioWidth 62335 // 65535 - 3200 -> 200 uS

//--- Variables ---
unsigned int Sample1Delay = 65535-240; // 15us

//------------------------------------------------------------------------------
// Initialization routines

// Initialize the I/O pins and set some flags
//
void Init (void)
{
pinMode (TxPulse, OUTPUT);
pinMode (SamplePulse, OUTPUT);
pinMode (PWMPulse, OUTPUT);
TCCR0A = 0; // disable timer0
TCCR0B = 0;
}

// Timer2 is 8 bits with Div128, so delay is (255-n)*128/Fosc
// For Fosc = 16MHz Timer2 has 8us of resolution
void InitTimer2 (void)
{
TCCR2A = 0;
TCCR2B = 0;
bitSet (TIMSK2, TOIE2); // Enable Timer2 interrupt
TCCR2B = 0x05; // Prescaler = /128 (8 us resolution)
}

// Timer1 is 16 bits and clocked at 16MHz; use PS=1 for 0.0625us resolution
//
void InitTimer1 (void)
{
TCCR1A = 0;
TCCR1B = 0;
bitClear (TIMSK1, TOIE1); // Don't allow an interrupt
TCNT1 = 0; // Clear the timer
TCCR1B = 0x01; // Prescaler = /1 (62.5ns resolution)
}

void setup ()
{
Init ();
InitTimer2 ();
InitTimer1 ();

TCNT2 = 200; // Set the timer
}

//------------------------------------------------------------------------------
// Processing routines

// Delay (in us) = 65535-n
// Because of the fudge factor, ~15us is the minimum delay.
//
void Timer1Delay (unsigned int n)
{
n += 235; // Adjust for fixed error (approx 15us)
TCNT1 = n; // Load the counter
bitSet (TIFR1, TOV1); // Clear the flag
while (!(TIFR1 & (1<<TOV1))) {;} // Wait for a flag
}

// Read the pulse delay pot
//
void ReadDelayPot (void)
{
static int value;

value = analogRead(DelayPot); // Wait for the ADC to finish
Sample1Delay = 65535 - 240 - value; // 15us min, 64us max
}

// ISR() is the interrupt service routine for Timer2. The main loop is
// triggered off this interrupt and must be completed before the next
// interrupt.
ISR (TIMER2_OVF_vect)
{
TCNT2 = period; // Reset the timer
digitalWrite (TxPulse, HIGH);
Timer1Delay (TxPulseWidth); // Transmit pulse
digitalWrite (TxPulse, LOW);

Timer1Delay (Sample1Delay); // TX-to-sample pulse delay
digitalWrite (SamplePulse, HIGH);
Timer1Delay (SampleWidth); // Sample pulse
digitalWrite (SamplePulse, LOW);

Timer1Delay (AudioDelay); // Delay for audio
digitalWrite (PWMPulse, HIGH);
Timer1Delay(AudioWidth); // Speaker pulse
digitalWrite (PWMPulse, LOW);

ReadDelayPot();

// The remaining routines are where extra processing gets done. It is critical
// that all processing is complete before the next TCNT0 interrupt occurs, which
// depends on the TX pulse rate, TX pulse width, and sampling time. If the pulse
// rate = 600Hz, pulse width = 100us, and max sampling time = 35us then the
// processing time available is 1667us - 100us - 35us = 1532us. With a 16MHz
// clock we have an instruction cycle of 0.0625us, so there is time for 24512 code
// instructions, including calls and returns.
}


void loop ()
{
}

[dfbowers]

Nice! I'm running the ATmega328 as well. Looks like it would be an easy matter to just run the chip stand-alone with a few extra components and use the Arduino as a programmer.
I'm tempted to give it a try.

Thanks Joop!
Don

[joop]

Hi Don,

I am rather surprised that it worked so well. I might spent some time designing a shield for this. It would also be an easy task to add extra analog inputs for setting the tx pulse and sample pulse width, I still have 4 analog inputs left.

[joop]

I noticed a small error in the last comments inside the code.

"before the next TCNT0 interrupt occurs"

should read:

"before the next TCNT2 interrupt occurs"

[Krzysztof]

Hi.
Also I am using the Arduino Nano 16 MHz, easy and fun.
Joop.
Your minimum delay depends on the settings of the prescaler T1.
Best regards Chris.

[joop]

Hi Chris,

thanks, will check it out.

I found another reason for the minimum delay. A quote from the arduino forum:

"The overhead of abstracting IO to "pin number" is pretty substantial: a subroutine call, lookup table to get the port, another lookup table to get the bit, a third to check whether analogWrite is in use, and then less efficient instructions to access the port "indirectly""

The solution would be to use:

PORTB |= 0x20; // turn D13 on

Instead of:

digitalWrite (TxPulse, HIGH);

There seems to be a 20x time penalty when using the standard digitalWrite command. Will check it out some time this week on my setup. Disadvantage is of course that the code becomes less readable.

[ODM]

Serial port and Timer 0 etc. will become useable without the arduino layer's allocating of resources. It makes for more "simple" code but it is full of pitfalls for inexperienced programmers - just like that IO overhead.

It's possible to abstract things without slowdown; for example like this if defining a pin for sampling output to pin 2 of PORTD:

(assuming PORTD,2 is already an output)
#define SAMPLE_OUT PORTD
#define SAMPLE_PIN 2
// sample pin = 1
SAMPLE_OUT |= (1<<SAMPLE_PIN)
// sample pin = 0
SAMPLE_OUT &= ~(1<<SAMPLE_PIN)

The same syntax goes with any io_OUT and io_PIN - this leaves the option to use io_IN and io_PIN for reconfiguring the same interface pin on the fly for various purposes. Example above can be yet shortened with macros, but it also introduces the usual C hazards of macros.

[Krzysztof]

Hi Joop.
In this interrupt the T2 I count the incoming pulses on D5 to T1.

ISR(TIMER2_OVF_vect) { //T2 Int
if (tics==mp) {
TCCR1B = TCCR1B & ~7; //T1 stopped
cbi (TIMSK2,TOIE2); //T2 disable Int10
sbi (TIMSK0,TOIE0); //T0 enable
licz=0x10000 * mtp;
licz += TCNT1;
mtp=0;
ready=1;
}
tics++; //count number of interrupt events
if (TIFR1 & 1) { //if T1 overflow flag
mtp++; //count number of T1 overflows
sbi(TIFR1,TOV1); //clear T1 overflow flag
}
}

At the time the measurement pulses off the T0 (mills, delay, serial).
The measurement is very stable and accurate.
I use a lot of ASM.
See about switching speed:http://tronixstuff.wordpress.com/201...-manipulation/
Best regards Chris.

[joop]

It's possible to abstract things without slowdown; for example like this if defining a pin for sampling output to pin 2 of PORTD:

Thanks ODM,

I like the idea, this will make the code much more readable. Wiil try to add it to the next version.

[joop]

The measurement is very stable and accurate.
I use a lot of ASM.
See about switching speed:http://tronixstuff.wordpress.com/201...-manipulation/

Hi Chris,

I didn't know you can intermix assembly and arduino code, interesting! Thanks for the tronixstuff link, it is very helpful.

[Krzysztof]

Hi Joop.
ASM can be:

#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))

and so:

cbi (TIMSK0,TOIE0); //T0 dissable millis and delay
TCCR1A=0;
TCCR1B=0;
TCCR2A=0;
TCCR2B=0; //Normal tryb
TCCR2B = TCCR2B | 7; //T2 prescaler 1024
sbi(TIFR1,TOV1); //T1 clear overflow flag
TCNT1=0; //T1=0
sbi (GTCCR,PSRASY); //T2 prescaler=0
TCNT2=0; //T2=0
TCCR1B = TCCR1B | 7; //T1 start
sbi (TIMSK2,TOIE2); //T2 enable OVF Int10)
while (ready == 0); //czekaj

Best regards Chris.

[joop]

Thanks Chris!

[joop]

Here's the modified version. Shortest delay is now below 1 microsecond!

//------------------------------------------------------------------------------
// Arduino PI Firmware
//------------------------------------------------------------------------------
// This project uses the Arduino Uno
// Clock is run off the internal 16MHz oscillator
// Each instruction takes 1 clock cycles so time resolution is 0.0625us
// Timer2 controls the main loop, has 8 bits plus prescaler.
// Timer1 controls delays, has 16 bits plus prescaler.

// a bit of history:
// version 1.0 - published jan 29, 2013 using standard Arduino commands, shortest
// delay possible because of this is about 15 microseconds
// version 1.1 - published feb 03, 2013 replace all of the digitalWrite command
// with direct port access, shortest delay below 1 microsecond

//--- Defines ---
#define DIGITAL_OUT PORTB
#define TX_PIN 5 // PB5 or D13
#define SAMPLE_PIN 4 // PB4 or D13
#define PWM_PIN 3 // PB3 or D11

#define DelayPot A5

#define period 47 // 255-208 -> 1664us (~600 Hz)
#define TxPulseWidth 63935 // 65535 - 1600 -> 100 uS
#define SampleWidth 65295 // 65535 - 240 -> 15 uS
#define AudioDelay 65135 // 65535 - 400 -> 25 uS
#define AudioWidth 62335 // 65535 - 3200 -> 200 uS

//--- Variables ---
unsigned int Sample1Delay = 65535-240; // 15us

//------------------------------------------------------------------------------
// Initialization routines

// Initialize the I/O pins and set some flags
//
void Init (void)
{
DDRB = B00111111; // set PORTB (digital 13-8 to outputs
TCCR0A = 0; // disable timer0
TCCR0B = 0;
}

// Timer2 is 8 bits with Div128, so delay is (255-n)*128/Fosc
// For Fosc = 16MHz Timer2 has 8us of resolution
void InitTimer2 (void)
{
TCCR2A = 0;
TCCR2B = 0;
bitSet (TIMSK2, TOIE2); // Enable Timer2 interrupt
TCCR2B = 0x05; // Prescaler = /128 (8 us resolution)
}

// Timer1 is 16 bits and clocked at 16MHz; use PS=1 for 0.0625us resolution
//
void InitTimer1 (void)
{
TCCR1A = 0;
TCCR1B = 0;
bitClear (TIMSK1, TOIE1); // Don't allow an interrupt
TCNT1 = 0; // Clear the timer
TCCR1B = 0x01; // Prescaler = /1 (62.5ns resolution)
}

void setup ()
{
Init ();
InitTimer2 ();
InitTimer1 ();

TCNT2 = 200; // Set the timer
}

//------------------------------------------------------------------------------
// Processing routines

// Delay (in us) = 65535-n
// Because of the fudge factor, ~0.75us is the minimum delay.
//
void Timer1Delay (unsigned int n)
{
n += 12; // Adjust for fixed error (approx 0.75us)
TCNT1 = n; // Load the counter
bitSet (TIFR1, TOV1); // Clear the flag
while (!(TIFR1 & (1<<TOV1))) {
;
} // Wait for a flag
}

// Read the pulse delay pot
//
void ReadDelayPot (void)
{
static int value;

value = analogRead(DelayPot); // Wait for the ADC to finish
Sample1Delay = 65535 - 12 - value; // about 0.75us min, 64us max
}

// ISR() is the interrupt service routine for Timer2. The main loop is
// triggered off this interrupt and must be completed before the next
// interrupt.
ISR (TIMER2_OVF_vect)
{
TCNT2 = period; // Reset the timer

DIGITAL_OUT |= (1<<TX_PIN);
Timer1Delay (TxPulseWidth); // Transmit pulse
DIGITAL_OUT &= ~(1<<TX_PIN);

Timer1Delay (Sample1Delay); // TX-to-sample pulse delay

DIGITAL_OUT |= (1<<SAMPLE_PIN);
Timer1Delay (SampleWidth); // Sample pulse
DIGITAL_OUT &= ~(1<<SAMPLE_PIN);

Timer1Delay (AudioDelay); // Delay for audio

DIGITAL_OUT |= (1<<PWM_PIN);
Timer1Delay(AudioWidth); // Speaker pulse
DIGITAL_OUT &= ~(1<<PWM_PIN);

ReadDelayPot();

// The remaining routines are where extra processing gets done. It is critical
// that all processing is complete before the next TCNT0 interrupt occurs, which
// depends on the TX pulse rate, TX pulse width, and sampling time. If the pulse
// rate = 600Hz, pulse width = 100us, and max sampling time = 35us then the
// processing time available is 1667us - 100us - 35us = 1532us. With a 16MHz
// clock we have an instruction cycle of 0.0625us, so there is time for 24512 code
// instructions, including calls and returns.
}


void loop ()
{
}

[dfbowers]

Nice work and thank you for the contribution Joop. That opens doors for other possibilities.

DON

[joop]

Hope you can use it Don!

There's a small error in one of the comments: PB4 equals D12 (define section at the top)...