4-Digit 7-Segment Counter with LiPo Backup

A large 4-digit 7-segment counter with LiPo backup, in case USB power is cut.

May 28, 2019

•

15036 views

•

8 respects

counter

4 digit 7 segment

Devices & Components

Arduino Uno Rev3

One Channel Relay Module Board Shield

General Purpose Transistor NPN

Battery, 3.7 V

Resistor 100 ohm

Adafruit Powerboost 500C

Resistor 10k ohm

Adafruit 4 Digit 7 Segment LED Display, 1.2" Yellow, Common Cathode

Project description

Code

arduino

You may need to reorder the PINs depending on how you wire it to the display.

1// counter button definition
2#define button       A0 // +1
3#define
4  button_minus A1 // -1
5#define button_10    A2 // +10
6#define button_100   A3
7  // +100
8#define button_reset A4 // reset
9
10// common pins of the four digits
11  definitions
12#define Dig1    2
13#define Dig2    3
14#define Dig3    4
15#define
16  Dig4    5
17// segment pin definitions
18#define SegA    6
19#define SegB    7
20#define
21  SegC    8
22#define SegD    9
23#define SegE    10
24#define SegF    11
25#define
26  SegG    12
27// A=10 : 
28
29// variable declarations
30byte current_digit;
31int
32  count = 0;
33 
34void setup()
35{
36  pinMode(button, INPUT_PULLUP);
37  pinMode(button_minus,
38  INPUT_PULLUP);
39  pinMode(button_10, INPUT_PULLUP);
40  pinMode(button_100, INPUT_PULLUP);
41
42  pinMode(button_reset, INPUT_PULLUP);
43  pinMode(SegA, OUTPUT);
44  pinMode(SegB,
45  OUTPUT);
46  pinMode(SegC, OUTPUT);
47  pinMode(SegD, OUTPUT);
48  pinMode(SegE,
49  OUTPUT);
50  pinMode(SegF, OUTPUT);
51  pinMode(SegG, OUTPUT);
52  pinMode(Dig1,
53  OUTPUT);
54  pinMode(Dig2, OUTPUT);
55  pinMode(Dig3, OUTPUT);
56  pinMode(Dig4,
57  OUTPUT);
58
59  disp_off();  // turn off the display
60
61  // Timer1 module
62  overflow interrupt configuration
63  TCCR1A = 0;
64  TCCR1B = 1;  // enable Timer1
65  with prescaler = 1 ( 16 ticks each 1 µs)
66  TCNT1  = 0;  // set Timer1 preload
67  value to 0 (reset)
68  TIMSK1 = 1;  // enable Timer1 overflow interrupt
69
70}
71
72ISR(TIMER1_OVF_vect)
73   // Timer1 interrupt service routine (ISR)
74{
75  disp_off();  // turn off
76  the display
77
78  switch (current_digit)
79  {
80    case 1:
81    if (count
82  >= 1000)
83    {
84      disp(count / 1000);   // prepare to display digit 1 (most
85  left)
86      digitalWrite(Dig1, HIGH);  // turn on digit 1
87    }
88      break;
89
90
91    case 2:
92    if (count >= 100)
93    {
94      disp( (count / 100) % 10);
95   // prepare to display digit 2
96      digitalWrite(Dig2, HIGH);     // turn
97  on digit 2
98    }
99      break;
100
101    case 3:
102    if (count >= 10)
103
104    {
105      disp( (count / 10) % 10);   // prepare to display digit 3
106      digitalWrite(Dig3,
107  HIGH);    // turn on digit 3
108    }
109      break;
110
111    case 4:
112      disp(count
113  % 10);   // prepare to display digit 4 (most right)
114      digitalWrite(Dig4,
115  HIGH);  // turn on digit 4
116  }
117
118  current_digit = (current_digit % 4) +
119  1;
120}
121
122// main loop
123void loop()
124{
125  if(digitalRead(button) == 0)
126
127  {
128    count++;  // increment 'count' by 1
129    if(count > 9999)
130      count
131  = 0;
132    delay(200);  // wait 200 milliseconds
133  }
134  else if(digitalRead(button_minus)
135  == 0)
136  {
137    count--;  // decrement 'count' by 1
138    if(count < 0)
139
140      count = 9999;
141    delay(200);  // wait 200 milliseconds
142  }
143  else
144  if(digitalRead(button_10) == 0)
145  {
146    count=count+10;  // increment by 10
147
148    if(count > 9999)
149      count = 0;
150    delay(200);  // wait 200 milliseconds
151
152  }
153  else if(digitalRead(button_100) == 0)
154  {
155    count=count+100;  //
156  increment by 100
157    if(count > 9999)
158      count = 0;
159    delay(200);
160  // wait 200 milliseconds
161  }
162  else if(digitalRead(button_reset) == 0)
163
164  {
165    count=0;  // reset
166    delay(200);  // wait 200 milliseconds
167  }
168}
169
170void
171  disp(byte number)
172{
173  switch (number)
174  {
175    case 0:  // print 0
176
177      digitalWrite(SegA, HIGH);
178      digitalWrite(SegB, HIGH);
179      digitalWrite(SegC,
180  HIGH);
181      digitalWrite(SegD, HIGH);
182      digitalWrite(SegE, HIGH);
183
184      digitalWrite(SegF, HIGH);
185      digitalWrite(SegG, LOW);
186      break;
187
188
189    case 1:  // print 1
190      digitalWrite(SegA, LOW);
191      digitalWrite(SegB,
192  HIGH);
193      digitalWrite(SegC, HIGH);
194      digitalWrite(SegD, LOW);
195
196      digitalWrite(SegE, LOW);
197      digitalWrite(SegF, LOW);
198      digitalWrite(SegG,
199  LOW);
200      break;
201
202    case 2:  // print 2
203      digitalWrite(SegA,
204  HIGH);
205      digitalWrite(SegB, HIGH);
206      digitalWrite(SegC, LOW);
207
208      digitalWrite(SegD, HIGH);
209      digitalWrite(SegE, HIGH);
210      digitalWrite(SegF,
211  LOW);
212      digitalWrite(SegG, HIGH);
213      break;
214
215    case 3:  //
216  print 3
217      digitalWrite(SegA, HIGH);
218      digitalWrite(SegB, HIGH);
219
220      digitalWrite(SegC, HIGH);
221      digitalWrite(SegD, HIGH);
222      digitalWrite(SegE,
223  LOW);
224      digitalWrite(SegF, LOW);
225      digitalWrite(SegG, HIGH);
226      break;
227
228
229    case 4:  // print 4
230      digitalWrite(SegA, LOW);
231      digitalWrite(SegB,
232  HIGH);
233      digitalWrite(SegC, HIGH);
234      digitalWrite(SegD, LOW);
235
236      digitalWrite(SegE, LOW);
237      digitalWrite(SegF, HIGH);
238      digitalWrite(SegG,
239  HIGH);
240      break;
241
242    case 5:  // print 5
243      digitalWrite(SegA,
244  HIGH);
245      digitalWrite(SegB, LOW);
246      digitalWrite(SegC, HIGH);
247
248      digitalWrite(SegD, HIGH);
249      digitalWrite(SegE, LOW);
250      digitalWrite(SegF,
251  HIGH);
252      digitalWrite(SegG, HIGH);
253      break;
254
255    case 6:  //
256  print 6
257      digitalWrite(SegA, HIGH);
258      digitalWrite(SegB, LOW);
259
260      digitalWrite(SegC, HIGH);
261      digitalWrite(SegD, HIGH);
262      digitalWrite(SegE,
263  HIGH);
264      digitalWrite(SegF, HIGH);
265      digitalWrite(SegG, HIGH);
266
267      break;
268
269    case 7:  // print 7
270      digitalWrite(SegA, HIGH);
271
272      digitalWrite(SegB, HIGH);
273      digitalWrite(SegC, HIGH);
274      digitalWrite(SegD,
275  LOW);
276      digitalWrite(SegE, LOW);
277      digitalWrite(SegF, LOW);
278      digitalWrite(SegG,
279  LOW);
280      break;
281
282    case 8:  // print 8
283      digitalWrite(SegA,
284  HIGH);
285      digitalWrite(SegB, HIGH);
286      digitalWrite(SegC, HIGH);
287
288      digitalWrite(SegD, HIGH);
289      digitalWrite(SegE, HIGH);
290      digitalWrite(SegF,
291  HIGH);
292      digitalWrite(SegG, HIGH);
293      break;
294
295    case 9:  //
296  print 9
297      digitalWrite(SegA, HIGH);
298      digitalWrite(SegB, HIGH);
299
300      digitalWrite(SegC, HIGH);
301      digitalWrite(SegD, HIGH);
302      digitalWrite(SegE,
303  LOW);
304      digitalWrite(SegF, HIGH);
305      digitalWrite(SegG, HIGH);
306
307  }
308}
309
310void disp_off()
311{
312   digitalWrite(Dig1, LOW);
313   digitalWrite(Dig2,
314  LOW);
315   digitalWrite(Dig3, LOW);
316   digitalWrite(Dig4, LOW);
317}
318
319//
320  end of code.
321

