Transcript Input Laboratory

Input Laboratory:
GPIO Pin control needed to have the
Blackfin accept your commands
Re-uses information from ENEL353 and ENCM369
courses and text books combined with Blackfin DATA
manual to activate the Blackfin input device
(PF – programmable flags)
Reminder: How does a switch work?
The following – DOES NOT WORK
PRESS DOWN TO CLOSE
SPRING
TO CAUSE
SWITCH TO
OPEN AFTER
PUSH TO CLOSE
SWITCH OUTPUT
SWITCH INPUT
2 /25
One side of the switch must be pulled
“softly” to 3 V / 5V (pull up resistor)
3v
10k “Pull-up”
resistor
BLACKFIN
INPUT IS 5V
WHEN SWITCH
OPEN
INPUT IS 0V
WHEN SWITCH
CLOSED
GPIO LINES PF8, PF9, PF10, PF11
GROUND (0V)
3 /25
Blackfin has a GPIO data register
General purpose input/output
 16 GPIO lines come into the register
 Registers are based on flip-flops to store
whether the input is 3V (high) or zero (low)
 16 flip flops put together make the FIO_FLAG_D
register
 The GPIO data register is memory mapped so
no special instructions needed, you “treat it as if
it was the same as any other memory”
 When you “read” from the GPIO register, you
cause a “load” of the input values into the flipflop and out onto the microcontroller’s data bus
4 /25
Registers used to control PF pins
 Flag Data register (FIO_FLAG_D) -- READABLE
 Used to read the PF bits as an input -- (1 or 0)
 Need to read pins PF11 to PF8 ONLY , ignore all other pins values
 Read the value, AND off unwanted bits, then use it
5 /25
What we know about the way “front
panel” switches connected to BF533
SW1 is connected to PF8 input ofGPIO
SW2 is connected to PF9 input ofGPIO
SW3 is connected to PF10 input ofGPIO
SW4 is connected to PF11 input ofGPIO
The other pins in the GPIO interface are
used for “other” purposes on the Blackfin
board and MUST not have their values
changed e.g. Video device input port
6 /25
What we want to do
Read the GPIO data register
Return ONLY the values in pins 8 to 11
which means removing (masking out) the
other values which might have 1’s or 0’s in
them
Value read from GPIO data register = 0x4723
 We only want to get the bits 0x0700 (SW1, SW2, SW3)
Value read from GPIO data register = 0x4023
 We only want to get the bits 0x0000 (no switches)
Value read from GPIO data register = 0x4823
 We only want to get the bits 0x0800 (SW4)
7 /25
What we have to code
using AND instructions
MASK bit set to 1 for bits we keep, 0 for bits removed
 MASK = 0x0F00 (Bits 8, 9, 10, 11 are 1, other bits are zero)
Value read from data register = 0x4623 (want PF8, 9, 10)
 MASK set to 0x0700 -- Result = value & MASK
 bit value result 0x0600 (SW2, SW3 on, SW1 off)
Value read from data register = 0x4123 (PF9 )
 MASK set to 0x0200 -- Result = value & MASK
 Bit value results 0x0000 -- (SW2 off)
Value read from data register = 0x4923 (PF11)
 MASK set to 0x0800 -- Result = value & MASK
 Bit value result 0x0800 – SW4 on)
8 /25
So the assembly code should look
something like this
#include <blackfin.h>
.section program;
.global _ReadGPIOFlagsASM;
_ReadGPIOFlagsASM:
P0.L = lo(FIO_FLAG_D); P0.H = ……
R0 = W[P0] (Z); // Convert 16 bits to 32 bits via zero extension
// These are “bit settings” not a number
#define AND_MASK 0x0F00;
R1 = AND_MASK; // Keep only bits 8, 9, 10, 11
// (connected to switches)
R0 = R0 & R1;
_ReadGPIOFlagsASM.END: RTS;
9 /25
DOES NOT WORK -- We have not
“initialized” the GPIO device interface
“Initialize device” means “prepare the
device to make work”, in this case I / O
Always initialize device registers (part of
‘driver’ code)
#include <blackfin.h>
.section program;
.global _ReadGPIOFlagsASM;
_ReadGPIOFlagsASM:
P0.L = lo(FIO_FLAG_D); P0.H = ……
………;
R0 = R0 & R1;
_ReadGPIOFlagsASM.END: RTS;
10 /25
Initialize the GPIO interface requires
change to many control registers
Turn the interrupts OFF for PF8 to PF11.
Do this WITHOUT changing the interrupt
behaviour for the other pins 0 to 7 and 12
to 15
Set the POLARITY register so that a 1
coming into pins PF8 to PF11 is read as a
HIGH (1). Do this without changing the
POLARITY behaviour of the other GPIO
pins 0 to 7 and 12 to 15
Etc. etc.
11 /25
If leave interrupts on, then a stray signal at
the GPIO will cause the processor to
“stop”
The POLAR register plays a big part of
how the processor reads values
Get the POLAR settings wrong causes very
strange behaviour where the processor thinks
things are working when they are not, and
thinks things are not working when they are
Problems with Real-time operating system lab.
12 /25
Initialize the GPIO interface
 Set the DIRECTION register so that PF8 to
