/*****************************************************************************
1-DIGIT 7-SEGMENT COUNTER
=============================
In this project a common cathode 7-segmentdisplay is connected to PORT B of a
PIC16F877A type microcontroller (other types can also be used). The microcontroller
is operated from an 8MHz crystal.
The display counts from 0 to 9 and then back to 0 continuously with one second delay
between each count.
**************************************************************************/
void main()
{
unsigned char Disp, Cnt = 0;
unsigned char SevenSegment[] = 
{0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
TRISB = 0; 					// PORT D pins are outputs
PORTB = 0 ;

for(;;)						 // DO FOREVER
{
Disp = SevenSegment[Cnt];		 // Get bits of number to be displayed
PORTB = Disp; 			// Display number
Cnt++; 				// Incremet count
if(Cnt == 10)Cnt = 0; 		// Back to zero
Delay_Ms(1000);			 // Wait 1 second
}
}

unsigned char Disp, Cnt = 0;
unsigned char SevenSegment[] = 
{0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
TRISB = 0; 					// PORT D pins are outputs
PORTB = 0 ;

Disp = SevenSegment[Cnt];		 // Get bits of number to be displayed

 PORTB = Disp; 			// Display number

Cnt++; 				// Incremet count
if(Cnt == 10)Cnt = 0; 		// Back to zero

Delay_Ms(1000);			 // Wait 1 second

// this function forms the bit pattern corresponding to a number between 0 and 9. This
// bit pattern is returned to the calling program
//
unsigned char Display_Segment(unsigned char Number)
{
unsigned char SevenSegment[] = 
{0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
unsigned char Disp;
Disp = SevenSegment[Number]; 		// Get bits of the number to be displayed
return (Disp); 				// Return bits to main program
}
//
// Start of main program
//
void main()
{
unsigned char Cnt = 0;
TRISB = 0; 					// PORT B pins are outputs
PORTB = 0 ;


for(;;) 						// DO FOREVER
{
PORTB = Display_Segment(Cnt); // Display number
Cnt++; 				// Increment count
if(Cnt== 10)Cnt = 0; 		// Back to zero
Delay_Ms(1000); 			// Wait 1 second
}
}

/*Project name: 7-Segment */
#define SW1 PORTD.F0

char Display_Segment(char Number)
{
char SevenSegment[] = 
{0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
char Disp;
Disp = SevenSegment[Number]; 		// Get bits of the number to be displayed
return (Disp);					 // Return bits to main program
}


char Count = 0;

void main() 
{
  TRISB  = 0;           //Configure PORTB as Outputs
  PORTB = 0;
  TRISD.F0 = 1;      //Configure RD0 as intput
  
  while(1){

      if (SW1==0)          //Check if switch SW1 is closed
      {
         delay_ms(100);  //wait for 100ms  (switch debouncing)
         if (SW1==0)       //Check if switch SW1 is still closed
         {
			Count ++;
PORTB = Display_Segment(Count);
	if (Count >9) Count =0;
         }
while (SW1 ==0); // Wait for release of the button

      }
      else
      {
        PORTB = Display_Segment(Count);
      }
    }
}

/*
 * Project name:
     UP/DOWN Decimal Counter with Push Button and 7-Segment Interface
* Description:
     This code is an example of Seven Segment Display and Push Button interface.
     A decimal counter value will be displayed on the seven segment display.
     The value of the counter can be incremented or decremented through push
     buttons.
     MCU:             PIC16F877A
     The two push buttons are connected to RD0(Increment) and RD1(Decrement)
     and the seven segment display connected to PORTB (Segment a to PB.0,
     Segment b to PB.1 and so on)
*/
//-------------- Function to Return mask for common cathode 7-seg. display
char SevenSegment(char num) {
  switch (num) {
    case 0 : return 0x3F;
    case 1 : return 0x06;
    case 2 : return 0x5B;
    case 3 : return 0x4F;
    case 4 : return 0x66;
    case 5 : return 0x6D;
    case 6 : return 0x7D;
    case 7 : return 0x07;
    case 8 : return 0x7F;
    case 9 : return 0x6F;
  } //case end
}

char   digit;      			// To Hold Decimal Value
char number;     			// To Hold Equivalent Seven Segment Value

void main() {
  TRISB = 0x00;        			// Set PORTB direction to be output
  PORTB = 0x00;        		// Turn OFF LEDs on PORTB
  TRISD0_bit = 1;      		// RD0 Input for Increment
  TRISD1_bit = 1;      		// RD1 Input for Decrement

  digit   =    0; 				 // Initial Value of Counter , Decimal Value
  number  = SevenSegment (digit)   ;//Get 7-segment pattern
  PORTB   = number;		//Display 

  do {
    if (PORTD.F0 == 0 ) {  		// Detect logical zero
      Delay_ms(200);
      digit ++;                 		// Increase Counter
      number  = SevenSegment (digit)   ;
      PORTB   = number;

    }
    if (PORTD.F1 == 0) {  		// Detect logical zero
      Delay_ms(200) ;
      digit = digit--;                 		// Decrease Counter
      number  = SevenSegment (digit)   ;
      PORTB   = number;                
    }
  } while(1);                             	// endless loop
}

//Call System

#define SW1 PORTD.F0
#define SW2 PORTD.F1
#define SW3 PORTD.F2
#define SW4 PORTD.F3
#define SW5 PORTD.F4
#define SW6 PORTD.F5
//======================
void main()
{
TRISB = 0; 				//PORTB as outouts
PORTB = 0;													
TRISD = 0xFF;			//PORTD as inputs 
PORTB = 0x3F; 			// Display "0"

 while(1)
 {
   
  //==========First SWITCH ========
	if(SW1==0) 			// Test for LOW state 
	{
	PORTB = 0x06; 		// Display "1"
	PORTB.F7 = 1 ; delay_ms(500); PORTB.F7 = 0 ;// Buzzer Operation 
	delay_ms(10000); 		// Wait 10 sec 
	}
      
	else if(SW2==0) 		// Test for LOW state 
    	{
	PORTB = 0x5B ;		// Display "2"
	PORTB.F7 = 1 ; delay_ms(500); PORTB.F7 = 0 ;// Buzzer Operation
	delay_ms(10000);
	}
      
    	else if(SW3==0) 		// Test for LOW state 
	{
    	PORTB = 0x4F; 		// Display "3"
	PORTB.F7 = 1 ; delay_ms(500); PORTB.F7 = 0 ;// Buzzer Operation
	delay_ms(10000);
	}
      
    	else if(SW4==0) 		// Test for LOW state 
	{
    	PORTB = 0x66; 		// Display "4"
	PORTB.F7 = 1 ; delay_ms(500); PORTB.F7 = 0 ;// Buzzer Operation        
	delay_ms(10000);
	}
      
    	else if(SW5==0)     		// Test for LOW state 
	{
	PORTB = 0x6D; 		// Display "5"
	PORTB.F7 = 1 ; delay_ms(500); PORTB.F7 = 0 ;// Buzzer Operation
	delay_ms(10000);
	}
      
    	else if(SW6==0) 		// Test for LOW state 
	{
      
	PORTB = 0x7D; 		// Display "6"
	PORTB.F7 = 1 ; delay_ms(500); PORTB.F7 = 0 ;// Buzzer Operation
	delay_ms(10000);
	}
      
    	else 
    	PORTB = 0x3F;		// Display "0"
   //==============================
  
   }
}

/*****************************************************************************
2-DIGIT 7-SEGMENT DISPLAY
=======================
In this tutorial 2-digit common cathode 7-segment display is connected to PORT B of a
PIC16F877A type microcontroller (other types can also be used). The microcontroller is operated from an 8MHz crystal. The displays are multiplexed where the a-g segment lines are in parallel, but the common cathode pin (enable) of each display is controlled separately.
Number 45 is displayed on the 2-digit display as an example.
Digit1 (right hand side) is controlled from port RD0 through a transistor switch, and
Digit2 (left hand side) is from port RD1.
This program uses a function to get the bit pattern for a given number. This bit pattern is returned to the calling program.
*******************************************************************/
#define Digit1_Enable RD0_bit
#define Digit2_Enable RD1_bit
//
// this function forms the bit pattern corresponding to a number between
// 0 and 9. this bit pattern is returned to the calling program
//
unsigned char Display_Segment(unsigned char Number)
{
unsigned char SevenSegment[] = 
{0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
unsigned char Disp;
Disp = SevenSegment[Number]; 		// Get bits of the number to be displayed
return (Disp); 				// Return bits to main program
}
//
// Start of main program
//
void main()
{
unsigned char Num = 45;
unsigned char Digit1_Data,Digit2_Data;
TRISB = 0; 							// PORT B pins are outputs
TRISD = 0; 							// PORT D output
Digit1_Enable = 0; 						// Disable Digit 1 to start with
Digit2_Enable = 0;						 // Disable Digit 2 to start with
for(;;) // DO FOREVER
{
Digit2_Data = Num / 10; 				// Extract Digit 2 data ,(4)
Digit1_Data = Num % 10; 				// Extract Digit 1 data , (5)

PORTB = Display_Segment(Digit1_Data); 	// Send LSD number (5) to port
Digit1_Enable = 1; 					// Enable Digit 1
Delay_Ms(5);						 // Wait 5ms
Digit1_Enable = 0; 					// Disable Digit 1

PORTB = Display_Segment(Digit2_Data); 	// Send MSD number (4) to port
Digit2_Enable = 1;					 // Enable Digit 2
Delay_Ms(5); 					// Wait 5ms
Digit2_Enable = 0;					 // Disable Digit 2
}
}