// counter button definition
#define button       A0 // +1
#define
  button_minus A1 // -1
#define button_10    A2 // +10
#define button_100   A3
  // +100
#define button_reset A4 // reset

// common pins of the four digits
  definitions
#define Dig1    2
#define Dig2    3
#define Dig3    4
#define
  Dig4    5
// segment pin definitions
#define SegA    6
#define SegB    7
#define
  SegC    8
#define SegD    9
#define SegE    10
#define SegF    11
#define
  SegG    12
// A=10 : 

// variable declarations
byte current_digit;
int
  count = 0;
 
void setup()
{
  pinMode(button, INPUT_PULLUP);
  pinMode(button_minus,
  INPUT_PULLUP);
  pinMode(button_10, INPUT_PULLUP);
  pinMode(button_100, INPUT_PULLUP);

  pinMode(button_reset, INPUT_PULLUP);
  pinMode(SegA, OUTPUT);
  pinMode(SegB,
  OUTPUT);
  pinMode(SegC, OUTPUT);
  pinMode(SegD, OUTPUT);
  pinMode(SegE,
  OUTPUT);
  pinMode(SegF, OUTPUT);
  pinMode(SegG, OUTPUT);
  pinMode(Dig1,
  OUTPUT);
  pinMode(Dig2, OUTPUT);
  pinMode(Dig3, OUTPUT);
  pinMode(Dig4,
  OUTPUT);

  disp_off();  // turn off the display

  // Timer1 module
  overflow interrupt configuration
  TCCR1A = 0;
  TCCR1B = 1;  // enable Timer1
  with prescaler = 1 ( 16 ticks each 1 µs)
  TCNT1  = 0;  // set Timer1 preload
  value to 0 (reset)
  TIMSK1 = 1;  // enable Timer1 overflow interrupt

}

