/*
UP Down Counter with Four 7-Segment Display Multiplexing
In this project four common anode 7-segment LED displays are connected to
PORTD of a PIC16F877A  * 4MHz .
Digit 1 (left digit) enable pin is connected to port pin RA0 ( Thousands)
and digit 2  enable pin is connected to port pin RA1 (Hundreds) .
and digit 3  enable pin is connected to port pin RA2 (Tens) .
and digit 4  enable pin is connected to port pin RA3 (Ones) .
The program counts up -down from buttons at RB0 , RB1 .
The display is updated in a timer interrupt service routine at every 5ms by :
Reload TMR0=100 & prescaler ration 1:32>> imer interrupt service routine at
 (255-100) *32us=5ms = scanning time
*/

#define Thous_Dig  PORTA.B0 //Thousands  unit
#define Hund_Dig  PORTA.B1//Hndreds unit
#define Tens_Dig PORTA.B2//Tens unit
#define Ones_Dig PORTA.B3//ones unit



//Global variable
unsigned char Count = 0;
unsigned char Flag = 0;
bit oldstate1;
bit oldstate2;

//-Function to Return mask for common anode 7-seg. display
unsigned short mask(unsigned short num) {
 switch (num) {
 case 0 : return 0xC0;
 case 1 : return 0xF9;
 case 2 : return 0xA4;
 case 3 : return 0xB0;
 case 4 : return 0x99;
 case 5 : return 0x92;
 case 6 : return 0x82;
 case 7 : return 0xF8;
 case 8 : return 0x80;
 case 9 : return 0x90;
 } //case end
}
// TMR0 timer interrupt service routine. The program jumps to the ISR at every 5ms.

void interrupt ()
{

//Local variable
unsigned char Thous_Seg,Hund_Seg,Tens_Seg, Ones_Seg;
TMR0 = 100; 				// Re-load TMR0>>255-100=155usx32(prescaler)=5ms
INTCON = 0x20; 				// >>>>Set T0IE and clear T0IF<<<<
if(Flag == 0) 				// Do digit 1
{
Ones_Dig = 1;
Tens_Dig = 1;
Hund_Dig = 1;
Thous_Seg = Count / 1000; 			// TENS_SEG >>tens
PORTD = mask(Thous_Seg); 			// Send to PORTD
Thous_Dig = 0; 				// Enable digit 1>>RA0
}
 else
if(Flag == 1) 				// Do digit 1
{
Ones_Dig = 1;
Tens_Dig = 1;
Thous_Dig = 1;

Hund_Seg = (Count / 100)%10; 			// TENS_SEG >>tens
PORTD = mask(hund_Seg); 			// Send to PORTD
Hund_Dig=0; 				// Enable digit 1>>RA0
}
else
if(Flag == 2) 				// Do digit 1
{
Ones_Dig = 1;
Hund_Dig = 1;
Thous_Dig = 1;
Tens_Seg = (Count / 10)%10; 			// TENS_SEG >>tens
PORTD = mask(Tens_Seg); 			// Send to PORTD
Tens_Dig=0; 				// Enable digit 1>>RA0
}

 else
if(Flag == 3) 				// Do digit 1
{
Tens_Dig = 1;
Hund_Dig = 1;
Thous_Dig = 1;

Ones_Seg = Count %10; 			// TENS_SEG >>tens
PORTD = mask(Ones_Seg); 			// Send to PORTD
Ones_Dig = 0; 				// Enable digit 1>>RA0
}

 Flag =Flag++;
if (Flag > 3)    Flag=0;

				// Toggle Flag as switch  , Counter


}
//
// Start of MAIN Program. configure PORTA and PORTD as outputs.
// In addition, configure TMR0 to interrupt at every 10ms
//
void main()
{
ADCON1=0X07;        		//set A PORT general I/O
TRISD= 0; 			// PORTD are outputs
PORTD=0XFF;
TRISA = 0; 			//  outputs
PORTA=0XFF;
TRISB=0XFF;
PORTB=0XFF;

// Configure TMR0 timer interrupt
OPTION_REG = 0xC4;	 	// Prescaler = 32
TMR0 = 100; 			// Load TMR0L with 100
INTCON = 0xA0; 			// Enable TMR0 interrupt

for(;;) // Endless loop
{

//UP Count
if (Button(&PORTB, 0, 1, 0)) {               		// Button 0 : Detect logical 0
      oldstate1 = 1;                              		// Update flag
    }
    if (oldstate1 && Button(&PORTB, 0, 1, 1)) {   	// Detect zero-to-one transition
        Count = Count +1;
        oldstate1 = 0;                                                 	// Update flag
    }
//DOWN Count
        if(Button(&PORTB,1,1,0)){		// Button 1 : Detect logical 0
        oldstate2 = 1;                              		// Update flag
}

          if (oldstate2 && Button(&PORTB, 1, 1, 1)) {   	// Detect zero-to-one transition
            Count = Count -1;
            oldstate2 = 0;                              		// Update flag
}

    if (Count > 9999)                 			// if it's more than 9999 go to 0;
   Count = 0;

}
}

