If we can just send 1 signal correctly over the SPI MOSI line, then Lab 4 will work!!!

Transcription

1 If we can just send 1 signal correctly over the SPI MOSI line, then Lab 4 will work!!! Design and implementation details on the way to a valid SPI-LCD interface driver

2 Slides 3 to 13 are old versions of the new code in Ideas for Lab 4 Laboratories Skipping to hardware details in Slide 13 2/ 29

3 To be tackled today Review -- What is SPI? Review -- What is the SPI master slave relationship? How do we configure the SPI interface inside the Blackfin? How do we activate the chip-select line PF5? Does activating the PF5 line as SPI output control mean we have to change all the SetupPF8to11ASM( ) and other routines? When do we activate the chip-select line, and how long for? What happens when there is not a new value in the SPI transmit buffer what does the SPI interface do it can t do nothing does it start transmitting zeros (which would turn out all the LEDs we just turned on One function left to be developed InitHardware_SPI( ), NO_DELAY, RUN_ONCE) perhaps contains InitializeSPI (unsigned short int SPI_baudrate); and void StartSPI_ASM(void); 3/ 29

4 Lab 4 looks something like three new types of uttcos threads InitScheduler( ) AddThread(InitHardware, NO_DELAY, RUN_ONCE) AddThread(Init_SPI, NO_DELAY, RUN_ONCE) AddThread(SPI_WriteMessages, SHORT_DELAY, RUN_OFTEN) AddThread(SPI_Message_InitLCD, 2 * SHORT_DELAY, RUN_ONCE); AddThread(MeasureTemperatureTiming, NO_DELAY, 1); AddThread(CalculateTemperature, QUARTER_SECOND, QUARTER_SECOND) AddThread(DisplayTempertureLED, 3/8 seconds, QUARTER_SECOND) AddThread(SPI_Message_HappyXmasLCD, 4.5_SECOND, THREE_SECONDS); AddThreadSPI_Message_TemperatureLCD, 5.5_SECOND, THREE_SECONDS); AddThread(SPI_511RULES_LCD, 6.5_SECOND, THREE_SECONDS); StartScheduler( ) Loop GotoSleepTillInterrupt Dispatch Tasks -- DO CODE REVIEW

5 SPI_Message_LCD( ) ; All message threads look similar extern bool SPI_InUse; extern bool sendinstruction; extern int numwordslefttosend; extern int numwordssent; extern unsigned short int arraytosend[150]; void SPI_Message(void) { if (SPI_InUse == true) return; SPI_InUse = true; char message[ ] = My message ; CopyCharArrayToIntArray(arrayToSend, message); numwordssent = 0; sendinstruction = false; numwordslefttosend = strlen(message); } 5/ 29

6 SPI_Message_InitLCD ( ) ; extern bool SPI_InUse; extern bool sendinstruction; extern int numwordslefttosend; extern int numwordssent; extern unsigned short int arraytosend[150]; void SPI_InitMessage(void) { if (SPI_InUse == true) return; SPI_InUse = true; char message[ ] = { 0x30, 0x30, etc}; CopyCharArrayToIntArray(arrayToSend, message); numwordssent = 0; sendinstruction = true; numwordslefttosend = strlen(message); } 6/ 29

7 SPI_Message_Temperature ( ) ; extern bool SPI_InUse; extern bool sendinstruction; extern int numwordslefttosend; extern int numwordssent; extern unsigned short int arraytosend[150]; void SPI_MessageTemperature(void) { if (SPI_InUse == true) return; SPI_InUse = true; // Different way to copy char [ ] sprintf(arraytosend, Temperature is %f C, Lab3_temperature); numwordssent = 0; sendinstruction = true; numwordslefttosend = strlen(arraytosend); } 7/ 29

8 Lab 4 looks something like three new types of uttcos threads InitScheduler( ) AddThread(InitHardware, NO_DELAY, RUN_ONCE) AddThread(Init_SPI, NO_DELAY, RUN_ONCE) AddThread(SPI_WriteMessages, SHORT_DELAY, RUN_OFTEN) AddThread(SPI_Message_InitLCD, 2 * SHORT_DELAY, RUN_ONCE); AddThread(MeasureTemperatureTiming, NO_DELAY, 1); AddThread(CalculateTemperature, QUARTER_SECOND, QUARTER_SECOND) AddThread(DisplayTempertureLED, 3/8 seconds, QUARTER_SECOND) AddThread(SPI_Message_HappyXmasLCD, 4.5_SECOND, THREE_SECONDS); AddThreadSPI_Message_TemperatureLCD, 5.5_SECOND, THREE_SECONDS); AddThread(SPI_511RULES_LCD, 6.5_SECOND, THREE_SECONDS); StartScheduler( ) Loop GotoSleepTillInterrupt Dispatch Tasks -- DO CODE REVIEW