ISR(TIMER1_OVF_vect)
   // Timer1 interrupt service routine (ISR)
{
  disp_off();  // turn off
  the display

  switch (current_digit)
  {
    case 1:
    if (count
  >= 1000)
    {
      disp(count / 1000);   // prepare to display digit 1 (most
  left)
      digitalWrite(Dig1, HIGH);  // turn on digit 1
    }
      break;


    case 2:
    if (count >= 100)
    {
      disp( (count / 100) % 10);
   // prepare to display digit 2
      digitalWrite(Dig2, HIGH);     // turn
  on digit 2
    }
      break;

    case 3:
    if (count >= 10)

    {
      disp( (count / 10) % 10);   // prepare to display digit 3
      digitalWrite(Dig3,
  HIGH);    // turn on digit 3
    }
      break;

    case 4:
      disp(count
  % 10);   // prepare to display digit 4 (most right)
      digitalWrite(Dig4,
  HIGH);  // turn on digit 4
  }

  current_digit = (current_digit % 4) +
  1;
}

// main loop
void loop()
{
  if(digitalRead(button) == 0)

  {
    count++;  // increment 'count' by 1
    if(count > 9999)
      count
  = 0;
    delay(200);  // wait 200 milliseconds
  }
  else if(digitalRead(button_minus)
  == 0)
  {
    count--;  // decrement 'count' by 1
    if(count < 0)

      count = 9999;
    delay(200);  // wait 200 milliseconds
  }
  else
  if(digitalRead(button_10) == 0)
  {
    count=count+10;  // increment by 10

    if(count > 9999)
      count = 0;
    delay(200);  // wait 200 milliseconds

  }
  else if(digitalRead(button_100) == 0)
  {
    count=count+100;  //
  increment by 100
    if(count > 9999)
      count = 0;
    delay(200);
  // wait 200 milliseconds
  }
  else if(digitalRead(button_reset) == 0)

  {
    count=0;  // reset
    delay(200);  // wait 200 milliseconds
  }
}

