1. Developing a bicycle speed-o-meter
Midterm Review
NOTE after the midterm, Dr. Krisnamurphy will be tackling this design with you on the 68K processor so you can get practice using a different processor

2. General Project concept
Blackfin Programmable
Flag (PF) Input
Magnetic Sensor Signal
Motorola Parallel Interface
Timer (PIT) Input
High speed clock signal
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

3. Main function concept ulong DetermineSpeed(ulong wheelDiameter, ulong clockFrequency)
#define ulong unsigned long int;
extern “C” ulong CountClockASM(const int); // Assembly code interface
extern “C” ulong CalculateSpeedASM(ulong, ulong, ulong);
extern “C” void SetupInterface(void);
ulong DetermineSpeed(ulong wheelDiameter, ulong clockFrequency) {
// Get to known position on magnetic sensor signal
unsigned long discard_count;
unsigned long count_high, count_low;
SetupInterface( );
discard_count = CountClockASM(while_MagneticSensorHigh); // Not ready yet
discard_count = CountClockASM(while_MagneticSensorLow); // Not ready yet
count_high = CountClockASM(while_MagneticSensorHigh);
count_low = CountClockASM(while_MagneticSensorLow);
return CalculateSpeedASM(count_high + count_low, wheelDiameter, clockFrequency); }
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

4. How many clock ticks pass while magnetic sensor value stays a certain way?
extern “C” ulong CountClockASM(const int); // Assembly code interface
extern “C” void SetupInterface(void);
extern “C” ulong CalculateSpeedASM(ulong, ulong, ulong);
ulong CountClockASM(const int high_low) { // Either a high magnetic sensor value (1)
// or low sensor value (0) needs measuring
ulong clock_count = 0;
while (magnetic_sensor = = high_low) { // if signal is unchanged from start
// Must count just one clock signal low-to-high transition
while (clock_signal = = high) /* wait */;
while (clock_signal = = low) /* wait */; // Changes on low-to-high edge
clock_count++; }
return clock_count;
} // Must assume that clock-signal is MUCH faster than sensor signal
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

5. What we need to know
How can you pass parameters between “C/C++” and assembly code functions?
How can you return a parameter from assembly code functions?
What registers are available on the processor?
How do you set up the interface between the processor and the real world
Many signals are coming into processor, how do you separate (mask off) the signals you want from those you don’t?
What are the basic operations for accessing memory?
What are the basic ALU operations for this processor?
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

6. Programming model Blackfin Data Registers R0, R1 …. R7
Address Registers
Pointer Registers
P0, P1 … P5
Frame Buffer FP
Stack Pointer SP
Special DSP
I0-I3, B0-B3, M0-M3, L0-L3
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

7. Syntax examples Blackfin
Register to Register Move reg1  reg 2 32 bit operations
R1 = R2; (1 500 MHz)
Register to Register Move reg1  reg 2 16 bit operations
R1.L = R2.L; and also
R1.H = R2.L;
Register to Register Move reg1  reg 2 8 bit operations
Here is some new syntax that convert 8-bit values into 32 bit values
R1 = R2.B (X); R1.L = R2.B (Z);
R1 = R2.B(X);
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

8. Syntax examples Blackfin
Register to Register ADD reg1  reg 2 + reg3 32 bit operations
R1 = R2 + R3; (1 500 MHz)
Register to Register Move reg1  reg 2 + reg3 16 bit operations
R1.L = R2.L + R3.L (NS);
(1 500 MHz)
Also R1 = R2 +|- R3;
Means R1.L = R2.L – R3.L; and R1.H = R2.H + R3.H;
Register to Register Move reg1  reg 2 + reg3 8 bit operations
R1.L = R2.B (X); R0.L = R3.B (X); R1.L = R1.L + R0.L (NS);
( > MHz)
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

9. 32-bit Memory Move operations
Blackfin
Value at memory location 1 placed at memory location 2
P0.H = hi(_MEM1); P0.L = lo(_MEM1);
P1.H = hi(_MEM2); P1.L = lo(_MEM2); R0 = [P0];
[P1] = R0; > 6 cycles
Multiple moves
P1.H = hi(_MEM2); P1.L = lo(_MEM2); R0 = [P0++];
[P1++] = R0;
R0 = [P0++];
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

10. 16-bit Memory Move operations
Blackfin
Value at memory location 1 placed at memory location 2
P0.H = hi(_MEM1); P0.L = lo(_MEM1);
P1.H = hi(_MEM2); P1.L = lo(_MEM2); R0 =W [P0];
W[P1] = R0; > 6 cycles
Multiple moves
P1.H = hi(_MEM2); P1.L = lo(_MEM2); R0 = W[P0++] (X);
W [P1++] = R0;
R0 = W[P0++] (X);
W[P1++] = R0;
R0 =W [P0++] (X);
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

