shiftled.c

ARM7 LED shift register (ST2221) in C programming

/*

*/

#include <LPC2103.H> 	                                	// LPC2103 MPU Register
#include "shiftled.h" 
//#include <intrins.h>

// GPIO0.04	  -> SERIAL DATA OUT,FOR ST2221 DRV
// GPIO0.05   -> CLK for ST2221
// GPIO0.06   -> ENABLE for ST2221
// GPIO0.07   -> LATCH for ST2221

// Define ST2221 PinIO Mask 
#define  ST2221_DAT    0x00000010   						
// P0.04(0000 0000 0000 0x00 0000 0000 0001 0000)
#define  ST2221_CLK    0x00000020   						
// P0.05(0000 0000 0000 x000 0000 0000 0020 0000)
#define  ST2221_EN     0x00000040   						
// P0.06(0000 0000 0000 00x0 0000 0000 0400 0000)
#define  ST2221_LTH    0x0000080   						
// P0.07(0000 0000 000x 0000 0000 0000 8000 0000)

#define  EN_set() IOSET = ST2221_EN	 				
// EN = 1 (Select Instruction)
#define  EN_clr() IOCLR = ST2221_EN					
// EN = 0 (Select Data)
#define  DAT_set() IOSET = ST2221_DAT				
// DAT = 1 (Read)
#define  DAT_clr() IOCLR = ST2221_DAT					
// DAT = 0 (Write)
#define  CLK_set() IOSET = ST2221_CLK					
// CLK = 1 (Enable)
#define  CLK_clr() IOCLR = ST2221_CLK					
// CLK = 0 (Disable)
#define  LTH_set() IOSET = ST2221_LTH					
// CLK = 1 (Enable)
#define  LTH_clr() IOCLR = ST2221_LTH					
// CLK = 0 (Disable)
extern void delay(unsigned long int count1);
extern struct Setting_Buf Set_Buf;

unsigned char uBuffer[4];
unsigned char Comm_buffer[4];
unsigned char Refreshbit;
unsigned char Global_V1;

struct DisplayBuf{
	unsigned char TAR[4];	//MSB..LSB (TAR[3] TAR[2] TAR[1] TAR[0])
	unsigned char OUT[4];	//MSB..LSB (OUT[3] OUT[2] OUT[1] OUT[0])
	unsigned char DIF[5];	//SIGN MSB..LSB (DIF[4] DIF[2] DIF[1] DIF[0])
};

struct DisplayBuf Dis_Buf;
//			  a
//			----			0 -- 00111111, 0x3f
//		  f|	|b		    1 -- 00000110
//		   |  g	|
//		   ------
//		  e|    |c
//		   |    |
//		   ------ o  dp
//			  d
//
const char SEGMENT[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x00,0x76,0x77,0x38,0x78,0x40}; 
/*        code char SEGMENT[]={0xFA,0x60,0xDC,0xF4,0x66,0xB6,0xBE,0xE0,0xFE,0xF6,0x00}; */
//code char SEGMENT[]={0xFC,0x60,0xDA,0xF2,0x66,0xB6,0xBE,0xE0,0xFE,0xF6,0x00, 0x6e, 0xde, 0x1c,0x1e, 0x02};
/* 0, 1,2,3,4,5,6,7,8,9, off, H,A,L,T,- */
//t,A,r,o,u,d,I,F,C,n,O,h,S,P,E,1,2,3
//0x78,0x77,0x50,0x5c,0x1c,0x5e,0x30,0x71,0x39,0x54,0x3f,0x74,0x6d,0x73,0x79
/*const char tAr[]="tAr ";
const char Out[]="Out ";
const char dIF[]="dIF ";
const char InCt[]="InCt";
const char InCo[]="InCo";
const char Sht[]="Sht ";
const char PrS[]="PrS ";
const char bS[]=" S";
const char bo[]=" o";
const char PE[]="PE";
*/
//***********************************seven segment display control & display*****************************
void Display_Function_Name(unsigned char *name)
{
	signed char a;
	clear_Display();
	for (a=4; a>0;a--)
	{
		
		Search_FontMap(name[4-a]);
		Dis_Buf.TAR[a-1]=Global_V1;
	}	
	Display_buffer();
}