void
  disp(byte number)
{
  switch (number)
  {
    case 0:  // print 0

      digitalWrite(SegA, HIGH);
      digitalWrite(SegB, HIGH);
      digitalWrite(SegC,
  HIGH);
      digitalWrite(SegD, HIGH);
      digitalWrite(SegE, HIGH);

      digitalWrite(SegF, HIGH);
      digitalWrite(SegG, LOW);
      break;


    case 1:  // print 1
      digitalWrite(SegA, LOW);
      digitalWrite(SegB,
  HIGH);
      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, LOW);

      digitalWrite(SegE, LOW);
      digitalWrite(SegF, LOW);
      digitalWrite(SegG,
  LOW);
      break;

    case 2:  // print 2
      digitalWrite(SegA,
  HIGH);
      digitalWrite(SegB, HIGH);
      digitalWrite(SegC, LOW);

      digitalWrite(SegD, HIGH);
      digitalWrite(SegE, HIGH);
      digitalWrite(SegF,
  LOW);
      digitalWrite(SegG, HIGH);
      break;

    case 3:  //
  print 3
      digitalWrite(SegA, HIGH);
      digitalWrite(SegB, HIGH);

      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, HIGH);
      digitalWrite(SegE,
  LOW);
      digitalWrite(SegF, LOW);
      digitalWrite(SegG, HIGH);
      break;


    case 4:  // print 4
      digitalWrite(SegA, LOW);
      digitalWrite(SegB,
  HIGH);
      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, LOW);

      digitalWrite(SegE, LOW);
      digitalWrite(SegF, HIGH);
      digitalWrite(SegG,
  HIGH);
      break;

    case 5:  // print 5
      digitalWrite(SegA,
  HIGH);
      digitalWrite(SegB, LOW);
      digitalWrite(SegC, HIGH);

      digitalWrite(SegD, HIGH);
      digitalWrite(SegE, LOW);
      digitalWrite(SegF,
  HIGH);
      digitalWrite(SegG, HIGH);
      break;

    case 6:  //
  print 6
      digitalWrite(SegA, HIGH);
      digitalWrite(SegB, LOW);

      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, HIGH);
      digitalWrite(SegE,
  HIGH);
      digitalWrite(SegF, HIGH);
      digitalWrite(SegG, HIGH);

      break;

    case 7:  // print 7
      digitalWrite(SegA, HIGH);

      digitalWrite(SegB, HIGH);
      digitalWrite(SegC, HIGH);
      digitalWrite(SegD,
  LOW);
      digitalWrite(SegE, LOW);
      digitalWrite(SegF, LOW);
      digitalWrite(SegG,
  LOW);
      break;

    case 8:  // print 8
      digitalWrite(SegA,
  HIGH);
      digitalWrite(SegB, HIGH);
      digitalWrite(SegC, HIGH);

      digitalWrite(SegD, HIGH);
      digitalWrite(SegE, HIGH);
      digitalWrite(SegF,
  HIGH);
      digitalWrite(SegG, HIGH);
      break;

    case 9:  //
  print 9
      digitalWrite(SegA, HIGH);
      digitalWrite(SegB, HIGH);

      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, HIGH);
      digitalWrite(SegE,
  LOW);
      digitalWrite(SegF, HIGH);
      digitalWrite(SegG, HIGH);

  }
}