11. Memory Move operations
Blackfin
Multiple moves of registers
[- - SP] = (R7:5, P5:3);
Combination of memory moves and ALU operations
Can also do parallel read and write operations together with math operations
Syntax looks like this
R1 = R2 | | R3 = [P0++] | | [I1++] = R4;
Not all operations can be made parallel
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

12. If – then – else constructs Signed tests
Blackfin
Set the condition code register
CC = D1 == D0; CC = D1 < D0; CC = D1 <= D0;
Conditional jump
IF CC JUMP NEXT_INSTR
IF !CC JUMP NEXT_INSTR
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

13. If – then – else constructs Un-signed tests
Blackfin
Set the condition code register
CC = D1 == D0 (IU); CC = D1 < D0 (IU); CC = D1 <= D0 (IU);
Conditional jump
IF CC JUMP NEXT_INSTR
IF !CC JUMP NEXT_INSTR
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

14. Example if-then-else code
C++ example
Blackfin
IF (A > B) C = D;
ELSE C = E;
Set A, B, C, D, E to registers R0, R1, .. R4
CC = R1 < R0; IF !CC JUMP ELSE; R2 = R3; JUMP END_IF; ELSE: R2 = R4; END_IF:
CC = R1 < R0; IF CC R2 = R3; IF !CC R2 = R4;
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

15. Example loop code -- software loop
C++ example
Blackfin
sum = 0;
for (loop = 0; loop < 6; loop++) sum = sum + loop;
Set R0 = sum , R1 = loop
R0 = 0; R1 = 0;
R2 = 6;
LOOP: CC = R2 <= R1; IF !CC JUMP PAST_LOOP; R0 = R0 + R1; R1 += 1;
JUMP LOOP
PAST_LOOP:
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

16. Example loop code -- Hardware loop
C++ example
Blackfin
sum = 0;
for (loop = 0; loop < 6; loop++) sum = sum + loop;
Set R0 = sum , R1 = loop
R0 = 0; R1 = 0;
P1 = 6;
LSETUP(LSTART, LEND) LC1 = P1;
LSTART: R0 = R0 + R1; LEND: R1 += 1;
PAST_LOOP: OUTSIDE THE LOOP
Has a capability of 2 hardware (high-speed, zero overhead) loop
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

17. Reminder of what we were trying to do General Project concept
Blackfin Programmable
Flag (PF) Input
Magnetic Sensor Signal
Motorola Parallel Interface
Timer (PIT) Input
High speed clock signal
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