void Display_Func(unsigned char *Buf, short Buf_Value, unsigned char change_tag)
{
	signed char i;
	signed short x,temp, temp1;
//************************************************clear buffer with option	
	if(change_tag==1)
	{
		for (i=0;i<4;i++)
    	{
        	Dis_Buf.TAR[i]=SEGMENT[10];
    	}
	}
    for (i=0;i<4;i++)
    {
        Dis_Buf.OUT[i]=SEGMENT[10];
    }

    for (i=0;i<5;i++)
    {
        Dis_Buf.DIF[i]=SEGMENT[10];
    }
//    Display_buffer();
//****************************************************

	if(change_tag==1)
	{
		for (i=4; i>0;i--)
		{
			Search_FontMap(Buf[4-i]);
			Dis_Buf.TAR[i-1]=Global_V1;
		}
	}			
		x=Buf_Value;
        temp1=x%1000;
        temp= x/1000;
		Dis_Buf.OUT[3]=SEGMENT[temp];

        temp=temp1/100;
        temp1=temp1 % 100;
		temp = temp & 0x0f;
		Dis_Buf.OUT[2]=SEGMENT[temp];

        temp=temp1/10;
        temp1=temp1 % 10;
 		Dis_Buf.OUT[1]=SEGMENT[temp];
		Dis_Buf.OUT[0]=SEGMENT[temp1];		
		Display_buffer();
}

void Search_FontMap(unsigned char F)
{
	switch (F)
	{
		case 't':
			Global_V1= 0xF8;
			break;
		case 'A':
			Global_V1= 0xF7;
			break;
		case 'r':
			Global_V1= 0xD0;
			break;
		case 'o':
			Global_V1= 0xDc;
			break;
		case 'u':
			Global_V1= 0x9c;
			break;
		case 'd':
			Global_V1= 0xDe;
			break;
//t,A,r,o,u,d,I,F,C,n,O,h,S,P,E
//0x78,0x77,0x50,0x5c,0x1c,0x5e,0x30,0x71,0x39,0x54,0x3f,0x74,0x6d,0x73,0x79
		case 'I':
			Global_V1= 0xB0;
			break;
		case 'F':
			Global_V1= 0xF1;
			break;
		case 'C':
			Global_V1= 0xB9;
			break;
		case 'n':
			Global_V1= 0xD4;
			break;
		case 'O':
			Global_V1= 0xBf;
			break;
		case 'h':
			Global_V1= 0xF4;
			break;
		case 'S':
			Global_V1= 0xEd;
			break;
		case 'P':
			Global_V1= 0xF3;
			break;
		case 'E':
			Global_V1= 0xF9;
			break;
		case '1':
			Global_V1= 0x06;
			break;
		case '2':
			Global_V1= 0x5b;
			break;
		case '3':
			Global_V1= 0x4f;
			break;
		case '4':
			Global_V1= 0x66;
			break;
		case '5':
			Global_V1= 0x6d;
			break;
		case '6':
			Global_V1= 0x7d;
			break;
		case '7':
			Global_V1= 0x07;
		case '8':
			Global_V1= 0x7f;
			break;
		case '9':
			Global_V1= 0x6f;
			break;
		case '-':
			Global_V1=0x40;
			break;	
		case 'y':
			Global_V1=0xee;
			break;
		case 'H':
			Global_V1=0xf6;
			break;
		case 'N':
			Global_V1=0xb7;
			break;
			
		default:
			Global_V1= 0x00;
			break;
	}
}