9 Void SPI_WriteMessages(void) uttcos thread Do code review bool SPI_InUse = false; bool sendinstruction false; int numwordslefttosend = 0; int numwordssent = 0; unsigned short int arraytosend[150]; enum {EHIGH, ELOW, EHIGH2}; void SPI_WriteMessage(void) { if (SPI_InUse == false) return; // No message to send if (numwordslefttosend == 0) {SPI_InUse = false; return); // all words sent get ready static whichspidriverstate = EHIGH; nextspidrivestate = whichspidriverstate ; switch (whichspidriverstate ) {.. 9/ 29

10 SPI_WriteMessages(void) Do code review switch (whichstate) { case EHIGH; if (SPI_Ready( ) = false) return; // E high RS low WriteSPI(0x0800 arraytosend(numwordssent); nextspidrivestate = ELOW; break; case ELOW; if (SPI_Ready( ) = false) return; // E low RS low WriteSPI(0x0000 arraytosend(numwordssent) nextspidrivestate = EHIGH2; break; case EHIGH2; 10 / 29

11 SPI_WriteMessages(void) Do code review switch (whichstate) { case EHIGH;. break; case ELOW;... break;; case EHIGH2; if (SPI_Ready( ) = false) return; // E high RS low WriteSPI(0x0800 arraytosend(numwordssent); numwordssent++; --numwordslefttosend ; nextspidrivestate = EHIGH; break; } currentspidrivestate = nextspidrivestate; } 11 / 29

12 Lab 4 looks something like three new types of uttcos threads InitScheduler( ) AddThread(InitHardware, NO_DELAY, RUN_ONCE) AddThread(Init_SPI, NO_DELAY, RUN_ONCE) AddThread(SPI_WriteMessages, SHORT_DELAY, RUN_OFTEN) AddThread(SPI_Message_InitLCD, 2 * SHORT_DELAY, RUN_ONCE); AddThread(MeasureTemperatureTiming, NO_DELAY, 1); AddThread(CalculateTemperature, QUARTER_SECOND, QUARTER_SECOND) AddThread(DisplayTempertureLED, 3/8 seconds, QUARTER_SECOND) AddThread(SPI_Message_HappyXmasLCD, 4.5_SECOND, THREE_SECONDS); AddThreadSPI_Message_TemperatureLCD, 5.5_SECOND, THREE_SECONDS); AddThread(SPI_511RULES_LCD, 6.5_SECOND, THREE_SECONDS); StartScheduler( ) Loop GotoSleepTillInterrupt Dispatch Tasks -- DO CODE REVIEW

13 KIS Get something sent over the SPI We need to send 12 signals to LCD We need the wiring correct We need the timing correct We need the signals correct including INIT code TOO COMPLICATED GO FOR KIS Hook up to Interface output to the LEDs on Logic Lab station Send a simple 16-bit value over SPI Does it appear (in the correct Check using E-UNIT not uttcos bit order) on LEDs 13 / 29

14 Lab. 4 interface SPI from Blackfin master (MOSI, MISO, CLK, PF5 SPI to interface (slave) (MOSI, MISO, CLK, slave select ) LINES TO LOGIC LAB LED LOOK HERE FOR EXPECTED SIGNALS HOOK TO LOGIC LAB STATION LIGHTS 14 / 26

15 Things we are missing All relate to SPI HARDWARE bool SPI_Ready(void) --- Quiz 1 void WriteSPI(unsigned short SPIvalue); void InitSPI(void); We are going to have to read the reference sheet 15 / 26

16 Review -- Master / Slave concept Slave Select (Chip Select) We put a value into the Blackfin SPI_TDBR register hardware does the rest Blackfin sends out active low chip select signal PF5 Blackfin sends out the valuebits on the MOSI signal. Slave accepts signal as SS1 is connected to PF5 Then PF5 goes high no more information for SLAVE If we get the first step correct then everything else should happen automatically provided we have set up the SPI interface correctly 16 / 29

17 Review -- Using an SPI interface to logic lab LED SPI_TDBR Blackfin Processor SPI_RXBR MOSI SLAVE SELECT PF5 used (PF0 to PF7) SPI CLOCK MISO SLAVE INPUT INTERFACE CONTROL DATA CJ7 / CJ8 output to LED LOAD Slave to LCD SLAVE OUTPUT INTERFACE SWITCHES (LOGIC LAB) 17 / 29

18 Blackfin transmits 16 bits with THIS format over the MOSI line We don t care about format at the moment THIS IS NEW STUFF DB7, DB6, DB1, DB0 We just want to make something E Enable / Strobe RS valid to appear on 1 MOSI 0 When line this line goes from high to the 1 LCD data low, then the command is send to (latched into) LCD 0 LCD instruction Use test driven development To make LCD respond and to command E-Unit 0x4F0 R/W Then Blackfin must transmit to explore new ideas 0x5F0 ( NOT E High ) TTCOS 1 Read from LCD 0x4F0 ( E low ) 0 Write to LCD 0x5F0 ( E high ) 18 / 29

19 Start with something we know how to do PF5 as Output signal Need to set PF5 as output to make SPI work But if we change Init_MySwitchesASM(); from Lab. 1 too much else MIGHT need changing TEST(GPIO_Setup_TEST) { CHANGING Init_MySwitchesASM(would mean we would have to change all Tests from Lab. 1 } CHANGES NEEDED FOR LAB. 10 (FAR FUTURE) BUT NOT NOW -- CAN WE DO SOMETHING ELSE? 19 / 29

20 void ChangePFtoOutputASM(int which_pins ) Make sure nothing else changes in FIO_DIR so read, then OR, then write ONE SOLUTION -- Review for Quiz 3 and Final exam PF5 GPIO changed to Output without changing other things #include <blackfin.h>.global _ChangePF.;// void ChangePFtoOutputASM(int which_pins ) _ChangePF. P1.L = lo (FIO_DIR); P1.H = hi (FIO_DIR); old_value_r1 = W[P1] (Z); // Get old value -- unsigned new_value_r2 = old_value_r1 which_pins_r0 // INPAR1 in R0 W[P1] = new_value_r2; ssync; // Force Blackfin to do the write (store) NOW not later 20 / 29

21 Blackfin interface details This part is more slave side We care about Blackfin side of SPI interface Possible quiz question is it on reference sheet 21 / 29

22 Concept We write 16-bits (0xFF0A) into SPI_TDBR Hardware transfers this to SHIFT register SPI_TDBR now empty 0x F F 0 A For next 16 ticks of SPI clock MASTER talks to SLAVE Hardware SENDS out 1 bit from shift register over MOSI line to SLAVE each clock tick speeds up to 25 MHz per bit SLAVE talks to MASTER Hardware CAN ALSO RECEIVE 1 bit over MISO line from the SLAVE and puts into shift register each clock tick speeds up to 25 MHz per bit Hardware transfers shift register value (from slave) into SPI_RDBR (receive DBR) SPI_RDBR is now FULL This transmission over a serial line (16-bits 1 at a time) is much slower than other internal Blackfin operation Must be careful not to overwrite last transmission with new transmission by trying to hard writing values too quickly 22 / 29

23 TRY about 0x8000 baud rate to start with 23 / 29

24 SPI_registers -- Hardware Chap. 10 WHAT TO WORRY ABOUT WHAT TO IGNORE SPI_BAUD We want to be able to change this slow it down to??? Maximum serial clock rate is ¼ of the system clock rate SCK freq = Peripheral clock frequency / 2 * SPI_BAUD -- Many Megabits / sec SPI_FLG (Not SPI_FLAG) do we need ChangePFtoOutputASM FLS5 bit activates PF5 as slave select line FLG5 bit could be used by us to control value of PF5 line (Slave select) when FLG5 bit is low, PF5 output is low, when FLG5 bit is high, PF5 output is high, However we would rather have the SPI hardware change PF5 output line at the correct time for us. Page of the manual says if CPHA = 0, the SPI hardware sets the output value (PF5) and the FLG5 bit (that developer sets) is ignored MEANS WE WOULD NOT NEED TO CHANGE MyInitSwitchesASM( )!!!! SOUNDS GOOD TO ME JUST SET PLS5 TO 1 AND THE PROCESSOR DOES THE WORK -- except how do you make CPHA = 0? 24 / 29

25 Status register information RO and W1C bits -- SPI_Ready( ); 25 / 29

26 SPI-registers -- more SPI_STAT SPI Status register Has some read only (RO R-Oh) bits RO bits are changed by processor SPI hardware NOT us Has some write 1 to clear sticky bits which are set when error condition occurs Remember to write 1 to clear these bits during SPI Setup NOT Write 0 SPI_TDBR transmit data buffer register Value written to this register is transmitted over SPI interface Writing to this register clears the SPI transmit interrupt signal One of the questions about writing the SPI_ISR function is answered by this information When we write to the SPI_TDBR register, the interrupt signal is cleared automatically. We don t have to clear a bit as we would do with the core timer and general purpose timer register interrupts However we not writing an SPI_ISR in Lab 4 what a shame all that information going to waste use in Quiz 3 or final perhaps 26 / 29

27 Chapter 10 in reference manual and reference sheet SPI_Ready( ) code We don t have a ready to start bit like coffeepot we have a have finished bit instead NOTE RO not R0 (Read only) SYSTEM CHANGED 27 / 29

28 Set this bit after others set Separate line of code All set in InitSPI( )???????? INFO WE NEEDED This is for SLAVE talking to MASTER 28 / 29

29 SPI_CTL register InitSPI( ) Values needed during setup TIMOD transfer initiation mode 01 Start transfer with write to SPI_TDBR. Interrupt when SPI_TDBR is empty. Timing issues possible here get an interrupt after SPI_TDBR is empty the first time PSSE Slave Select Enable 0 Disable setting this as 1 makes this Blackfin a slave device. There might be circumstances where you want one Blackfin as master, and another as a slave but this is not one of them. SIZE = 1 (16 bits) LSBF Last significant bit first 0 as we want MSBF first as that is the way the LCD interface has been designed MSTR master 1 as we want Blackfin to be master, not slave SPE SPI Enable 1 but we might not want to do this during set-up, configure SPI then enable SPI as last step WOM Write open drain master 0 Normal because this was the way the interface was designed EMISO Enable MISO to allow slave to talk to master 0 Not in this part of the lab GM Get more data 0 when SPI_RDBR (receive buffer) is full discard new incoming data don t really care at the moment 29 / 29

30 SPI_CTL register Things we still don t understand SZ send zeros (or last word again) when SPI_TDBR is empty causes what to happen? Sending zeros sounds bad as that means the LCD will think we are sending it commands SLAVE TALK TO MASTER CPOL clock polarity Means what and do we care? CPHA Clock Phase When CPHA = 1, slave select controlled by user software When CPHA = 0, slave select controlled by SPI hardware MURPHY S RULE any bit whose function is not obvious will be the key of whether you get the interface to work or not 30 / 29

31 VALID slave load on signal transition VALID DATA STORED Figure SLAVE DATA IS LOADED ON L-to-H CLOCK TRANSITION Different than Slave is SELECTED when PF5 = 0 INVALID slave load on signal transition INVALID DATA STORED 31 / 29

32 We are now at the stage where we can do some experimenting with the hardware We know that the following pins are key to the operation of the SPI interface. MOSI this will show the data being transmitted from the SPI interface PF5 chip select line When this is pulled low, then the slave will accept any data being transmitted, otherwise data is ignored When this goes low to high then the serial data transmitted to the slave is latched (converted into a parallel signal that is then sent to LCD as a data or a command request. Place scope probes on these lines 32 / 29

33 Lab 4 quick test Hook up the lines to the logic lab LIGHTS not LCD InitScheduler( ) --- Can also do inside E_Unit Final hint InitHardware Blackfin LED, switches AddTask(Init_SPI, NO_DELAY, RUN_ONCE) AddTask(AnythingOnMOSILine,Test 4.5_SECOND, TWO_SECOND); These commands should appear on LLS LEDS AddTask(MeasureTemperatureTiming, NO_DELAY, 1); AddTask(CalculateTemperature, QUARTER_SECOND, QUARTER_SECOND) AddTask(DisplayTempertureLED, 3/8 seconds, QUARTER_SECOND) AddTask(SPI_Message_HappyXmasLCD, 4.5_SECOND, TWO_SECOND); AddTask(SPI_Message_TemperatureLCD, 5.5_SECOND, TWO_SECOND); StartScheduler( ) Loop GotoSleepTillInterrupt Dispatch Tasks

34 AnythingOnMOSILine( ) This is essentially send a special message bool SPI_In_USE; // SEMAPHORE (lock) short int sendmymessage; // MESSAGE (simple) char SPImessage[80]; // MESSAGE body char SimpleTestMessageWithShakespeare[ ] = {0xFF, 0xAA, 0x23, 0x67, 0x2B,!0x2B, EOS /* end of string character */}; #include <stdio.h> void AnythingOnMOSILine (void) { if (SPI_In_Use == true) return; // Must wait till SPI interface is not in use by another task // SPI_In_Use is false // We want to use the SPI interface block other tasks from using it SPI_In_Use = true; } strcpy(spimessage, SimpleTestMessageWithShakespeare); sendmymessage = DATA; // DEFINE INSTRUCTION AS 2 SOMEWHERE -- DO CODE REVIEW 34 / 26

35 Concept We write 16-bits (0xFF0A) into SPI_TDBR Hardware transfers this to SHIFT register SPI_TDBR now empty For next 16 ticks of SPI clock 0x F F 0 A Hardware sends out 1 bit from shift register over MOSI line to SLAVE each clock tick speeds up to 25 MHz per bit Hardware receives 1 bit over MISO line from the SLAVE and puts into shift register each clock tick speeds up to 25 MHz per bit Hardware transfers shift register value (from slave) into SPI_RDBR (receive DBR) SPI_RDBR is now FULL This transmission over a serial line (16-bits 1 at a time) is much slower than other internal Blackfin operation Must be handled via interrupt control 35 / 29

36 Lab. 4 interface SPI from Blackfin master (MOSI, MISO, CLK, PF5 SPI to interface (slave) (MOSI, MISO, CLK, slave select ) LINES TO LOGIC LAB LED LOOK HERE FOR EXPECTED SIGNALS HOOK TO LOGIC LAB STATION LIGHTS 36 / 26

37 What we should see on scope Sending 0xFF, 0xAA, 0x23, 0x67, EOS Make SPI_BAUD very large (0x8000 very slow SPI transmission) Connect Lab. 4 interface to logic lab station lights (top) See 0x05FF, 0x04FF, 0x05FF Then 0x05AA, 0x04AA, 0x05AA Then 0x0523, 0x0423, 0x0523 Then 0x0567, 0x0467, 0x / 29

38 Things we are missing All relate to SPI HARDWARE bool SPI_Ready(void) { Check SPI Finished bit in SPI status register } void WriteSPI(unsigned short SPIvalue) { Write the value to SPI transmit buffer register } void InitSPI(void) { Set slave select in SPI flag register Set Baud rate Set all necessary bits in SPI Control register Enable SPI interface } 38 / 26

39 Final Lab. 3 and Lab. 4 InitScheduler( ) -- Lab 3 looks something like this AddTask(InitHardware, NO_DELAY, RUN_ONCE) AddTask(MeasureTemperatureTiming, NO_DELAY, 1); AddTask(CalculateTemperature, QUARTER_SECOND, QUARTER_SECOND) AddTask(DisplayTempertureLED, 3/8 seconds, QUARTER_SECOND) AddTask(FlashLED6, NO_DELAY, EIGHTH_SECOND StartScheduler( ) Loop GotoSleepTillInterrupt Dispatch Tasks 39 / 29

40 Lab 4 looks something like three new types of uttcos threads InitScheduler( ) AddThread(InitHardware, NO_DELAY, RUN_ONCE) AddThread(Init_SPI, NO_DELAY, RUN_ONCE) AddThread(SPI_WriteMessages, SHORT_DELAY, RUN_OFTEN) AddThread(SPI_Message_InitLCD, 2 * SHORT_DELAY, RUN_ONCE); AddThread(MeasureTemperatureTiming, NO_DELAY, 1); AddThread(CalculateTemperature, QUARTER_SECOND, QUARTER_SECOND) AddThread(DisplayTempertureLED, 3/8 seconds, QUARTER_SECOND) AddThread(SPI_Message_HappyXmasLCD, 4.5_SECOND, THREE_SECONDS); AddThreadSPI_Message_TemperatureLCD, 5.5_SECOND, THREE_SECONDS); AddThread(SPI_511RULES_LCD, 6.5_SECOND, THREE_SECONDS); StartScheduler( ) Loop GotoSleepTillInterrupt Dispatch Tasks -- DO CODE REVIEW

41 Code reminder using sprintf( ) Xmas message and temperature I want to put the temperature (as a number) into a string that gets transmitted over SPI how would I do that using C? volatile bool SPI_In_USE; // SEMAPHORE (lock) volatile short int sendmymessage; // MESSAGE (simple) volatile char SPImessage[80]; // MESSAGE body volatile float temperature; // Calculated as a Lab. 3 Task // Know terms in red for final #include <stdio.h> -- DO CODE REVIEW void SPI_Message_TemperatureLCD(void) { if (SPI_In_Use == true) return; // Must wait till SPI interface is not in use by another task // SPI_In_Use must be false therefore we can change it and use SPI // We want to use the SPI interface block other tasks from using it SPI_In_Use = true; sprintf(spimessage, Temperature %f4.2 C, temperature); sendmymessage = DATA; // DEFINE DATA AS 1 SOMEWHERE } 41 / 26

42 SPI_Message_LCD( ) ; All look similar extern bool SPI_InUse; extern bool sendinstruction; extern int numwordslefttosend; extern int numwordssent; extern unsigned short int arraytosend[150]; void SPI_Message(void) { if (SPI_InUse == true) return; SPI_InUse = true; char message[ ] = My message ; CopyCharArrayToIntArray(arrayToSend, message); numwordssent = 0; sendinstruction = false; numwordslefttosend = strlen(message); } 42 / 29

43 SPI_Message_InitLCD ( ) ; extern bool SPI_InUse; extern bool sendinstruction; extern int numwordslefttosend; extern int numwordssent; extern unsigned short int arraytosend[150]; void SPI_InitMessage(void) { if (SPI_InUse == true) return; SPI_InUse = true; char message[ ] = { 0x30, 0x30, etc}; CopyCharArrayToIntArray(arrayToSend, message); numwordssent = 0; sendinstruction = true; numwordslefttosend = strlen(message); } 43 / 29

44 SPI_WriteMessages(void) Do code review bool SPI_InUse = false; bool sendinstruction false; int numwordslefttosend = 0; int numwordssent = 0; unsigned short int arraytosend[150]; enum {EHIGH, ELOW, EHIGH2}; SPI_WriteMessage(void) { if (SPI_InUse == false) return; // No message to send if (numwordslefttosend == 0) {SPI_InUse = false; return); // all words sent get ready static whichstate = EHIGH; switch (whichstate) { case EHIGH; if (SPI_Ready( ) = false) return; // E high RS low whichstate = ELOW; WriteSPI(0x0800 arraytosend(numwordssent); 44 / 29

45 SPI_WriteMessages(void) Do code review switch (whichstate) { case EHIGH; if (SPI_Ready( ) = false) return; // E high RS low whichstate = ELOW; WriteSPI(0x0800 arraytosend(numwordssent); break; ; case ELOW; if (SPI_Ready( ) = false) return; // E low RS low whichstate = EHIGH2; WriteSPI(0x0000 arraytosend(numwordssent); break; case EHIGH2; if (SPI_Ready( ) = false) return; // E high RS low whichstate = EHIGH; WriteSPI(0x0800 arraytosend(numwordssent); break; numwordssent++; --numwordslefttosend ; } 45 / 29