Input Laboratory: GPIO Pin control needed to have the Blackfin accept your commands

1. 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)

2. Reminder: How does a switch work?The following – DOES NOT WORK PRESS DOWN TO CLOSE SPRINGTO CAUSESWITCH TOOPEN AFTERPUSH TO CLOSE SWITCH OUTPUT SWITCH INPUT

3. One side of the switch must be pulled “softly” to 3 V / 5V (pull up resistor). Softly – avoid much current 3v 10k “Pull-up” resistorI = V / R = ?? mA? BLACKFIN INPUT IS 3VWHEN SWITCHOPEN GPIO LINES PF8, PF9, PF10, PF11 INPUT IS 0VWHEN SWITCHCLOSED GROUND (0V) INPUT IS ???WHEN SWITCH OPEN

4. Blackfin has a GPIO data registerGeneral 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 flip-flop and out onto the microcontroller’s data bus

5. 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

6. 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

7. 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)

8. 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)

9. 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;

10. 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;

11. 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.

12. 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.

13. 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

14. 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?

15. 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

16. 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

17. 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

18. 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

19. 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 ?

20. 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 casenext: 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

21. Other GPIO register flip flopsFIO_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)

22. 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 // REMEMBER – This processor does not // treat WRITEs as high priority // UNLESS 2 writes are waiting to happen // and a 3rd write is requested!!!!! // DO same thing for FIO_MASK_B TurnInterruptsOff_PF8to11ASM.END: RTS

23. 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

24. 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

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: CALL SetPolarity_PF8to11;next2: CALL OtherStuff_PF8to11; Next3: CALL SetDirection_PF8to1; Next4: CALL Enable__PF8to11; UNLINK; _InitGPIOFlagsASM.END: RTS;

26. Lets write this code in C insteadTurnInterruptsOff_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 This convention allows the overloading of C++ functions (but not C)

27. Another GPIO register we need to set correctly

28. Another flip-flop group controls whether the flip-flop outputs follow the flip-flop inputs or are “high impedance” – off – no useful value

29. 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

30. 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)

31. 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

32. 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 Design Error “Changes all pins

33. 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 you look at the test code to see what was being tested

34. These tests DONOT find the design error

35. These tests DO find the design errorand 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

36. 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)

37. Echoing the switches to the LEDCode 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 } }

38. Building a radio controlled car4 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 YOUR PROGRAM RUNNING ON THE BLACKFIN int ReadSwitches( ) void WriteLED(int ) ProcessDataASM( ) subroutine VOICE A/D D/A EARPHONES A/D D/A Interrupt routine

39. LEDs connected to FLASH port BACKFORWARDRIGHTLEFT??? CONTROL ON Might be connected to other thingsDON’T CHANGEBEHAVIOUR Blackfin BF533 I/O