PF11 pins can be used as INPUT pinswithout
changing the behaviour of the other GPIO pins.
IF DONE INCORRECTLY CAN BURN OUT THE
CHIP. You don’t want a device sending a 1 to the
GPIO interface, while the interface is trying to output a
0. – Human microprocessor demo 
 AFTER all other initialization steps are complete
Set the ENABLE register so that pins PF8 to PF11
work without changing the behaviour of the other
GPIO pins. Power saving feature
13 /25
So the assembly code looks
something like this. PPPP activated
#include <blackfin.h>
.section program;
.global _InitGPIOFlagsASM;
_InitGPIOFlagsASM:
CALL TurnInterruptsOff_PF8to11; // WHAT IS A CALL?
CALL SetPolarity_PF8to11;
CALL OtherStuff_PF8to11;
CALL SetDirection_PF8to1;
CALL Enable__PF8to11;
_InitGPIOFlagsASM.END:
RTS;
// WHAT IS A RTS?
14 /25
Review – how does the processor
handle instructions
Repeat for ever
Fetch an instruction (pointed to
by PC – at address N)
Increment the PC to point to
‘the next instruction’ (N + 1)
Decode the fetched instruction
(work out what to do)
Execute the fetched instruction
 Write the instruction results
back to registers or memory as
needed
15 /25
What if instruction in a JUMP
instruction?
 Repeat for ever
 Fetch an instruction (pointed to by PC)
 Increment the PC to point to ‘the next instruction
 Decode the instruction (work out what to do)
 Execute the instruction
 Write the instruction results back to registers or
memory as needed
If the instruction is a jump, then part of
the instruction is a label (address) which
must be put into PC so we don’t fetch
the NEXT instruction but one further
away in the code
16 /25
What if instruction in a JUMP TO
SUBROUTINE (CALL) instruction?
 Repeat for ever
 Fetch an instruction (pointed to by PC)
 Increment the PC to point to ‘the next
instruction
 Decode the instruction (work out what to do)
 Execute the instruction
 Write the instruction results back to registers or
memory as needed
If the instruction is a jump or jump
to subroutine, then part of the
instruction is a label (address)
which must be put into PC so we
don’t fetch the NEXT instruction but
one further away in the code
17 /25
What if instruction in a JUMP TO
SUBROUTINE (CALL) instruction?





Fetch an instruction (pointed to by PC)
Increment the PC to point to ‘the next instruction
Decode the instruction (work out what to do)
Execute the instruction
Write the instruction results back to registers or memory as needed
 If the instruction is a jump or jump to subroutine (CALL)
, then part of the instruction is a label (address) which
must be put into PC so we don’t fetch the NEXT
instruction but one further away in the code
 If the instruction is a jump to subroutine instruction
(CALL) – then remember the ‘next instruction’ you
were planning to call in the RETS register (link)
 If the instruction is return from subroutine instruction