18. Required Assembly Language
extern “C” ulong CountClockASM(const int); // Assembly code interface
extern “C” void SetupInterface(void);
extern “C” ulong CalculateSpeedASM(ulong, ulong, ulong);
ulong CountClockASM(const int high_low) {
ulong clock_count = 0;
while (magnetic_sensor = = high_low) { // if signal is unchanged from start
// Must count just one clock signal low-to-high transition
while (clock_signal = = high) /* wait */;
while (clock_signal = = low) /* wait */; // Changes on low-to-high edge
clock_count++; }
return clock_count;
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

19. Hardware test – wait while magnetic signal is “high”
Blackfin
Magnetic Signal
Bit 10 of FIO_FLAG_D register of PF interface
while (mag_signal == HIGH)
/* wait */ ;
#define MASK 0x400
P0.H = hi(FIO_FLAG_D);
P0.L = lo(FIO_FLAG_D); R1 = MASK;
WHILE:
R0 = W[P0] (Z); R0 = R0 & R1; CC = R0 == R1; IF CC JUMP WHILE (BP);
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

20. Required BF533 Assembly Language
_CountClockASM: R0 contains the INPAR
R1 = 0; P0.H = hi(FIO_FLAG_D); P0.L = lo(FIO_FLAG_D);
WHILE:
R2 = W[P0] (Z); R3 = MASKMAG; // SLOW Magnetic Signal on bit 10
R2 = R2 & R3;
CC = R2 == R0;
IF !CC JUMP ENDWHILE;
R3 = MASKCLK; // FAST Clock Signal on bit 11
HIGH: R2 = W[P0] (Z);
CC = R2 == R3
IF CC JUMP HIGH (BP);
LOW : R2 = W[P0] (Z);
CC = R2 < R3
IF CC JUMP LOW (BP);
R1 += 1;
JUMP WHILE
END_WHILE: R0 = R1; RTS
ulong CountClockASM(const int high_low) {
ulong clock_count = 0;
while (magnetic_sensor = = high_low) { // if signal is unchanged from start
// Must count just one clock signal // low-to-high transition
while (clock_signal = = high) /* wait */;
while (clock_signal = = low) /* wait */; // Changes on low-to-high edge
clock_count++; }
return clock_count;
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

21. Subroutine / Function calls
Blackfin
extern “C” int FooASM(int, int, int)
C = FooASM(1,2,3)
.extern _FooASM
LINK 20;
[SP + 16] = R4;
R0 = 1;
R1 = 2;
R2 = 3;
CALL _FooASM;
R4 = R0;
.. Other code
R4 = [SP + 16];
UNLINK;
RTS;
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

22. Code conventions for subroutines / functions
Blackfin -- VisualDSP
Volatile registers Destroyed after CALL
R0, R1, R2, R3 P0, P1, P2
Non-volatile registers MUST BE UNCHANGED after CALL to a subroutine
R4, R5, R6, R7
P3, P4, P5, FP, SP
Subroutine return value is passed in R0
Subroutine OUTPARS
OUTPAR1  R0
OUTPAR2  R1
OUTPAR3  R2
OUTPAR4  [SP + 12]
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

23. Main function concept ulong DetermineSpeed(ulong wheelDiameter, ulong clockFrequency)
#define ulong unsigned long int;
extern “C” ulong CountClockASM(const int); // Assembly code interface
extern “C” ulong CalculateSpeedASM(ulong, ulong, ulong);
extern “C” void SetupInterface(void);
ulong DetermineSpeed(ulong wheelDiameter, ulong clockFrequency) {
// Get to known position on magnetic sensor signal
unsigned long discard_count;
unsigned long count_high, count_low;
SetupInterface( );
discard_count = CountClockASM(while_MagneticSensorHigh);
discard_count = CountClockASM(while_MagneticSensorLow);
count_high = CountClockASM(while_MagneticSensorHigh);
count_low = CountClockASM(while_MagneticSensorLow);
return CalculateSpeedASM(count_high + count_low, wheelDiameter, clockFrequency); }
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

24. Main Blackfin function concept
_DetermineSpeed: LINK 20
[FP + 8] = R0; [FP + 12] = R1; // Save INPARS [SP + 16] = R4;
CALL _SetupInterface;
R0 = MASKMAG; CALL _CountClockASM;
R0 = 0; CALL _CountClockASM
R4 = R0; // count_high
R0 = R0 + R4; // high + low.
R1 = [FP + 8]; // old INPAR1
R2 = [FP + 12]; // old INPAR2
CALL _CalculateSpeedASM // Return in R0
[SP + 16] = R4;
UNLINK
RTS
ulong DetermineSpeed(ulong wheelDiameter,
ulong clockFrequency) {
// Get to known position on magnetic sensor signal
unsigned long discard_count;
unsigned long count_high, count_low;
SetupInterface( );
discard_count = CountClockASM(while_MagneticSensorHigh);
discard_count = CountClockASM(while_MagneticSensorLow);
count_high = CountClockASM(while_MagneticSensorHigh);
count_low = CountClockASM(while_MagneticSensorLow);
return CalculateSpeedASM(count_high + count_low, wheelDiameter, clockFrequency); }
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

25. extern “C” void SetupInterface(void);
Blackfin
Direction register
0 = input, 1 = output
FIO_DIR bits
Interrupt control
FIO_MASKA_D on any bit
Enable input (Power save issue)
FIO_INEN on any bit
Polarity
FIO_POLAR on any bit
Edge / Level sensitivity
FIO_EDGE FIO_BOTH on any bit
Magnetic signal Clock signal
Bit 10 MASKMAG 0x200 Bit 11 MASKCLK 0x400
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

26. extern “C” void SetupInterface(void); SPECIFICS
Blackfin
Magnetic signal Clock signal
Bit 10 MASKMAG 0x200 Bit 11 MASKCLK 0x400
Direction register
0 = input, 1 = output
R0  FIO_DIR MASK OFF BITS 10, FIO_DIR  R0
Interrupt control
R0  FIO_MASKA_D MASK OFF BITS 10, FIO_MASKA_D  R0
Enable input (Power save issue)
R0  FIO_INEN OR BITS 10, FIO_INEN  R0
Polarity
R0  FIO_POLAR MASK OFF BITS 10, FIO_POLAR  R0
Edge / Level sensitivity
FIO_EDGE FIO_BOTH MASK OFF BITS 10, 11
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

27. In class exercise – Write Blackfin code for extern “C” void SetupInterface(void);
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada

28. Information taken from Analog Devices On-line Manuals with permission
Information furnished by Analog Devices is believed to be accurate and reliable. However, Analog Devices assumes no responsibility for its use or for any infringement of any patent other rights of any third party which may result from its use. No license is granted by implication or otherwise under any patent or patent right of Analog Devices. Copyright  Analog Devices, Inc. All rights reserved.
4/14/2019
Motorola Blackfin Comparison Part , Copyright M. Smith, ECE, University of Calgary, Canada