void disp_off()
{
   digitalWrite(Dig1, LOW);
   digitalWrite(Dig2,
  LOW);
   digitalWrite(Dig3, LOW);
   digitalWrite(Dig4, LOW);
}

//
  end of code.

Code

arduino

You may need to reorder the PINs depending on how you wire it to the display.

1// counter button definition
2#define button       A0 // +1
3#define  button_minus A1 // -1
4#define button_10    A2 // +10
5#define button_100   A3  // +100
6#define button_reset A4 // reset
7
8// common pins of the four digits  definitions
9#define Dig1    2
10#define Dig2    3
11#define Dig3    4
12#define  Dig4    5
13// segment pin definitions
14#define SegA    6
15#define SegB    7
16#define  SegC    8
17#define SegD    9
18#define SegE    10
19#define SegF    11
20#define  SegG    12
21// A=10 : 
22
23// variable declarations
24byte current_digit;
25int  count = 0;
26 
27void setup()
28{
29  pinMode(button, INPUT_PULLUP);
30  pinMode(button_minus,  INPUT_PULLUP);
31  pinMode(button_10, INPUT_PULLUP);
32  pinMode(button_100, INPUT_PULLUP);
33  pinMode(button_reset, INPUT_PULLUP);
34  pinMode(SegA, OUTPUT);
35  pinMode(SegB,  OUTPUT);
36  pinMode(SegC, OUTPUT);
37  pinMode(SegD, OUTPUT);
38  pinMode(SegE,  OUTPUT);
39  pinMode(SegF, OUTPUT);
40  pinMode(SegG, OUTPUT);
41  pinMode(Dig1,  OUTPUT);
42  pinMode(Dig2, OUTPUT);
43  pinMode(Dig3, OUTPUT);
44  pinMode(Dig4,  OUTPUT);
45
46  disp_off();  // turn off the display
47
48  // Timer1 module  overflow interrupt configuration
49  TCCR1A = 0;
50  TCCR1B = 1;  // enable Timer1  with prescaler = 1 ( 16 ticks each 1 µs)
51  TCNT1  = 0;  // set Timer1 preload  value to 0 (reset)
52  TIMSK1 = 1;  // enable Timer1 overflow interrupt
53
54}
55
56ISR(TIMER1_OVF_vect)   // Timer1 interrupt service routine (ISR)
57{
58  disp_off();  // turn off  the display
59
60  switch (current_digit)
61  {
62    case 1:
63    if (count  >= 1000)
64    {
65      disp(count / 1000);   // prepare to display digit 1 (most  left)
66      digitalWrite(Dig1, HIGH);  // turn on digit 1
67    }
68      break;
69
70    case 2:
71    if (count >= 100)
72    {
73      disp( (count / 100) % 10);   // prepare to display digit 2
74      digitalWrite(Dig2, HIGH);     // turn  on digit 2
75    }
76      break;
77
78    case 3:
79    if (count >= 10)
80    {
81      disp( (count / 10) % 10);   // prepare to display digit 3
82      digitalWrite(Dig3,  HIGH);    // turn on digit 3
83    }
84      break;
85
86    case 4:
87      disp(count  % 10);   // prepare to display digit 4 (most right)
88      digitalWrite(Dig4,  HIGH);  // turn on digit 4
89  }
90
91  current_digit = (current_digit % 4) +  1;
92}
93
94// main loop
95void loop()
96{
97  if(digitalRead(button) == 0)
98  {
99    count++;  // increment 'count' by 1
100    if(count > 9999)
101      count  = 0;
102    delay(200);  // wait 200 milliseconds
103  }
104  else if(digitalRead(button_minus)  == 0)
105  {
106    count--;  // decrement 'count' by 1
107    if(count < 0)
108      count = 9999;
109    delay(200);  // wait 200 milliseconds
110  }
111  else  if(digitalRead(button_10) == 0)
112  {
113    count=count+10;  // increment by 10
114    if(count > 9999)
115      count = 0;
116    delay(200);  // wait 200 milliseconds
117  }
118  else if(digitalRead(button_100) == 0)
119  {
120    count=count+100;  //  increment by 100
121    if(count > 9999)
122      count = 0;
123    delay(200);  // wait 200 milliseconds
124  }
125  else if(digitalRead(button_reset) == 0)
126  {
127    count=0;  // reset
128    delay(200);  // wait 200 milliseconds
129  }
130}
131
132void  disp(byte number)
133{
134  switch (number)
135  {
136    case 0:  // print 0
137      digitalWrite(SegA, HIGH);
138      digitalWrite(SegB, HIGH);
139      digitalWrite(SegC,  HIGH);
140      digitalWrite(SegD, HIGH);
141      digitalWrite(SegE, HIGH);
142      digitalWrite(SegF, HIGH);
143      digitalWrite(SegG, LOW);
144      break;
145
146    case 1:  // print 1
147      digitalWrite(SegA, LOW);
148      digitalWrite(SegB,  HIGH);
149      digitalWrite(SegC, HIGH);
150      digitalWrite(SegD, LOW);
151      digitalWrite(SegE, LOW);
152      digitalWrite(SegF, LOW);
153      digitalWrite(SegG,  LOW);
154      break;
155
156    case 2:  // print 2
157      digitalWrite(SegA,  HIGH);
158      digitalWrite(SegB, HIGH);
159      digitalWrite(SegC, LOW);
160      digitalWrite(SegD, HIGH);
161      digitalWrite(SegE, HIGH);
162      digitalWrite(SegF,  LOW);
163      digitalWrite(SegG, HIGH);
164      break;
165
166    case 3:  //  print 3
167      digitalWrite(SegA, HIGH);
168      digitalWrite(SegB, HIGH);
169      digitalWrite(SegC, HIGH);
170      digitalWrite(SegD, HIGH);
171      digitalWrite(SegE,  LOW);
172      digitalWrite(SegF, LOW);
173      digitalWrite(SegG, HIGH);
174      break;
175
176    case 4:  // print 4
177      digitalWrite(SegA, LOW);
178      digitalWrite(SegB,  HIGH);
179      digitalWrite(SegC, HIGH);
180      digitalWrite(SegD, LOW);
181      digitalWrite(SegE, LOW);
182      digitalWrite(SegF, HIGH);
183      digitalWrite(SegG,  HIGH);
184      break;
185
186    case 5:  // print 5
187      digitalWrite(SegA,  HIGH);
188      digitalWrite(SegB, LOW);
189      digitalWrite(SegC, HIGH);
190      digitalWrite(SegD, HIGH);
191      digitalWrite(SegE, LOW);
192      digitalWrite(SegF,  HIGH);
193      digitalWrite(SegG, HIGH);
194      break;
195
196    case 6:  //  print 6
197      digitalWrite(SegA, HIGH);
198      digitalWrite(SegB, LOW);
199      digitalWrite(SegC, HIGH);
200      digitalWrite(SegD, HIGH);
201      digitalWrite(SegE,  HIGH);
202      digitalWrite(SegF, HIGH);
203      digitalWrite(SegG, HIGH);
204      break;
205
206    case 7:  // print 7
207      digitalWrite(SegA, HIGH);
208      digitalWrite(SegB, HIGH);
209      digitalWrite(SegC, HIGH);
210      digitalWrite(SegD,  LOW);
211      digitalWrite(SegE, LOW);
212      digitalWrite(SegF, LOW);
213      digitalWrite(SegG,  LOW);
214      break;
215
216    case 8:  // print 8
217      digitalWrite(SegA,  HIGH);
218      digitalWrite(SegB, HIGH);
219      digitalWrite(SegC, HIGH);
220      digitalWrite(SegD, HIGH);
221      digitalWrite(SegE, HIGH);
222      digitalWrite(SegF,  HIGH);
223      digitalWrite(SegG, HIGH);
224      break;
225
226    case 9:  //  print 9
227      digitalWrite(SegA, HIGH);
228      digitalWrite(SegB, HIGH);
229      digitalWrite(SegC, HIGH);
230      digitalWrite(SegD, HIGH);
231      digitalWrite(SegE,  LOW);
232      digitalWrite(SegF, HIGH);
233      digitalWrite(SegG, HIGH);
234  }
235}
236
237void disp_off()
238{
239   digitalWrite(Dig1, LOW);
240   digitalWrite(Dig2,  LOW);
241   digitalWrite(Dig3, LOW);
242   digitalWrite(Dig4, LOW);
243}
244
245//  end of code.
246