(RTS), put stored value in RETS register back into PC,
which causes a jump back to the ‘next instruction’
which we were going to do before the CALL happened
18 /25
Incorrect code – contains a hidden defect
which stops the proper program operation
#include <blackfin.h>
.section program;
.global _InitGPIOFlagsASM;
_InitGPIOFlagsASM:
CALL TurnInterruptsOff_PF8to11;
// CALL means set RETS register -- link register on MIPS
//
to point to instruction after CALL
//
RETS register = address of instruction labelled “next:”
next:
CALL SetPolarity_PF8to11;
next2: CALL OtherStuff_PF8to11;
Next3: CALL SetDirection_PF8to1;
Next4:
CALL Enable__PF8to11; // Set RETS register to _InitGPIOFlagsASM.END
_InitGPIOFlagsASM.END: RTS; // RTS means JUMP RETS
// or “Change the PC to the value stored in RETS register
// What line of code will be executed when the RTS instruction finishes?
// meaning “where does the code jump to -- ANSWER PC
=_InitGPIOFlagsASM.END: -- Code is now in a for-ever nowhere loop ?
19 /25
Correct code; LINK and UNLINK
should be a part of ALL subroutines
#include <blackfin.h>
.section program;
.global _InitGPIOFlagsASM;
_InitGPIOFlagsASM:
LINK 16;
// Save (write) RETS to the memory stack
CALL TurnInterruptsOff_PF8to11;
// CALL means set RETS register
//
to point to instruction after CALL
//
RETS = next: in this case
next:
CALL SetPolarity_PF8to11;
next2: CALL OtherStuff_PF8to11;
Next3: CALL SetDirection_PF8to1;
Next4:
CALL Enable__PF8to11;
UNLINK;
// Recover (get back) RETS from the stack
_InitGPIOFlagsASM.END: RTS; // This means JUMP RETS
// PC set to “saved” RETS so code “returns” to the function that called it
20 /25
Other GPIO register flip flops
FIO_MASKA_D and FIO_MASKB_D
 Stop this from happening unintentionally
 If bit X = 1, tell processor to cause an interrupt
(change program operation) when FIO_FLAG_D
bit X is active (changes to a 1 value)
21 /25
CALL TurnInterruptsOff_PF8to11ASM;
BAD CODING PRACTICE
#include <blackfin.h>
.section program;
.global _TurnInterruptsOff_PF8to11ASM;
_ TurnInterruptsOff_PF8to11ASM:
P0.L = lo(FIO_MASK_A); P0.H = ……
R1 = 0;
W[P0] = R0;
ssync;
// Tell processor to do the write operation NOW
// DO same thing for FIO_MASK_B
TurnInterruptsOff_PF8to11ASM.END:
RTS
22 /25
P0.L = lo(FIO_MASK_A); P0.H = ……
R1 = 0;
W[P0] = R0;
This puts a 0 in every bit and turns ALL
interrupts off – not just bits 8 to 11
23 /25
CALL TurnInterruptsOff_PF8to11;
GOOD CODING USING BITWISE &
INSTRUCTION TO CLEAR BITS TO ZERO
#include <blackfin.h>
.section program;
.global _TurnInterruptsOff_PF8to11;
_ TurnInterruptsOff_PF8to11:
P0.L = lo(FIO_MASK_A); P0.H = ……
R0 = W[P0] (Z);
// Read all the bits
#define MASK_NOCHANGE_VALUES 0xF0FF
R1 = MASK_NOCHANGE_VALUES
R0 = R1 & R1;
// Bits 8 to 11 zero
W[P0] = R0;
// But other bits still the same
// DO same thing for FIO_MASK_B
TurnInterruptsOff_PF8to11:
RTS
24 /25
Lets call a “C++” function instead of
writing the code in assembly code
#include <blackfin.h>
.section program;
.global _InitGPIOFlagsASM;
_InitGPIOFlagsASM:
LINK 16;
CALL TurnInterruptsOff_PF8to11CPP__Fv;
// We must use “name mangling” to call C++ code
next:
next2:
Next3:
CALL SetPolarity_PF8to11;
CALL OtherStuff_PF8to11;
CALL SetDirection_PF8to1;
Next4:
CALL Enable__PF8to11;
UNLINK;
_InitGPIOFlagsASM.END: RTS;
25 /25
Lets write this code in C instead
TurnInterruptsOff_PF8to11CPP__Fv;
Place code in “InitGPIO.cpp
#include <blackfin.h>
void TurnInterruptsOff_PF8to11CPP(void) {
*pFIO_MASK_A = 0; // WRONG – need to use AND operation
ssync( );
// *pFIO_MASK_A = *pFIO_MASK_A & ~0x0F00
// What does the ~ (twiddle) operation perform?
// DO same thing for FIO_MASK_B
}
In assembly code the C++ function TurnInterruptsOff_PF8to11CPP( ) becomes
named
_TurnInterruptsOff_PF8to11CPP__Fv (name mangled)
In assembly code the C function TurnInterruptsOff_PF8to11C ( ) becomes
named _TurnInterruptsOff_PF8to11C
26 /25
This convention allows the overloading of C++ functions (but not C)
Another GPIO register we need to set
correctly
27 /25
Another flip-flop group controls
whether the flip-flop outputs follow
the flip-flop inputs or are “high
impedance” – off – no useful value
28 /25
CALL EnablePins_PF8to11;
#include <blackfin.h>
.section program;
.global _EnablePins_PF8to11;
_ EnablePins_PF8to11:
P0.L = lo(FIO_INEN); P0.H = ……
#define MASK_CHANGE_VALUES 0x0F00;
R1 = MASK_CHANGE_VALUES
W[P0] = R1;
EnablePins_PF8to11.END:
RTS
WRONG: True this enables bits 8 to 11, but it also DISABLES all the
other bits
Need to use “OR” instruction after reading the enable register
29 /25
A key issue with GPIO is whether a pin is to
act as an input device (bringing things in
from the outside world into the Blackfin) or
as an output device (sending things from
the Blackfin to the outside world)
30 /25
Why do you need to know how to do
read (load) and write (store) on internal registers?
Flag Direction register (FIO_DIR)
 Used to determine if the PF bit is to be used for input or
