CEG 3136 Lab 2: Hardware Interfacing - Keypad Lab Report

downloaded from

Scholarfriends

https://scholarfriends.com Downloaded by: writerforacademic@gmail.com | https://scholarfriends.com/singlePaper/273111/lab-report-ceg-3136-lab-2-hardwareinterfacing-keypad-fall-2019 Distribution of this document is illegal.

CEG 3136 Lab 2: Hardware Interfacing - Keypad Fall 2019 Students:

Purpose

3

Equipment

3

Part One:

3

Problem

3

Input/Outputs of Problem

3

Algorithm

3

Implementation

8

Testing

8

Part two:

8

Problem

8

Input/Outputs of Problem

8

Algorithm

9

Implementation

9

Testing and Validation

10

Conclusion:

10

Purpose The purpose of this lab was to introduce the interfacing of the Motorola 9S12DG256 through an implementation of a keypad unit.

Equipment -Windows PC -Dragon12 board

Part One: Problem The task was to implement KeyPad.asm which would be used to communicate with the touchpad on the Dragon12 board. This code is used to take the inputs done on the touchpad by the user and associate them with a numerical value in ASCII code corresponding to the character pressed.

Input/Outputs of Problem The input was the key pressed on the touchpad by the user while the outputs were the corresponding ASCII of the key to be used by the program

Algorithm The first function in the algorithm is pollReadKey which is used to check if a key has been pressed or not, which allows the program to check if a key has been pressed without a key necessarily being pressed. This is different from the readKey() function which waits for a key to be pressed, instead this function checks if a key has been pressed, then if pressed it will return the key character and if not it will return NOKEY which has value 0.

char pollReadKey() { char ch = NOKEY;

// Initialized as no key.

int count = POLLCOUNT;

// Number of checks to be done

PORTA = 0x0f;

// Resets PORTA

do { if (PORTA != 0x0f) {

// Checks for key press

delayms(1); if (PORTA != 0x0f) { ch = readKey(); break;

// Check again for key press

// Reads key and converts to ASCII // End loop

} } count--; } while (count); return ch; }

The second function is the readKey function. This function reads the value associated with key press and also ensures that proper debouncing occurs both when the key is pressed and when it is released. When a keypress is detected, a 10 ms wait is done to ensure that the key is still pressed. This delay will ensure that a key has actually been pressed rather than some sort of vibration or noise. Once a key press signal is stable, the key is then read using the readKeyCode() subroutine and the keycode is translated into an ASCII character using the translate subroutine. Then the program waits until the key is released and returns control to the calling function.

byte readKey(){ byte ch; do { PORTA = 0x0F; //set all output pins PA7-PA4 to 0 while(PORTA == 0x0F) // Checking for the leading edge 1 until a key is pressed)

//bits PA3-PA0 are

{ code = PORTA; // get the keycode from the user delayms(10); //Delay for the debounce of button } }while(code != PORTA); //start again when PORTA changes code = readKeyCode(); //call readKeyCode to get keycode PORTA = 0x0F; // set pins PA7-PA4 to 0 while(PORTA != 0x0F) // wait for trailing edge { delayms(10); //delay for the debounce of the key } ch = translate(code);//call translate to get ASCII code return(ch); }

The readKeyCode function detects the key pressed and returns the proper code associated to it from the board. To create this function there is required knowledge on how the internal wiring of the touchpad is connected to the buttons and the IO register. Each row of the keypad is turned on momentarily to detect any key presses on that row. Once a change in the lower half of the PORTA register is detected, it indicates which key is pressed. After deciphering the key that was pressed, the subroutine then exits and returns the changed PORTA value of the pressed character.

#DEFINE ROW1 %1110 1111 #DEFINE ROW2 %1101 1111 #DEFINE ROW3 %1011 1111 #DEFINE ROW4 %0111 1111 byte readKeyCode(){ byte key; PORTA = ROW1; if(PORTA == ROW1) //Check to see if key pressed is in ROW1 { PORTA = ROW2; if(PORTA == ROW2)//Check to see if key pressed is in ROW2 { PORTA = ROW3; if(PORTA == ROW3) //Check to see if key pressed is in ROW3 { PORTA = ROW4 //Must be in ROW4 } } key = PORTA; } return (key); }

The final function we were tasked with implementing was the translate function. This function takes the code from the pressed key and returns the translated ASCII code, so it can be read by the program.

​byte translate(byte code){ if(code == %1110 1110) return '1'; if(code == %1110 1101) return '2'; if(code == %1110 1011) return '3'; if(code == %1110 0111) return 'a';

if(code == %1101 1110) return '4'; if(code == %1101 1101) return '5'; if(code == %1101 1011) return '6'; if(code == %1101 0111) return 'b';

if(code == %1011 1110) return '7'; if(code == %1011 1101) return '8'; if(code == %1011 1011) return '9'; if(code == %1011 0111) return 'c';

if(code == %0111 1110) return '*'; if(code == %0111 1101) return '0'; if(code == %0111 1011) return '#'; if(code == %0111 0111) return 'd';

return 0; }

Implementation Please see attached keypad.asm file for the implementation of each function.

Testing In order to test the modified code ran the code using an input which we had an expected output.

Then after running the code using said input we then compared the expected output with the actual output and since they were the same we concluded that we were successful in the modifications we made.

Part two: Problem We were tasked to create a subroutine, delayms which implements a delay based on the number of milliseconds specified by the numerical value of the input given.

Input/Outputs of Problem This delayms function was used for the debouncing problem for the keys. The input to the function was the time in ms, which was used to associate the amount that was wished to be delayed. This function did not have an actual output but the result of it causes a delay to be used in different situations.

Algorithm The algorithm is made up of two loops, one being the outer loop which delays in multiples of milliseconds and the other being the inner loop which causes a delay of 1 millisecond. In the function, the number of cycles being performed by the inner loop takes into account the number of cycles required by the outer loop to perform its functions. This allows for each cycle of the outer loop to be exactly 24,000 cycles which is about 1 millisecond. However, although negligible for this lab, the subroutine also uses a 19 additional cycles to complete some additional tasks. ​void delayms(unsigned int milli) { unsigned int delayCycles;

while (milli--) { delayCycles = 0x12BD; // Number of cycles for a 1 MS delay.

do { // NOP } while(--delayCycles) // Extra NOP } return; }

Implementation See the attached delay.asm file for implementation of the subroutine delayms.

Testing and Validation The testing of this function took place with all of the other functions implemented in part one due to a proper debounce being needed when attempting to read a key press, in order to obtain a single press and not multiple.

Conclusion: From this lab we concluded that user input can be read from a touchpad by using modular code along with subroutines and in order to overcome challenges such as key debouncing additional software scanning techniques must be implemented. We also noticed that if a subroutine is created for some purpose, new code can be implemented very easily by reusing your previous code.