TM4C129XKCZAD: keypad interface

Rajesh Varma

Part Number: TM4C129XKCZAD

Dear sir,

I am interfacing keypad with the TM4C129XCNZAD.

I already interfaced keypad with LM3s9B96 ( input lines Row directly to controller pin and columns connected through Decoder) The code is working .

I am using same code in TM4C129XCNZAD for keypad interface but only difference is column are directly connected to controller pin instead of decoder.

I am not able to get column number 1,2,3,4 .Getting column number 0 only.

Interrupt is working properly.

Please find the schematic of both circuit and code of both circuit.

keypad_LM3s9b96.c



#include"macro.h"

#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/debug.h"
#include "driverlib/gpio.h"
#include "driverlib/sysctl.h"
#include"external_variables.h"
#include "driverlib/rom.h"

 

//**********************************************************************************
/// void Coloum_Decoder_State(unsigned char Decoder_In_A ,unsigned char Decoder_In_B,unsigned char Decoder_In_C)
///	I/P: decoder states
/// O/P: Nothing
// Remark: This function is used to intialise the keypad GPIOs 
//**********************************************************************************

void Coloum_Decoder_State(unsigned char Decoder_In_A ,unsigned char Decoder_In_B,unsigned char Decoder_In_C)
	{
		if(Decoder_In_A ==0)
		{GPIOPinWrite(GPIO_PORTA_BASE , GPIO_PIN_3 , 0);}
		else 
		{GPIOPinWrite(GPIO_PORTA_BASE , GPIO_PIN_3 ,GPIO_PIN_3 );}
		if(Decoder_In_B ==0)
		{GPIOPinWrite(GPIO_PORTE_BASE , GPIO_PIN_2 , 0);}
		else 
		{GPIOPinWrite(GPIO_PORTE_BASE , GPIO_PIN_2 ,GPIO_PIN_2 );}
		if(Decoder_In_C ==0)
		{GPIOPinWrite(GPIO_PORTE_BASE , GPIO_PIN_3 , 0);}
		else 
		{GPIOPinWrite(GPIO_PORTE_BASE , GPIO_PIN_3 ,GPIO_PIN_3 );}		
	}

//**********************************************************************************
/// void keypad_init()
///	I/P: Nothing
/// O/P: Nothing
// Remark: This function is used to intialise the keypad connected GPIO pins
//**********************************************************************************

void keypad_init()
	{
	    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);   // Enable the GPIO blocks of port pin used.
	  	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
		SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ);
		SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
	
	    // Setting the GPIO's for the Rows as input signal
		GPIOPinTypeGPIOInput(Row_0_Base,Row_0_Pin);			   //Define PIN as input pin for all rows connected
		GPIOPinTypeGPIOInput(Row_1_Base,Row_1_Pin);
	//	GPIOPinTypeGPIOInput(GPIO_PORTF_BASE,0);
		GPIOPinTypeGPIOInput(Row_2_Base,Row_2_Pin);
		GPIOPinTypeGPIOInput(Row_3_Base,Row_3_Pin);
		GPIOPinTypeGPIOInput(Row_4_Base,Row_4_Pin);
	
		// Setting the GPIO's for the Coloum as output signal
	
		GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE,GPIO_PIN_3);	  //Define PIN as output for all coloumn connected
		GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE,GPIO_PIN_2);
		GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE,GPIO_PIN_3);

//********** The PGA Gain set to 10
		GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,GPIO_PIN_3);

//********************************************************************************//

		Coloum_Decoder_State(0,0,0); 			// Default state when all the Coloum are in low state.
	}


//**********************************************************************************
/// unsigned char Read_Row(void)
///	I/P: Nothing
/// O/P: Return the Row number
// Remark: This function is used to return row number
//**********************************************************************************