T  = machine cycle * prescaler * count (65536 - TMR1H: TMR1L);
Machine cycle = 4 / Fosc;
Fosc  is the crystal oscillator clock frequency

Machine cycle = 4 / 20Mhz = 0.2us. T = 0.2 * 4 * 12500 = 10000us or 10ms.

Char count;
	
void  interrupt () { 
Count ++ ;       // for each TIMER1 interrupt increments the counting variable
TMR1L = 0x2C ;   // recharge the TMR1L;
TMR1H = 0xCF ;   // recharge the TMR1H;
PIR1.TMR1IF = 0 ;  // clear the overflow.
}
	
void  main () {
INTCON.GIE = 1 ; // enable global interruption;
INTCON.PEIE = 1 ; // enable interruption of peripherals;
PIE1.TMR1IE = 1 ; // enable interrupt of TIMER1;
// TMR1 receives the value 53036 (65536 - 12500), which in Hexadecimal is 0xCF2C
TMR1L = 0x2C ; // least significant byte
TMR1H = 0xCF ; // most significant byte
T1CON = 0b00100001 ; // Timer mode, prescaler 1: 4, internal clock;
while ( 1 ) {
if (count == 100 ) {     // when count = 100, that is, when time reaches
PORTB.RB0 = ~ PORTB.RB0 ; // 1s (100 * 10ms) reverses the state of portb, pin RB0.
}                     
	
}
}

T = machine cycle * prescaler * postscaler * PR2
Machine cycle = 4 / Fosc

Using a clock of 12Mhz, prescaler 1:16 and postscaler 1:16.
T = (4/12) * 16 * 16 * 255 = 21760us = 21.7ms

void  interrupt () {
PORTB .F1 = ~ PORTB .F1 ; // reverses the state of pin RB1
PIR1 .TMR2IF = 0 ; // clears the interrupt flag
}
	
void  main () {
INTCON .GIE = 1 ; // enable global interruption
INTCON .PEIE = 1 ; // enable interruption of peripherals
PIE1 .TMR2IE = 1 ; // enable interrupt of TIMER2
T2CON = 0b01111111 ; // Postcaler 1:16, TIMER2 on and prescaler 1:16;
TRISB .F1 = 0 ; // define pin RB1 as output
PORTB .F1 = 0 ; / Sets pin RB1 as initial state at low level
PR2 = 255 ; // sets the value for PR2
}

(4/8MHz) * prescaler * (255-96)
0.5 * 32 * 159 = 2544us = 2.544ms
2.544 * 400 times = 1 sec

unsigned cnt;                 	// Define variable cnt

void interrupt() {
    cnt++;                    	// Interrupt causes cnt to be incremented by 1
    TMR0 = 96;               	// Timer TMR0 is returned its initial value
    INTCON = 0x20;           	// Bit T0IE is set, bit T0IF is cleared
}