/********************************************************************************/
/* Convert buffer to display buffer for display code conversion                 */
/********************************************************************************/
void convert_display(void)
{
        char Zerobit;
		short x,temp, temp1;
		char * PtBuf;
		
		Zerobit=0;
		PtBuf=&Set_Buf.Target_Cnt;
		x= *PtBuf;
		PtBuf++;
		x= x | (*PtBuf <<8);
        Zerobit=0;
        temp1=x%1000;
        temp= x/1000;

		if (temp == 0) 
		{
			Dis_Buf.TAR[3]=SEGMENT[10];  // off display
			Zerobit=1;
		}
		else
		{
			Dis_Buf.TAR[3]=SEGMENT[temp];
		}

        temp=temp1/100;
        temp1=temp1 % 100;
		temp = temp & 0x0f;
		if ((temp==0x00) && (Zerobit==1)) Dis_Buf.TAR[2]=SEGMENT[10]; // off 2 segments
		else
		{
			Zerobit=0;
			Dis_Buf.TAR[2]=SEGMENT[temp];
		}

        temp=temp1/10;
        temp1=temp1 % 10;
		if ((temp==0x00) && (Zerobit==1))
		{ 
			Dis_Buf.TAR[1]=SEGMENT[10]; // off 3 segments
		}
		else Dis_Buf.TAR[1]=SEGMENT[temp];
		Dis_Buf.TAR[0]=SEGMENT[temp1];
///OUTPUT
		x=Set_Buf.Output_Cnt;
        Zerobit=0;
        temp1=x%1000;
        temp= x/1000;

		if (temp == 0) 
		{
			Dis_Buf.OUT[3]=SEGMENT[10];  // off display
			Zerobit=1;
		}
		else
		{
			Dis_Buf.OUT[3]=SEGMENT[temp];
		}

        temp=temp1/100;
        temp1=temp1 % 100;
		temp = temp & 0x0f;
		if ((temp==0x00) && (Zerobit==1)) Dis_Buf.OUT[2]=SEGMENT[10]; // off 2 segments
		else
		{
			Zerobit=0;
			Dis_Buf.OUT[2]=SEGMENT[temp];
		}

        temp=temp1/10;
        temp1=temp1 % 10;
		if ((temp==0x00) && (Zerobit==1))
		{ 
			Dis_Buf.OUT[1]=SEGMENT[10]; // off 3 segments
		}
		else Dis_Buf.OUT[1]=SEGMENT[temp];
		Dis_Buf.OUT[0]=SEGMENT[temp1];

// DIFFERENT
		x=Set_Buf.Target_Cnt - Set_Buf.Output_Cnt;
		if (x<0) 
		{
			Dis_Buf.DIF[4]=SEGMENT[15]; //"-" sign
			x = ~x+1;	//1's complement
			IOSET = 0x00040000;	//"-" signed ON
		}
		else 
		{
			Dis_Buf.DIF[4]=SEGMENT[10]; //" " sign
			IOCLR = 0x00040000;
		}
        Zerobit=0;
        temp1=x%1000;
        temp= x/1000;

		if (temp == 0) 
		{
			Dis_Buf.DIF[3]=SEGMENT[10];  // off display
			Zerobit=1;
		}
		else
		{
			Dis_Buf.DIF[3]=SEGMENT[temp];
		}

        temp=temp1/100;
        temp1=temp1 % 100;
		temp = temp & 0x0f;
		if ((temp==0x00) && (Zerobit==1)) Dis_Buf.DIF[2]=SEGMENT[10]; // off 2 segments
		else
		{
			Zerobit=0;
			Dis_Buf.DIF[2]=SEGMENT[temp];
		}

        temp=temp1/10;
        temp1=temp1 % 10;
		if ((temp==0x00) && (Zerobit==1))
		{ 
			Dis_Buf.DIF[1]=SEGMENT[10]; // off 3 segments
		}
		else Dis_Buf.DIF[1]=SEGMENT[temp];
		Dis_Buf.DIF[0]=SEGMENT[temp1];


}

void clear_Display(void)
{
	char i;

    for (i=0;i<4;i++)
    {
        Dis_Buf.TAR[i]=SEGMENT[10];
    }

    for (i=0;i<4;i++)
    {
        Dis_Buf.OUT[i]=SEGMENT[10];
    }

    for (i=0;i<4;i++)
    {
        Dis_Buf.DIF[i]=SEGMENT[10];
    }
    Display_buffer();
}


/*******************************************************************/
/* Display Display_bufferX to seven segment                        */
/*******************************************************************/
void Display_buffer(void)                                           
{
	signed char i; 
    for (i=4; i>0; i--) shift_byte(Dis_Buf.DIF[i-1]);
    for (i=4; i>0; i--) shift_byte(Dis_Buf.OUT[i-1]);
    for (i=4; i>0; i--) shift_byte(Dis_Buf.TAR[i-1]);
    E_Display();
    Refreshbit=0;     
}

// ROUTINE TO DISPLAY THE DATA TO ST2221
// SHIFT BYTE TO ST2221
void shift_byte(unsigned char x)
{
	unsigned char i,temp;

    LTH_clr();
    CLK_clr();
    for (i=0; i<8; i++)
    {
   	 	temp=x;
		if ((temp & 0x80) == 0x80) DAT_set();
		else DAT_clr();
		x= x << 1;
        shift_bus();
    }
}

/****************************************************************/
/*Shift display data bus                                        */
/****************************************************************/
void shift_bus (void)
{
     delay(10000);
     LTH_clr();
     CLK_set();
     delay(10000);
     CLK_clr();
     delay(10000);
}

/****************************************************************/
/*Enable Display strobe                                         */
/****************************************************************/
void E_Display (void)
{
     LTH_set();
     delay(100000);
     LTH_clr();
     EN_clr();
     DAT_clr();
}