unsigned char Read_Row(void)
	{
		unsigned char Row_Number;
	
		
		if(GPIOPinRead(Row_0_Base,Row_0_Pin)== 0)
		{
			Row_Number=0;
		}
		else if(GPIOPinRead(Row_1_Base,Row_1_Pin)== 0)
		{
			Row_Number=1;
		}
		else if(GPIOPinRead(Row_2_Base,Row_2_Pin)== 0)
		{
			Row_Number=2;
		}
		else if(GPIOPinRead(Row_3_Base,Row_3_Pin)== 0)
		{
			Row_Number=3;
		}
		else if(GPIOPinRead(Row_4_Base,Row_4_Pin)== 0)
		{
			Row_Number=4;
		}
		else 
		{
			Row_Number=5;
		}
			
	return Row_Number;
		
	}

//**********************************************************************************
/// char getkey()
///	I/P: Nothing
/// O/P: Return the pressed key
/// Remark: This function is used to detect the pressed key
//**********************************************************************************
unsigned char test_row,test_coloum;

char getkey()
	{
		unsigned char Row_Number,Coloum_Number,Temp_Row_Number;
	
		// Check if any of the Key is pressed
		Coloum_Number=0;
		Row_Number=Read_Row();

		test_row = Row_Number;
			
	
		if((Row_Number ==5) && (Flag.Keypad_Reset==0)) 
		{
			val = 'N';
			Flag.Keypad_Reset=1;
			Flag.Key_Processed =0;
		}
		else if(( Flag.Keypad_Reset==0) && (Flag.Key_Processed ==1))  
		{
			val = 'P';
		//	Flag.Keypad_Reset=1;
		//	Flag.Key_Processed =0;		
		}
		else
		{
			//*******************************************************	
			if((Row_Number ==0) || (Row_Number ==1) || (Row_Number ==2)|| (Row_Number ==3) || (Row_Number ==4))
			{
				Coloum_Decoder_State(1,1,1);  // Coloum 0 high
				Temp_Row_Number=Read_Row();
				if (Temp_Row_Number != Row_Number)
				{
					Coloum_Number = 0;
				}
			
				Coloum_Decoder_State(0,1,1);  // Coloum 1 high
				Temp_Row_Number=Read_Row();
				if (Temp_Row_Number != Row_Number)
				{
					Coloum_Number = 1;
				}
				Coloum_Decoder_State(0,0,1);  // Coloum 2 high
				Temp_Row_Number=Read_Row();
				if (Temp_Row_Number != Row_Number)
				{
					Coloum_Number = 2;
				}
				Coloum_Decoder_State(1,0,1);  // Coloum 3 high
				Temp_Row_Number=Read_Row();
				if (Temp_Row_Number != Row_Number)
				{
					Coloum_Number = 3;
				}
				Coloum_Decoder_State(1,1,0);  // Coloum 4 high
				Temp_Row_Number=Read_Row();
				if (Temp_Row_Number != Row_Number)
				{
					Coloum_Number = 4;
				}
			 Flag.Keypad_Reset=0;
			}
		//****************************************************************
		//****************** Key Pad Matrix******************
		//****************************************************************
		  test_coloum = Coloum_Number;
			//************ROW-0**************************	
			//	test_col = Coloum_Number;
			if((Row_Number==0) && (Coloum_Number==0))	
			 {val = '3';Flag.Key_Processed=0;}
			else if((Row_Number==0) && (Coloum_Number==1))	
			 {val = '6';Flag.Key_Processed=0;}
			else if((Row_Number==0) && (Coloum_Number==3))	
			 {val = '9';Flag.Key_Processed=0;}
			else if((Row_Number==0) && (Coloum_Number==4))	
			 {val = 'd';Flag.Key_Processed=0;}
			//************ROW-1**************************	
			else if((Row_Number==1) && (Coloum_Number==0))	
			 {val = '2';Flag.Key_Processed=0;}
			else if((Row_Number==1) && (Coloum_Number==1))	
			 {val = '5';Flag.Key_Processed=0;}
		   	else if((Row_Number==1) && (Coloum_Number==3))	
			 {val = '8';Flag.Key_Processed=0;}
			else if((Row_Number==1) && (Coloum_Number==4))	
			 {val = '0';Flag.Key_Processed=0;}
		
			//************ROW-2**************************	
			else if((Row_Number==2) && (Coloum_Number==0))	
			 {val = '1';Flag.Key_Processed=0;}
			else if((Row_Number==2) && (Coloum_Number==1))	
			 {val = '4';Flag.Key_Processed=0;}
			else if((Row_Number==2) && (Coloum_Number==3))	
			 {val = '7';Flag.Key_Processed=0;}
			else if((Row_Number==2) && (Coloum_Number==4))	
			 {val = '.';Flag.Key_Processed=0;}
			//************ROW-3**************************	
			else if((Row_Number==3) && (Coloum_Number==0))	
			 {val = 'U';Flag.Key_Processed=0;}
			else if((Row_Number==3) && (Coloum_Number==1))	
			 {val = 'L';Flag.Key_Processed=0;}
			else if((Row_Number==3) && (Coloum_Number==2))	
			 {val = 'D';Flag.Key_Processed=0;}
			else if((Row_Number==3) && (Coloum_Number==3))	
			 {val = 'E';Flag.Key_Processed=0;}
			else if((Row_Number==3) && (Coloum_Number==4))	
			 {val = 'R';Flag.Key_Processed=0;}
			//************ROW-4**************************
			else if((Row_Number==4) && (Coloum_Number==0))	
			 {val = 'A';Flag.Key_Processed=0;}
			else if((Row_Number==4) && (Coloum_Number==1))	
			 {val = 'B';Flag.Key_Processed=0;}
			else if((Row_Number==4)&& (Coloum_Number==3))	
			 {val = 'C';Flag.Key_Processed=0;}
			else if((Row_Number==4) && (Coloum_Number==4))	
			 {val = 'S';Flag.Key_Processed=0;}
					
			else
			   { val = 'N';Flag.Key_Processed=0;}


	//****************************************************************	
		}
		Coloum_Decoder_State(0,0,0); 		// Resume the Default state when all the Coloum are in low state.	
		return(val);						// Return the key to the calling funtion
       
	}  // End of the function getkey();