void main() {

    OPTION_REG = 0x84;         // Prescaler is assigned to timer TMR0
    TRISB = 0;               	// All port B pins are configured as outputs
    PORTB = 0x0;              	// Reset port B

    TMR0 = 96;                	// Timer T0 counts from 96 to 255
    INTCON = 0xA0;            	// Enable interrupt TMR0

    cnt = 0;                  	// Variable cnt is assigned a 0
    
    do {                      	// Endless loop

        if (cnt == 400) {    	// Increment port B after 400 interrupts
            PORTB = PORTB++;  	// Increment number on port B by 1
            cnt = 0;          	// Reset variable cnt
        }

    } while(1);
}

TMR1H = 0x80; // Set initial value for timer TMR1
TMR1L = 0x00;  // TMR1 = 32768
(4/8MHz) * prescaler * (65535 – 32768 ) 
0.5 * 1 * 32767 = 16383.5 us = 16.384 ms
16.384 ms * 76 times = 1.2 sec

unsigned short cnt; // Define variable cnt
void interrupt() {
cnt++ ; // Interrupt causes cnt to be incremented by 1
PIR1.TMR1IF = 0; // Reset bit TMR1IF
TMR1H = 0x80; // TMR1H and TMR1L timer registers are returned
TMR1L = 0x00; // their initial values
}
void main() {
PORTB = 0xF0; // Initial value of port B bits
TRISB = 0; // Port B pins are configured as outputs
T1CON = 1; // Set timer TMR1 , prescaler 1:1 
PIR1.TMR1IF = 0; // Reset bit TMR1IF
TMR1H = 0x80; // Set initial value for timer TMR1
TMR1L = 0x00;
PIE1.TMR1IE = 1; // Enable interrupt on overflow
cnt = 0; // Reset variable cnt
INTCON = 0xC0; // Enable interrupt (bits GIE and PEIE)
do { // Endless loop
if (cnt == 76) { // Change port B state after 76 interrupts
PORTB = ~PORTB; // Number in port B is inverted
cnt = 0; // Reset variable cnt
}
} while (1);
}

(4/Fosc) * prescaler * postscaler * PR2
(4/8MHz) * 16 * 16 * 255 = 32640 us = 32.640 ms 
32.640 * 30 times = 1 sec

unsigned short cnt; // Define variable cnt
void Replace() {
PORTB = ~PORTB; // Define new function ‘Replace’
} // Function inverts port state
void interrupt() {
if (PIR1.TMR2IF) { // If bit TMR2IF = 1,
cnt++ ; // Increment variable cnt by 1
PIR1.TMR2IF = 0;// Reset bit and
TMR2 = 0; // reset register TMR2
}
}
// main
void main() {
cnt = 0; // Reset variable cnt
PORTB = 0b10101010; // Logic state on port B pins
TRISB = 0; // All port B pins are configured as outputs
T2CON = 0xFF; // Set timer2, prescaler=16, postscaler=16,TMR2ON 
TMR2 = 0; // Initial value of timer register TMR2
PIE1.TMR2IE = 1; // Enable interrupt
INTCON = 0xC0; // Set bits GIE and PEIE
while (1) { // Endless loop
if (cnt > 30) { // Change PORTB after more than 30 interrupts
Replace(); // Function Replace inverts the port B state
cnt = 0; // Reset variable cnt
}
}
}

• Pwm1_Init
• Pwm1_ Set _Duty
• Pwm1_Start
• Pwm1_Stop

 Pwm1_Init (freq);

Pwm1_Init (4000) // بدء توليد إشارة بتعديل عرض النبضة بتردد 4 كيلوهرتز

PWM1_Set_Duty (duty_ratio);

PWM1_Set_ Duty (192); // تحديد دورة الخدمة بالقيمة 75 بالمئة

 (Percent * 255) / 100

 (10 * 255) / 100 = 25.5

 PWM1_Set_Duty(25);

 (50 * 255) / 100 = 127.50

PWM1_Set_Duty(127);

 (90 * 255) / 100 = 229.50

PWM1_Set_Duty(229);

 Pwm1_Start (); // initial signal generation module CCP1 PWM PIC