// counter button definition
#define button       A0 // +1
#define  button_minus A1 // -1
#define button_10    A2 // +10
#define button_100   A3  // +100
#define button_reset A4 // reset

// common pins of the four digits  definitions
#define Dig1    2
#define Dig2    3
#define Dig3    4
#define  Dig4    5
// segment pin definitions
#define SegA    6
#define SegB    7
#define  SegC    8
#define SegD    9
#define SegE    10
#define SegF    11
#define  SegG    12
// A=10 : 

// variable declarations
byte current_digit;
int  count = 0;
 
void setup()
{
  pinMode(button, INPUT_PULLUP);
  pinMode(button_minus,  INPUT_PULLUP);
  pinMode(button_10, INPUT_PULLUP);
  pinMode(button_100, INPUT_PULLUP);
  pinMode(button_reset, INPUT_PULLUP);
  pinMode(SegA, OUTPUT);
  pinMode(SegB,  OUTPUT);
  pinMode(SegC, OUTPUT);
  pinMode(SegD, OUTPUT);
  pinMode(SegE,  OUTPUT);
  pinMode(SegF, OUTPUT);
  pinMode(SegG, OUTPUT);
  pinMode(Dig1,  OUTPUT);
  pinMode(Dig2, OUTPUT);
  pinMode(Dig3, OUTPUT);
  pinMode(Dig4,  OUTPUT);

  disp_off();  // turn off the display

  // Timer1 module  overflow interrupt configuration
  TCCR1A = 0;
  TCCR1B = 1;  // enable Timer1  with prescaler = 1 ( 16 ticks each 1 µs)
  TCNT1  = 0;  // set Timer1 preload  value to 0 (reset)
  TIMSK1 = 1;  // enable Timer1 overflow interrupt

}

