CCS/MSP430G2553: 4 Digit 7 Segment Clock

Hello all,

thank you for all replies!
I want to introduce a watch - working on MSP430G2553.

Electrical schematics:

#include <msp430.h>

#define a 0x01           //00 0000 0000 0001 segment A
#define b 0x02           //00 0000 0000 0010 segment B
#define c 0x04           //00 0000 0000 0100 segment C
#define d 0x08           //00 0000 0000 1000 segment D
#define e 0x10           //00 0000 0001 0000 segment E
#define f 0x20           //00 0000 0010 0000 segment F
#define g 0x40           //00 0000 0100 0000 segment G
#define DP     0x80      //00 0000 1000 0000 segment H - Dot Point

#define Dig_1  0x01   //P2.0 Common Anode
#define Dig_2  0x02   //P2.1 Common Anode
#define Dig_3  0x04   //P2.2 Common Anode
#define Dig_4  0x08   //P2.3 Common Anode

#define S1     0x10   //P2.4 Button 1
#define S2     0x20   //P2.5 Button 2

int display_min[]={a+b+c+d+e+f, b+c, a+b+d+e+g, a+b+c+d+g, b+c+f+g, a+c+d+f+g, a+c+d+e+f+g, a+b+c, a+b+c+d+e+f+g, a+b+c+d+f+g};
int display_hour[]={a+b+c+d+e+f, b+c, a+b+d+e+g, a+b+c+d+g, b+c+f+g, a+c+d+f+g, a+c+d+e+f+g, a+b+c, a+b+c+d+e+f+g, a+b+c+d+f+g};

//clock variables
volatile unsigned int j;
volatile unsigned int TI_second = 0;
volatile unsigned int TI_minute = 0;
volatile unsigned int TI_hour = 0;
volatile unsigned int dig_num = 0;
volatile unsigned int flag_dp = 0x01;
volatile unsigned int k = 0;
volatile unsigned int l = 0;

void Get_time(void)
{
    j++;
    if (j==10) flag_dp = 0;   // Clear DP after 0,5 second
    if (j==20)   //50mS * 20 = 1sec.
        {
            j=0;
            TI_second++;
            flag_dp = 1;   // Set DP for 0,5 second
        }
    if (TI_second==60)
        {
            TI_second = 0;
            TI_minute++;
        }
    if (TI_minute>=60)
        {
            TI_minute = 0;
            TI_hour++;
        }
    if (TI_hour>=24)
        {
            TI_hour = 0;
        }
}


void Display_time(void)
    {
      switch( dig_num )
      {
        case 0:
          {
            P1OUT = display_hour[TI_hour/10];    // First digit of hour set cathodes
            P1OUT &= ~DP;                        // Clear dot point here
            P2OUT |= BIT0;                       // First digit anode high
            P2OUT &= ~0x0E;                      // Other digit anodes low
            dig_num = 1;                         // goto next digit
          }
          break;

       case 1:
         {
            P1OUT = display_hour[TI_hour%10];    // Second digit of hour set cathodes
            P2OUT |= BIT1;                       // Second digit anode high
            P2OUT &= ~0x0D;                      // Other digit anodes low
                if(flag_dp == 1)                 // Every one second
                    {
                        P1OUT ^= DP;             // Set DP cathode
                    }
            dig_num = 2;                         // goto next digit
         }
         break;

      case 2:
        {
            P1OUT = display_min[TI_minute/10];   // First digit of minute set cathodes
            P1OUT &= ~DP;                        // Clear dot point here
            P2OUT |= BIT2;                       // Third digit anode high
            P2OUT &= ~0x0B;                      // Other digit anodes low
            dig_num = 3;                         // goto next digit
        }
        break;

      case 3:
        {
            P1OUT = display_min[TI_minute%10];    // Second digit of minute set cathodes
            P1OUT &= ~DP;                         // Clear dot point here
            P2OUT |= BIT3;                        // Fourth digit anode high
            P2OUT &= ~0x07;                       // Other digit anodes low
            dig_num = 0;                          // goto next digit (first)
        }
        break;
      }
    }

void Change_time(void)
{
if(!(P2IN&S1))       // If button S1 is pressed
    {
        k++;             // Increment k value
        if(k==2)         // Button S1 still pressed after 2 intervals
        {
        TI_hour++;   // Increment one hour
        Get_time();  // Update hour
        }
    }
if((P2IN&S1)) k=0;   // If button S1 is released

if(!(P2IN&S2))       // If button S1 is pressed
    {
        l++;             // Increment k value
        if(l==2)         // Button S1 still pressed after 2 intervals
        {
        TI_minute++; // Increment one hour
        Get_time();  // Update hour
        }
    }
    if((P2IN&S2)) l=0;   // If button S2 is released
    }

int main(void)
{
      //initialization
      WDTCTL = WDTPW + WDTHOLD;     // Stop watchdog timer
      BCSCTL1 = CALBC1_1MHZ;        // Set MCLK 1MHz
      DCOCTL = CALDCO_1MHZ;
      BCSCTL2 = SELM_0 | DIVM_0 | DIVS0; // Set SMCLK 1MHz

      //----Ports settings----------------------------------------------------------
      P1OUT = 0xFF;        // Set Port 1 pin HIGH
      P2OUT = 0xFF;        // Set Port 2 pin HIGH
      P1DIR = 0xFF;        // Set Port 1 as output
      P2DIR = 0x0F;        // Set Port 2 0-3 pins as output
      P2REN |= (S1+S2);    // Set resistor to VCC at S1 and S2

      //----TimerA settings---------------------------------------------------------
      TA0CCTL1 |= CCIE;                  // CCR0 interrupt enabled
      TA0CCTL2 |= CCIE;                  // CCR1 interrupt enabled
      TA0CTL = TASSEL_2 + MC_2 + TAIE;   // Source SMCLK, Continous Mode, Interrupt enabled
      TA0CCR0 = 50000;                   // not using but set
      TA0CCR1 =  25000;                  // 25000 in cont mode is 50 ms
      TA0CCR2 =  2500;                   // 2500  in cont mode is 5 ms

    //---Interrupts settings--------------------------------------------------------
      _EINT();                           // __enable_interrupts

    //---Variables settings---------------------------------------------------------
      dig_num = 0;                       // start from first digit

      while(1)      // infinity loop, timer will interrupt all
      {}
}

// Timer 0 A1 interrupt service routine
#pragma vector = TIMER0_A1_VECTOR
__interrupt void TIMER0_A1_ISR( void )
{
switch( TAIV )
    {
        case  2:     // CCR1
            {
                Get_time();          // update time
                TA0CCR1 += 25000;    // Add Offset to CCR1 50ms
                Change_time();       // function to set new time
            }
            break;

        case  4:    // CCR2
            {
                Display_time();   // refresh screen
                TA0CCR2 += 2500;  // Add offset 5ms ~50Hz

            }
            break;

        case 10:
        break;
      }
}

Now I will create temperature sensor with display, using seven segment LED Disp.

But I will not be editing this project.
Because - it works for 3 days and still showing good hour with battery.

I have other ideas and other uC. ;)

Thanks Chris,

Problem resolved!