LM3s9b96_keypad schematic.pdf

0216.keypad_TM4C129X.c

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "drivers/pinout.h"
#include "driverlib/rom.h"
#include "inc/hw_memmap.h"
#include "driverlib/gpio.h"
#include "inc/hw_sysctl.h"
//#include "driverlib/sysctl.h"
#include "utils/ustdlib.h"			/// required for usprintf function
//#include "driverlib/timer.h"
//#include "driverlib/interrupt.h"
#include "inc/hw_ints.h"
#include "utils/uartstdio.h"
//#include "driverlib/uart.h"
#include "grlib/grlib.h"
#include "drivers/kentec320x240x16_ssd2119.h"
#include <string.h>
#include <math.h>
#include "driverlib/systick.h"
#include "driverlib/rom_map.h"
//#include "drivers/ssiflash.h"   
//#include "driverlib/watchdog.h"
#include "macros.h"
//#include "prototype.h"
#include "external_variables.h"


unsigned char test_row;

//**********************************************************************************
/// void keypad_init()
///	I/P: Nothing
/// O/P: Nothing
// Remark: This function is used to intialise the keypad connected GPIO pins
//**********************************************************************************

void keypad_init()
	{
	   //SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);   // Enable the GPIO blocks of port pin used.
	   //SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
		 //SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ);
		 //SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
	
	    // Setting the GPIO's for the Rows as input signal
		MAP_GPIOPinTypeGPIOInput(Row_0_Base,Row_0_Pin);			   //Define PIN as input pin for all rows connected
		MAP_GPIOPinTypeGPIOInput(Row_1_Base,Row_1_Pin);
		MAP_GPIOPinTypeGPIOInput(Row_2_Base,Row_2_Pin);
		MAP_GPIOPinTypeGPIOInput(Row_3_Base,Row_3_Pin);
		MAP_GPIOPinTypeGPIOInput(Row_4_Base,Row_4_Pin);
	
		// Setting the GPIO's for the Coloum as output signal
	
		MAP_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE,GPIO_PIN_4);	
		MAP_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE,GPIO_PIN_6);
		MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE,GPIO_PIN_4);
		MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE,GPIO_PIN_2);
		MAP_GPIOPinTypeGPIOOutput(GPIO_PORTL_BASE,GPIO_PIN_5);
		
		 MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4, 0);
		 MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_6, 0);
		 MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_4, 0);
		 MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_2, 0);
		 MAP_GPIOPinWrite(GPIO_PORTL_BASE, GPIO_PIN_5, 0);
		
		