ISR(TIMER1_OVF_vect)   // Timer1 interrupt service routine (ISR)
{
  disp_off();  // turn off  the display

  switch (current_digit)
  {
    case 1:
    if (count  >= 1000)
    {
      disp(count / 1000);   // prepare to display digit 1 (most  left)
      digitalWrite(Dig1, HIGH);  // turn on digit 1
    }
      break;

    case 2:
    if (count >= 100)
    {
      disp( (count / 100) % 10);   // prepare to display digit 2
      digitalWrite(Dig2, HIGH);     // turn  on digit 2
    }
      break;

    case 3:
    if (count >= 10)
    {
      disp( (count / 10) % 10);   // prepare to display digit 3
      digitalWrite(Dig3,  HIGH);    // turn on digit 3
    }
      break;

    case 4:
      disp(count  % 10);   // prepare to display digit 4 (most right)
      digitalWrite(Dig4,  HIGH);  // turn on digit 4
  }

  current_digit = (current_digit % 4) +  1;
}

// main loop
void loop()
{
  if(digitalRead(button) == 0)
  {
    count++;  // increment 'count' by 1
    if(count > 9999)
      count  = 0;
    delay(200);  // wait 200 milliseconds
  }
  else if(digitalRead(button_minus)  == 0)
  {
    count--;  // decrement 'count' by 1
    if(count < 0)
      count = 9999;
    delay(200);  // wait 200 milliseconds
  }
  else  if(digitalRead(button_10) == 0)
  {
    count=count+10;  // increment by 10
    if(count > 9999)
      count = 0;
    delay(200);  // wait 200 milliseconds
  }
  else if(digitalRead(button_100) == 0)
  {
    count=count+100;  //  increment by 100
    if(count > 9999)
      count = 0;
    delay(200);  // wait 200 milliseconds
  }
  else if(digitalRead(button_reset) == 0)
  {
    count=0;  // reset
    delay(200);  // wait 200 milliseconds
  }
}