Pwm1_Stop (); / / stops the PWM signal generation module CCP1 PIC

void main () {
  
     Pwm1_init (5000);
     Pwm1_ Set_Duty (127);
     Pwm1_Start ();

     while (1);
}

void main() {
  
    Pwm2_init(5000);
    Pwm2_Set_Duty(127);
    Pwm2_Start();

    while(1);.
}

/*
Description: CCP module generating PWM
 MCU: PIC16F628A
 Oscillator: XT, 4.0 MHz
*/
 sbit UP at RB0_bit;
 sbit DOWN at RB1_bit;
 unsigned short new_DC, current_DC;

 void debounce(){
  Delay_ms(300);
 }

 void main() {
 CMCON = 0x07; // Disable comparators
 PORTB = 0x00; 
 TRISB = 0b00000011; // RB0, RB1 input, RB3 (PWM1) output
 PWM1_Init(5000);    // PWM module initialization (5KHz)
 new_DC = 0;         // Initial value of variable Duty Cycle
 current_DC = 0;
 PWM1_Start();       // Start PWM1 module with Zero DC
 PWM1_Set_Duty(current_DC);
 do {
  if (!UP){      // If the button connected to RB0 is pressed
   debounce();
   if (new_DC < 250)      // Don't go above 250
   new_DC = new_DC + 25 ; // increment Duty Cycle by 25
  }
  if (!DOWN) {   // If the button connected to RB1 is pressed
   debounce();
   if (new_DC !=0)        // Don't go below 0
   new_DC= new_DC - 25 ; // Decrement Duty Cycle by 25
  }
  if (current_DC != new_DC) {
   current_DC = new_DC ;
   PWM1_Set_Duty(current_DC); // Change the current DC to new value
  }
 } while(1);
}  // END main()

/*
************************************************ 
البرنامج : دخل تناظرى و تعديل فى عرض النبضة
الغرض : التحكم فى محرك مروحة عن طريق تعديل عرض النبضات من خلال دخل تناظرى
*/

void main () {

unsigned int a = 0; // تعريف متغير نوع عدد صحيح لحفظ نتيجة التحويل من تناظرى لرقمى  

ADCON1 = 0b00001001; // تهيئة طرف الدخل التناظرى  
TRISA = 255; // تهيئة أطراف المنفذ كمداخل 

Pwm_Init (5000); // تهيئة موديول تعديل عرض النبضة بتردد 5 كيلوهرتز 
Pwm_Start (); //بدء عمل موديول تعديل عرض النبضة  

do // حلقة غير منتهية 
 {
 a=Adc_Read(0); // قراءة القناة التناظرية صفر وحفظ قيمة نتيجة التحويل فى سجل مؤقت   
 a = (a / 4); // تحويل القيمة السابقة إلى نسبة مئوية لدورة الخدمة  
 Pwm_Set_Duty (a); //إرسال دورة الخدمة إلى موديول التحكم فى عرض النبضات لتظهر على طرف الخرج الخاص به  Delay_10us; // الانتظار لمدة 10 ميكروثانية 
}
   while (1); // التكرار بصفة مستمرة 

}

 
// Declaring Constants for sine wave.
 const unsigned short Sine_Wave [20] =
 {
 	127, 146, 163, 177, 185, 189, 185,
 	177, 163, 146, 127, 107, 90, 76,
 	68, 65, 68, 76, 90, 107
 };

 void main (void)
 {
 	// Declaration of variables.
	 unsigned short n = 0;
 	// Set the PWM module to Fpwm = 15.625K Hz
 	PWM1_Init (15625);
 	// Start of PWM signal.
 	PWM1_Start ();
 	while (1) 	// infinite loop.
 	{
 		// Loop for the 20 samples of a sine wave cycle.
 		for (n = 0; n <20; n ++)
 		{
			 // Changing the duty cycle of the PWM.
 			PWM1_Set_Duty (Sine_Wave [n]);
 			// Delay 50u sec.
 			delay_us (50);
 		}
 	}
 }