//		GPIOPinTypeGPIOInput(GPIO_PORTE_BASE,GPIO_PIN_4);			   //Define PIN as input pin for all rows connected
//		GPIOPinTypeGPIOInput(GPIO_PORTE_BASE,GPIO_PIN_6);
//		GPIOPinTypeGPIOInput(GPIO_PORTN_BASE,GPIO_PIN_4);
//		GPIOPinTypeGPIOInput(GPIO_PORTN_BASE,GPIO_PIN_2);
//		GPIOPinTypeGPIOInput(GPIO_PORTL_BASE,GPIO_PIN_5);
//	
//		// Setting the GPIO's for the Coloum as output signal
//	
//		GPIOPinTypeGPIOOutput(Row_0_Base,Row_0_Pin);	
//		GPIOPinTypeGPIOOutput(Row_1_Base,Row_1_Pin);
//		GPIOPinTypeGPIOOutput(Row_2_Base,Row_2_Pin);
//		GPIOPinTypeGPIOOutput(Row_3_Base,Row_3_Pin);
//		GPIOPinTypeGPIOOutput(Row_4_Base,Row_4_Pin);


//********************************************************************************//

	
	}


//**********************************************************************************
/// unsigned char Read_Row(void)
///	I/P: Nothing
/// O/P: Return the Row number
// Remark: This function is used to return row number
//**********************************************************************************
unsigned char Status_0,Status_1,Status_2,Status_3,Status_4;
unsigned char Read_Row(void)
	{
		unsigned char Row_Number;
		
		
		
		Status_0=MAP_GPIOPinRead(Row_0_Base,Row_0_Pin);
		Status_1=MAP_GPIOPinRead(Row_1_Base,Row_1_Pin);
		Status_2=MAP_GPIOPinRead(Row_2_Base,Row_2_Pin);
		Status_3=MAP_GPIOPinRead(Row_3_Base,Row_3_Pin);
		Status_4=MAP_GPIOPinRead(Row_4_Base,Row_4_Pin);
		
		if(MAP_GPIOPinRead(Row_0_Base,Row_0_Pin)== 0)
		{
			Row_Number=0;
		}
		else if(MAP_GPIOPinRead(Row_1_Base,Row_1_Pin)==0)
		{
			Row_Number=1;
		}
		else if(MAP_GPIOPinRead(Row_2_Base,Row_2_Pin)== 0)
		{
			Row_Number=2;
		}
		else if(MAP_GPIOPinRead(Row_3_Base,Row_3_Pin)== 0)
		{
			Row_Number=3;
		}
		else if(MAP_GPIOPinRead(Row_4_Base,Row_4_Pin)== 0)
		{
			Row_Number=4;
		}
		else 
		{
			Row_Number=5;
		}
	return Row_Number;
		
	}