output -- WARNING SMOKE POSSIBLE ISSUE
 Need to set pins PF11 to PF8 for input, leave all other pins
unchanged
31 /25
Making sure that the FIO_DIR is correct
for LAB. 1 – NOTE may need to change
for later labaoratories
Write the Blackfin assembly language instruction(s) to load the
address of the internal programmable flag FIO_DIR register into
pointer register P1 – then SET the Blackfin PF lines to act as inputs
#include <blackfin.h>
P1.L = lo (FIO_DIR); P1.H = ….
Design Error
“Changes all pins
// Check the requirements – need to have all input
// Manual says “setting a line for input means setting bit values to 0”
R0 = 0;
W[P1] = R0;
ssync;
// This changes “All pins”
// Force Blackfin to do the write (store) NOW not later
32 /25
Notice that previous slide WARNS
you about a design error in the code
We can’t do things this way as it changes
all the bits in the 16 flip-flops and we only
want to change 4 values in the flip-flops
The same design error is introduced into
Lab. 1 Task 3
However, the same design error is found
during the TDD tests – provided to look at
the test code to see what was being tested
33 /25
These tests DONOT find the design
error
34 /25
These tests DO find the design error
and in fact explain to you why it is likely that
your tests have failed.
But you have to read the message about the
Test and not ignore it
35 /25
Extra ideas you can use
Echoing Values from the switches to the
LED
Can be used to copy the switch presses to
the LED. If the LED outputs are connected
to the radio controlled car inputs, then we
can drive the car using the switches
(Last part of Lab. 1)
36 /25
Echoing the switches to the LED
Code in main( ) – written in C++
int main( ) {
InitializeGPIOInterface( ); // Check Lab. 1 for “exact name needed”
InitializeFlashLEDInterface( ); // Check Lab. 1 for “exact name needed”
#define SWITCHBITS 0x0F00
// Look in MIPs notes about
//
using a mask and the
//
AND bit-wise operation
//
to select “desired bits”
while (1) {
// Forever loop
int GPIO_value = ReadBlackfinGPIOFlagsASM ( );
int desired_bits = GPIO_value & SWITCHBITS;
}
}
int LED_light_values = desired_bits >> 8;
// Bits in wrong position
WriteFlashLEDLights(LED_light_values);
// to display on LEDS
37 /25
Building a radio controlled car
4 Threads at least
SWITCHES ON FRONT PANEL
“INPUT COMMANDS:
LED LIGHTS ON FRONT PANEL
“CONTROLSIGNALS TO RF TRANS:
PROGRAMMABLE FLAGS
LED-CONTROLREGISTER
FIO_FLAG_D Register
EBIU INTERFACE
int ReadSwitches( )
void WriteLED(int )
YOUR PROGRAM RUNNING ON THE BLACKFIN
ProcessDataASM( ) subroutine
VOICE
A/D
A/D D/A Interrupt routine
D/A
EAR
PHONES
38 /25
LEDs connected to FLASH port
BACK
FORWARD
RIGHT
LEFT
???
CONTROL ON
Might be
connected to
other things
DON’T
CHANGE
BEHAVIOUR
Blackfin BF533 I/O
39