void  disp(byte number)
{
  switch (number)
  {
    case 0:  // print 0
      digitalWrite(SegA, HIGH);
      digitalWrite(SegB, HIGH);
      digitalWrite(SegC,  HIGH);
      digitalWrite(SegD, HIGH);
      digitalWrite(SegE, HIGH);
      digitalWrite(SegF, HIGH);
      digitalWrite(SegG, LOW);
      break;

    case 1:  // print 1
      digitalWrite(SegA, LOW);
      digitalWrite(SegB,  HIGH);
      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, LOW);
      digitalWrite(SegE, LOW);
      digitalWrite(SegF, LOW);
      digitalWrite(SegG,  LOW);
      break;

    case 2:  // print 2
      digitalWrite(SegA,  HIGH);
      digitalWrite(SegB, HIGH);
      digitalWrite(SegC, LOW);
      digitalWrite(SegD, HIGH);
      digitalWrite(SegE, HIGH);
      digitalWrite(SegF,  LOW);
      digitalWrite(SegG, HIGH);
      break;

    case 3:  //  print 3
      digitalWrite(SegA, HIGH);
      digitalWrite(SegB, HIGH);
      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, HIGH);
      digitalWrite(SegE,  LOW);
      digitalWrite(SegF, LOW);
      digitalWrite(SegG, HIGH);
      break;

    case 4:  // print 4
      digitalWrite(SegA, LOW);
      digitalWrite(SegB,  HIGH);
      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, LOW);
      digitalWrite(SegE, LOW);
      digitalWrite(SegF, HIGH);
      digitalWrite(SegG,  HIGH);
      break;

    case 5:  // print 5
      digitalWrite(SegA,  HIGH);
      digitalWrite(SegB, LOW);
      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, HIGH);
      digitalWrite(SegE, LOW);
      digitalWrite(SegF,  HIGH);
      digitalWrite(SegG, HIGH);
      break;

    case 6:  //  print 6
      digitalWrite(SegA, HIGH);
      digitalWrite(SegB, LOW);
      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, HIGH);
      digitalWrite(SegE,  HIGH);
      digitalWrite(SegF, HIGH);
      digitalWrite(SegG, HIGH);
      break;

    case 7:  // print 7
      digitalWrite(SegA, HIGH);
      digitalWrite(SegB, HIGH);
      digitalWrite(SegC, HIGH);
      digitalWrite(SegD,  LOW);
      digitalWrite(SegE, LOW);
      digitalWrite(SegF, LOW);
      digitalWrite(SegG,  LOW);
      break;

    case 8:  // print 8
      digitalWrite(SegA,  HIGH);
      digitalWrite(SegB, HIGH);
      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, HIGH);
      digitalWrite(SegE, HIGH);
      digitalWrite(SegF,  HIGH);
      digitalWrite(SegG, HIGH);
      break;

    case 9:  //  print 9
      digitalWrite(SegA, HIGH);
      digitalWrite(SegB, HIGH);
      digitalWrite(SegC, HIGH);
      digitalWrite(SegD, HIGH);
      digitalWrite(SegE,  LOW);
      digitalWrite(SegF, HIGH);
      digitalWrite(SegG, HIGH);
  }
}

void disp_off()
{
   digitalWrite(Dig1, LOW);
   digitalWrite(Dig2,  LOW);
   digitalWrite(Dig3, LOW);
   digitalWrite(Dig4, LOW);
}

//  end of code.

Downloadable files

Fritzing

Comments

Only logged in users can leave comments

Ratti3

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content