//**********************************************************************************
/// char getkey()
///	I/P: Nothing
/// O/P: Return the pressed key
/// Remark: This function is used to detect the pressed key
//**********************************************************************************
unsigned char Row_Number,Coloum_Number,Temp_Row_Number;	
char getkey()
	{
		
	
		// Check if any of the Key is pressed
		Coloum_Number=0;
		Row_Number=Read_Row();

		test_row = Row_Number;	
	
			if((Row_Number ==5) && (Flag.Keypad_Reset==0)) 
		{
			val = 'N';
			Flag.Keypad_Reset=1;
			Flag.Key_Processed =0;
		}
		else if(( Flag.Keypad_Reset==0) && (Flag.Key_Processed ==1))  
		{
			val = 'P';
			//	Flag.Key_Processed =1;		
		}
		else
		{
			//*******************************************************	
			if((Row_Number ==0) || (Row_Number ==1) || (Row_Number ==2)|| (Row_Number ==3) || (Row_Number ==4))
			{
				//Coloum_Decoder_State(1,1,1);  // Coloum 0 high
				MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4,GPIO_PIN_4);
				MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_6, 0);
				MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_4, 0);
				MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_2, 0);
				MAP_GPIOPinWrite(GPIO_PORTL_BASE, GPIO_PIN_5, 0);
		

				Temp_Row_Number=Read_Row();
				if (Temp_Row_Number != Row_Number)
				{
					Coloum_Number = 0;
				}
			
				MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_6,GPIO_PIN_6);
			  MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4, 0);
  		  MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_4, 0);
  		  MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_2, 0);
  		  MAP_GPIOPinWrite(GPIO_PORTL_BASE, GPIO_PIN_5, 0);
		

				Temp_Row_Number=Read_Row();
				if (Temp_Row_Number != Row_Number)
				{
					Coloum_Number = 1;
				}
			
		
				MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_4,GPIO_PIN_4);
				MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4, 0);
    		MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_6, 0);
    		MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_2, 0);
    		MAP_GPIOPinWrite(GPIO_PORTL_BASE, GPIO_PIN_5, 0);
				
				Temp_Row_Number=Read_Row();
				if (Temp_Row_Number != Row_Number)
				{
					Coloum_Number = 2;
				}
				
				
				
				
				MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_2,GPIO_PIN_2);
				MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4, 0);
  		  MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_6, 0);
				MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_4, 0);
				MAP_GPIOPinWrite(GPIO_PORTL_BASE, GPIO_PIN_5, 0);
		

				Temp_Row_Number=Read_Row();
				if (Temp_Row_Number != Row_Number)
				{
					Coloum_Number = 3;
				}
				MAP_GPIOPinWrite(GPIO_PORTL_BASE, GPIO_PIN_5,GPIO_PIN_5);
				MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4, 0);
  		  MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_6, 0);
  		  MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_4, 0);
   		  MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_2, 0);

				Temp_Row_Number=Read_Row();
				if (Temp_Row_Number != Row_Number)
				{
					Coloum_Number = 4;
				}
			 Flag.Keypad_Reset=0;
			}
		//****************************************************************
		//****************** Key Pad Matrix******************
		//****************************************************************
		
			//************ROW-0**************************	
			//	test_col = Coloum_Number;
			if((Row_Number==0) && (Coloum_Number==0))	
			 {val = '3';Flag.Key_Processed=0;}
			else if((Row_Number==0) && (Coloum_Number==1))	
			 {val = '6';Flag.Key_Processed=0;}
			else if((Row_Number==0) && (Coloum_Number==3))	
			 {val = '9';Flag.Key_Processed=0;}
			else if((Row_Number==0) && (Coloum_Number==4))	
			 {val = 'd';Flag.Key_Processed=0;}
			//************ROW-1**************************	
			else if((Row_Number==1) && (Coloum_Number==0))	
			 {val = '2';Flag.Key_Processed=0;}
			else if((Row_Number==1) && (Coloum_Number==1))	
			 {val = '5';Flag.Key_Processed=0;}
		   	else if((Row_Number==1) && (Coloum_Number==3))	
			 {val = '8';Flag.Key_Processed=0;}
			else if((Row_Number==1) && (Coloum_Number==4))	
			 {val = '0';Flag.Key_Processed=0;}
		
			//************ROW-2**************************	
			else if((Row_Number==2) && (Coloum_Number==0))	
			 {val = '1';Flag.Key_Processed=0;}
			else if((Row_Number==2) && (Coloum_Number==1))	
			 {val = '4';Flag.Key_Processed=0;}
			else if((Row_Number==2) && (Coloum_Number==3))	
			 {val = '7';Flag.Key_Processed=0;}
			else if((Row_Number==2) && (Coloum_Number==4))	
			 {val = '.';Flag.Key_Processed=0;}
			//************ROW-3**************************	
			else if((Row_Number==3) && (Coloum_Number==0))	
			 {val = 'U';Flag.Key_Processed=0;}
			else if((Row_Number==3) && (Coloum_Number==1))	
			 {val = 'L';Flag.Key_Processed=0;}
			else if((Row_Number==3) && (Coloum_Number==2))	
			 {val = 'D';Flag.Key_Processed=0;}
			else if((Row_Number==3) && (Coloum_Number==3))	
			 {val = 'E';Flag.Key_Processed=0;}
			else if((Row_Number==3) && (Coloum_Number==4))	
			 {val = 'R';Flag.Key_Processed=0;}
			//************ROW-4**************************
			else if((Row_Number==4) && (Coloum_Number==0))	
			 {val = 'A';Flag.Key_Processed=0;}
			else if((Row_Number==4) && (Coloum_Number==1))	
			 {val = 'B';Flag.Key_Processed=0;}
			else if((Row_Number==4)&& (Coloum_Number==3))	
			 {val = 'C';Flag.Key_Processed=0;}
			else if((Row_Number==4) && (Coloum_Number==4))	
			 {val = 'S';Flag.Key_Processed=0;}
	//****************************************************************	
		}
		 MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4, 0);
		 MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_6, 0);
		 MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_4, 0);
		 MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_2, 0);
		 MAP_GPIOPinWrite(GPIO_PORTL_BASE, GPIO_PIN_5, 0);
//		
//		if((comm_disable_seamaphore)&&(disp_para_cnt==2))
//			val = 'N';

		return(val);						// Return the key to the calling funtion
       
	}  // End of the function getkey();
	
	


//#define KEYPAD_ROW_0 GPIO_PIN_1 
//#define KEYPAD_ROW_1 GPIO_PIN_1 
//#define KEYPAD_ROW_2 GPIO_PIN_3 
//#define KEYPAD_ROW_3 GPIO_PIN_2 
//#define KEYPAD_ROW_4 GPIO_PIN_3 
//#define KEYPAD_ROWS (KEYPAD_ROW_0|KEYPAD_ROW_1|KEYPAD_ROW_2|KEYPAD_ROW_3|KEYPAD_ROW_4)



//#define KEYPAD_COL_0 GPIO_PIN_4 
//#define KEYPAD_COL_1 GPIO_PIN_6 
//#define KEYPAD_COL_2 GPIO_PIN_4 
//#define KEYPAD_COL_3 GPIO_PIN_2 
//#define KEYPAD_COL_4 GPIO_PIN_5 
//#define KEYPAD_COLS (KEYPAD_COL_0|KEYPAD_COL_1|KEYPAD_COL_2|KEYPAD_COL_3|KEYPAD_COL_4)


//int checkKeypadCol(unsigned long ulPort,unsigned char checkCol) 
//{
//	long rowPins;

//	MAP_GPIOPinWrite(ulPort, KEYPAD_COLS, checkCol);

//	Temp_Row_Number=Read_Row();
//	 
//	return value;
//	
//	
//}

//row = checkKeypadCol(GPIO_PORTE_BASE,KEYPAD_COL_0);
//row = checkKeypadCol(GPIO_PORTE_BASE,KEYPAD_COL_1);
//row = checkKeypadCol(GPIO_PORTN_BASE,KEYPAD_COL_2);
//row = checkKeypadCol(GPIO_PORTN_BASE,KEYPAD_COL_3);
//row = checkKeypadCol(GPIO_PORTL_BASE,KEYPAD_COL_4);



//

Tivac_keypad_schematic.pdf

over 2 years ago

0 Ralph Jacobi over 2 years ago

TI__Guru*** 128255 points

Hello Rajesh,

Looking over your code I didn't see anything glaringly wrong but I wonder about a couple things as I am trying to think through possible issues.

1) Is it okay for two GPIO to be high at the same time on a column? Because the way your code is setup, you are setting one I/O high before pulling the other one low. Since Column 0 works where they are all low first, that makes me wonder if having two signals high is causing an issue. Perhaps you can try setting the high signal at the end of each sequence of pin changes so you can be sure that all pins are low before the first pin is set high? The more I write on this one, the more I am feeling like this is a good first experiment to try out.

2) Have you considered taking scope shots of the two setups to see how the I/O are toggling different on the columns when using the encoder vs using direct connections? I think perhaps that might show something useful.

3) Are you using the same levels of resistance for pullups etc.? Along those lines, maybe verify with a scope about rise time and that the signal is stable when trying to read the column information etc.

Best Regards,

Ralph Jacobi

Arm-based microcontrollers

Arm-based microcontrollers forum

TM4C129XKCZAD: keypad interface