Hjälp med nedräkning med arduino på 7-segment

[Jonaz]

Jag behöver lite hjälp med en nedräkningstimer från 7:59 min ner till noll och sedan starta om igen.
Det är uppdelat i tre st segment, min, tiotal och sekunder.
Har inte tillgång till något shiftregister för tillfället, antar att det hade varit den enklaste lösningen?
Kod som jag provade lite med.

Kod: Markera allt

void loop() {
// Segment 1 Skriv 7
 digitalWrite(0,1);
 digitalWrite(1, 1);
 digitalWrite(2, 0);
 digitalWrite(3, 0);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 0);
  
// Segment 2 skriv 5
 digitalWrite(10, 0);
 digitalWrite(13, 0);
 digitalWrite(11, 0);
 digitalWrite(12, 1);
 digitalWrite(7,  1);
 digitalWrite(8,  0);
 digitalWrite(9,  0);

// Segment 3 Skriv  9
 digitalWrite(24, 0);
 digitalWrite(25,  0);
 digitalWrite(18,  0);
 digitalWrite(19,  0);
 digitalWrite(20, 1);
 digitalWrite(21, 1);
 digitalWrite(22, 0);
 
delay(1000);

// Segment 3 Skriv 8
 digitalWrite(24, 0);
 digitalWrite(25, 0);
 digitalWrite(18, 0);
 digitalWrite(19, 0);
 digitalWrite(20,0);
 digitalWrite(21,0);
 digitalWrite(22,0);
 
delay(1000);

Och så vidare ner till noll....

 

Men det blir kod på typ över 50 000 byte hela vägen ner till noll, det måste ju finnas ett effektivare sätt utan shiftregister,och med så lite kring komponenter som möjligt.

Är det någon som har lite tips?
Har googlat runt lite halv snabbt men inte hittat något matnyttigt.

[Glenn]

En uppenbar sak är ju att använda en drivkrets för 7segmentdisplayer som tar typ BCD in och 7segment ut, sen kan du multiplexa det över dina siffror också om du vill det.

Sen kan jag inte mycket om arduinons bastardiserade programmeringsspråk, men använder du subrutiner/funktioner över huvud taget ? om du menar att du inte gör det så förstår jag att det blir många kodrader ..Sen antar jag att digitalwrite skriver enstaka bitar ? ..varför inte skriva hela byten på en gång så blir det en rad istället, tycker du det blir svårläst borde du kunna ange det binärt (utgår ifrån att det fungerar med aurdinospråket också.)

Förstår jag dej rätt om du helt enkelt kopplat alla segmenten till varsin iopinne rakt av ? 28 iopinnar ? det funkar väl iofs, men blir tämligen opraktiskt av flera skäl.

[Icecap]

Och delay() är inte korrekt sätt att köra tid på! Tiden det tar att slå och av resten läggs ju till...

Men OK, grunden i funktionen är att räkna ner.

Då brukar jag ha en variabel som laddas till ett visst värde. I detta fall blir värdet 480 vilket motsvarar 8:00 i sekunder. Variablen kallas Time.

Detta ska sedan visas på displayen, siffer för siffer. Detta kan göras på många sätt men ett är såhär:
Minuter = Time / 60.
Sekunder10 = (Time / 10) % 10.
Sekunder01 = Time % 10.

Dessa värden visas sedan på varje display och behövs det ett bitmönster för att göra detta använder jag en (eller fler) uppslagstabell(er) som har bitmönster för siffrorna 0-9.

Så i grunden skulle mitt program se ut såhär i pseudokod:
Start:
Time = 480;
While Time

Visa siffrorna enl. ovanstående

Delay(1000); //Väldigt fel sätt men just nu får det duga
Time = Time - 1;

While-end
Goto Start.

[Krille Krokodil]

Precis som skrivits ovan så är väl det första logiska steget att göra funktioner för att skriva ut siffrorna på displayen och gömma undan pinnar och bits så man slipper se det, i enklaste form:

byte UppslagSegment1[] = {B00100100, ...};

void SkrivSegment1(int Siffra){
digitalWrite(0, UppslagSegment1[Siffra] && B00000001);
digitalWrite(1, UppslagSegment1[Siffra] && B00000010);
...
}

Så något åt detta hållet i slutändan:

void Loop(){

int Counter = 480;

while(Counter > 0){
SkrivSegment1(IcecapMinuter(Counter));
SkrivSegment2(IcecapSekunder10(Counter));
SkrivSegment3(IcecapSekunder01(Counter));
Counter--;
Delay(1000);
}
}

[Icecap]

Hade ett projekt som använde just 7-segment som display. För att göra det enkelt för mig gjorde jag såhär:

Kod: Markera allt

//  AAA
// F   B
// F   B
// F   B
//  GGG
// E   C
// E   C
// E   C
//  DDD DP

// A '0' turns on the segment <- OBS!!!
#define SEG_A   0xDF // 11011111
#define SEG_B   0xEF // 11101111
#define SEG_C   0x7F // 01111111
#define SEG_D   0xFD // 11111101
#define SEG_E   0xFB // 11111011
#define SEG_F   0xF7 // 11110111
#define SEG_G   0xBF // 10111111
#define SEG_DP  0xFE // 11111110
#define SEG_OFF 0xFF // 11111111

#define DSP_DEF_0  (SEG_A & SEG_B & SEG_C & SEG_D & SEG_E & SEG_F)                  // '0'
#define DSP_DEF_1  (        SEG_B & SEG_C)                                          // '1'
#define DSP_DEF_2  (SEG_A & SEG_B &         SEG_D & SEG_E &         SEG_G)          // '2'
#define DSP_DEF_3  (SEG_A & SEG_B & SEG_C & SEG_D &                 SEG_G)          // '3'
#define DSP_DEF_4  (        SEG_B & SEG_C &                 SEG_F & SEG_G)          // '4'
#define DSP_DEF_5  (SEG_A &         SEG_C & SEG_D &         SEG_F & SEG_G)          // '5'
#define DSP_DEF_6  (SEG_A &         SEG_C & SEG_D & SEG_E & SEG_F & SEG_G)          // '6'
#define DSP_DEF_7  (SEG_A & SEG_B & SEG_C)                                          // '7'
#define DSP_DEF_8  (SEG_A & SEG_B & SEG_C & SEG_D & SEG_E & SEG_F & SEG_G)          // '8'
#define DSP_DEF_9  (SEG_A & SEG_B & SEG_C & SEG_D &         SEG_F & SEG_G)          // '9'
#define DSP_DEF_SP (SEG_OFF)                                                        // ' '

//==================== Constants ====================

const BYTE Display_Digit_Pattern[] = {DSP_DEF_0, DSP_DEF_1, DSP_DEF_2, DSP_DEF_3, DSP_DEF_4, DSP_DEF_5, DSP_DEF_6, DSP_DEF_7, DSP_DEF_8, DSP_DEF_9}; // '9'

Då kunde jag enkelt definiera vilka segment som hade vilka värden och resten föll på plats med detta.

Alltså är det så enkelt att välja siffra som BitPattern = Display_Digit_Pattern[Value];

[Krille Krokodil]

Vill man komma ifrån det tidsfelet med delay som Icecap nämnde så kan man använda den här funktionen:

millis()

Returns the number of milliseconds since the Arduino board began running the current program. This number will overflow (go back to zero), after approximately 50 days.

[Krille Krokodil]

Fick ett litet uppdrag på en 8 timmar nedräknare...

Använder systemklockan med millis() för att räkna ut aktuell tid och uppdaterar sedan displayen i ungefär 25 Hz. Det skall in en enkel switch-sats sedan i loopen som tänder och släcker lite saker vid bestämda tider.

Kod: Markera allt

  unsigned int   CountdownTime = 8 * 60 * 60; //Number of seconds to countdown.
  unsigned long  StartTime; // To store first system clock read.  
  unsigned int   ElapsedTime = 0; // Seconds elapsed since first system clock read.

  DrawTime(CountdownTime);
  delay(5000);

  StartTime = millis();
  
  while(ElapsedTime < CountdownTime){
    if((millis() - StartTime) / 1000 > ElapsedTime){
      
      ElapsedTime++;
      DrawTime(CountdownTime - ElapsedTime);
    
    }
    delay(40);
  }

Tiden visas på en grafisk display 128x32.

Kod: Markera allt

void DrawTime(int Time){
  // Converts seconds to T:MM:SS and draws it on the display. 
  
  byte Hours = Time / 3600;
  byte Minutes10 = (Time - Hours * 3600) / 600;
  byte Minutes1 = (Time - Hours * 3600 - Minutes10 * 600) / 60;
  byte Seconds10 = (Time - Hours * 3600 - Minutes10 * 600 - Minutes1 * 60) / 10; 
  byte Seconds1 = Time % 10;
  
  display.clearDisplay();
  
  DrawNumber(1, Hours); 
  
  display.drawBitmap(25, 4,  CharColon, 9, 25, 1);
  
  DrawNumber(2, Minutes10); 
  DrawNumber(3, Minutes1); 
  
  display.drawBitmap(75, 4,  CharColon, 9, 25, 1);
  
  DrawNumber(4, Seconds10); 
  DrawNumber(5, Seconds1); 
  
  display.display();

};

[Jonaz]

Tack för svaren!

Fick nästan till det tillslut.
Koden i sin helhet.

Kod: Markera allt

int led4k1 =  0;
int led4k2 =  1;
int led4k3 =  2;
int led4k4 =  3;
int led4k5 =  4;
int led4k6 =  5;
int led4k7 =  6;

int led3k1 =   10;
int led3k2 =  13;
int led3k3 =  11;
int led3k4 =  12;
int led3k5 =  7;
int led3k6 =  8;
int led3k7 =   9;


int led2k1 =  24;
int led2k2 =  25;
int led2k3 =  18;
int led2k4 =  19;
int led2k5 =  20;
int led2k6 =  21;
int led2k7 =  22;
int led2k8 =  23;

int num = 0;
int num2 = 0;
int num3 = 8;
//int button = 0;
void setup()   {
 pinMode(led4k1, OUTPUT);
   pinMode(led4k2, OUTPUT);
    pinMode(led4k3, OUTPUT);
     pinMode(led4k4, OUTPUT);
	pinMode(led4k5, OUTPUT);
	 pinMode(led4k6, OUTPUT);
	  pinMode(led4k7, OUTPUT);
   pinMode(led3k1, OUTPUT);
   pinMode(led3k2, OUTPUT);
    pinMode(led3k3, OUTPUT);
     pinMode(led3k4, OUTPUT);
	pinMode(led3k5, OUTPUT);
	 pinMode(led3k6, OUTPUT);
	  pinMode(led3k7, OUTPUT);
   pinMode(led2k1, OUTPUT);
   pinMode(led2k2, OUTPUT);
    pinMode(led2k3, OUTPUT);
     pinMode(led2k4, OUTPUT);
	pinMode(led2k5, OUTPUT);
	 pinMode(led2k6, OUTPUT);
	  pinMode(led2k7, OUTPUT);
	   pinMode(led2k8, OUTPUT);

}
void loop()
{
	switch (num) {
  case 0:
 digitalWrite(led2k1, HIGH);
 digitalWrite(led2k2, LOW);
 digitalWrite(led2k3, LOW);
 digitalWrite(led2k4, LOW);
 digitalWrite(led2k5, LOW);
digitalWrite(led2k6, LOW);
digitalWrite(led2k7, LOW); 
digitalWrite(led2k8, LOW   );
break;
case -1:
 digitalWrite(led2k1, HIGH);
 digitalWrite(led2k2, LOW);
 digitalWrite(led2k3, LOW);
 digitalWrite(led2k4, LOW);
 digitalWrite(led2k5, LOW);
digitalWrite(led2k6, LOW);
digitalWrite(led2k7, LOW);  
 digitalWrite(led2k8, LOW   );  
    break;
  case 1:
   digitalWrite(led2k1, HIGH);
 digitalWrite(led2k2,   HIGH);
 digitalWrite(led2k3,   HIGH);
 digitalWrite(led2k4,   LOW);
 digitalWrite(led2k5,   HIGH);
digitalWrite(led2k6,    HIGH);
digitalWrite(led2k7,     LOW);
digitalWrite(led2k8, HIGH   );
    break;
  case 2:
  digitalWrite(led2k1, LOW);  
  digitalWrite(led2k2, HIGH);
 digitalWrite(led2k3,  LOW);
 digitalWrite(led2k4,  LOW);
 digitalWrite(led2k5,  LOW);
digitalWrite(led2k6,   LOW);
digitalWrite(led2k7,   HIGH);
digitalWrite(led2k8,  LOW  );  
    break;
  case 3:
  digitalWrite(led2k1, LOW);
 digitalWrite(led2k2,  HIGH);
 digitalWrite(led2k3,  LOW);
 digitalWrite(led2k4,  LOW);
 digitalWrite(led2k5,  HIGH);
digitalWrite(led2k6,   LOW);
digitalWrite(led2k7,    LOW);
digitalWrite(led2k8,  HIGH  );
    break;
	case 4:
  digitalWrite(led2k1, LOW);
 digitalWrite(led2k2,  LOW);
 digitalWrite(led2k3,  HIGH);
 digitalWrite(led2k4,  LOW);
 digitalWrite(led2k5,  HIGH);
digitalWrite(led2k6,   HIGH);
digitalWrite(led2k7,    LOW);
digitalWrite(led2k8,  LOW  );
    break;
	case 5:
  digitalWrite(led2k1,   LOW);
 digitalWrite(led2k2,   LOW);
 digitalWrite(led2k3,   LOW);
 digitalWrite(led2k4,   HIGH);
 digitalWrite(led2k5,   HIGH);
digitalWrite(led2k6,    LOW);
digitalWrite(led2k7,     LOW);
digitalWrite(led2k8,  HIGH  );
    break;
	case 6:
  digitalWrite(led2k1, LOW);
 digitalWrite(led2k2,   LOW);
 digitalWrite(led2k3,   HIGH);
 digitalWrite(led2k4,   HIGH);
 digitalWrite(led2k5,   LOW);
digitalWrite(led2k6,     LOW);
digitalWrite(led2k7,     LOW);
digitalWrite(led2k8,  LOW  );
    break;
	case 7:
  digitalWrite(led2k1, HIGH);
 digitalWrite(led2k2, HIGH);
 digitalWrite(led2k3, LOW);
 digitalWrite(led2k4, LOW);
 digitalWrite(led2k5, HIGH);
digitalWrite(led2k6,   HIGH);
digitalWrite(led2k7,    LOW);
digitalWrite(led2k8,  HIGH  );
    break;
	case 8:
  digitalWrite(led2k1, LOW);
 digitalWrite(led2k2,  LOW);
 digitalWrite(led2k3,   LOW);
 digitalWrite(led2k4,  LOW);
 digitalWrite(led2k5,  LOW);
digitalWrite(led2k6, LOW);
digitalWrite(led2k7, LOW);
digitalWrite(led2k8, LOW);
    break;
	case 9:
  digitalWrite(led2k1, LOW);
 digitalWrite(led2k2,   LOW);
 digitalWrite(led2k3,   LOW);
 digitalWrite(led2k4,   LOW);
 digitalWrite(led2k5,   HIGH);
digitalWrite(led2k6,    HIGH);
digitalWrite(led2k7,     LOW);
digitalWrite(led2k8, HIGH   );
    break;
  }

	switch (num2) {
  case -1:
 digitalWrite(led3k1,  HIGH);
 digitalWrite(led3k2,  LOW);
 digitalWrite(led3k3,  LOW);
 digitalWrite(led3k4,  LOW);
 digitalWrite(led3k5,  LOW);
digitalWrite(led3k6, LOW);
digitalWrite(led3k7, LOW);   
    break;
  
  case 0:
 digitalWrite(led3k1,  HIGH);
 digitalWrite(led3k2,  LOW);
 digitalWrite(led3k3,  LOW);
 digitalWrite(led3k4,  LOW);
 digitalWrite(led3k5,  LOW);
digitalWrite(led3k6, LOW);
digitalWrite(led3k7, LOW);   
    break;
    
   case 1:
   digitalWrite(led3k1, HIGH);
 digitalWrite(led3k2,   HIGH);
 digitalWrite(led3k3,   HIGH);
 digitalWrite(led3k4,   LOW);
 digitalWrite(led3k5,   HIGH);
digitalWrite(led3k6,    HIGH);
digitalWrite(led3k7,     LOW);
    break;
  case 2:
  digitalWrite(led3k1, LOW); 
  digitalWrite(led3k2, HIGH);
 digitalWrite(led3k3,  LOW);
 digitalWrite(led3k4,  LOW);
 digitalWrite(led3k5,  LOW);
digitalWrite(led3k6,   LOW);
digitalWrite(led3k7,   HIGH);
    break;
  case 3:
  digitalWrite(led3k1, LOW);
 digitalWrite(led3k2,  HIGH);
 digitalWrite(led3k3,  LOW);
 digitalWrite(led3k4,  LOW);
 digitalWrite(led3k5,  HIGH);
digitalWrite(led3k6,   LOW);
digitalWrite(led3k7,    LOW);
    break;
	case 4:
  digitalWrite(led3k1, LOW);
 digitalWrite(led3k2,  LOW);
 digitalWrite(led3k3,  HIGH);
 digitalWrite(led3k4,  LOW);
 digitalWrite(led3k5,  HIGH);
digitalWrite(led3k6,   HIGH);
digitalWrite(led3k7,    LOW);
    break;
	case 5:
  digitalWrite(led3k1,  LOW);
 digitalWrite(led3k2,    LOW);
 digitalWrite(led3k3,    LOW);
 digitalWrite(led3k4,    HIGH);
 digitalWrite(led3k5,    HIGH);
digitalWrite(led3k6,     LOW);
digitalWrite(led3k7,      LOW);
    break;
	case 6:
  digitalWrite(led3k1, LOW);
 digitalWrite(led3k2,   LOW);
 digitalWrite(led3k3,   HIGH);
 digitalWrite(led3k4,   HIGH);
 digitalWrite(led3k5,   LOW);
digitalWrite(led3k6,     LOW);
digitalWrite(led3k7,     LOW);
    break;
	case 7:
 digitalWrite(led3k1, HIGH);
 digitalWrite(led3k2,HIGH);
 digitalWrite(led3k3,LOW);
 digitalWrite(led3k4,LOW);
 digitalWrite(led3k5,HIGH);
digitalWrite(led3k6,  HIGH);
digitalWrite(led3k7,   LOW);
    break;
	case 8:
  digitalWrite(led3k1, LOW);
 digitalWrite(led3k2, LOW);
 digitalWrite(led3k3, LOW);
 digitalWrite(led3k4, LOW);
 digitalWrite(led3k5, LOW);
digitalWrite(led3k6, LOW);
digitalWrite(led3k7, LOW);
    break;
	case 9:
 digitalWrite(led3k1, LOW);
 digitalWrite(led3k2,  LOW);
 digitalWrite(led3k3,  LOW);
 digitalWrite(led3k4,  LOW);
 digitalWrite(led3k5,  HIGH);
digitalWrite(led3k6,   HIGH);
digitalWrite(led3k7,    LOW);
    break;
  }




    switch (num3) {
  case -1:
 digitalWrite(led4k1,  HIGH);
 digitalWrite(led4k2,  LOW);
 digitalWrite(led4k3,  LOW);
 digitalWrite(led4k4,  LOW);
 digitalWrite(led4k5,  LOW);
digitalWrite(led4k6,  LOW);
digitalWrite(led4k7,  LOW);   
    break;
      
      
      case 0:
 digitalWrite(led4k1,  HIGH);
 digitalWrite(led4k2,  LOW);
 digitalWrite(led4k3,  LOW);
 digitalWrite(led4k4,  LOW);
 digitalWrite(led4k5,  LOW);
digitalWrite(led4k6,  LOW);
digitalWrite(led4k7,  LOW);   
    break;
  case 1:
  digitalWrite(led4k1, HIGH);
 digitalWrite(led4k2,  HIGH);
 digitalWrite(led4k3,  HIGH);
 digitalWrite(led4k4,  LOW);
 digitalWrite(led4k5,  HIGH);
digitalWrite(led4k6,   HIGH);
digitalWrite(led4k7,    LOW);
    break;
  case 2:
  digitalWrite(led4k1,LOW); 
  digitalWrite(led4k2,HIGH);
 digitalWrite(led4k3, LOW);
 digitalWrite(led4k4, LOW);
 digitalWrite(led4k5, LOW);
digitalWrite(led4k6,  LOW);
digitalWrite(led4k7,  HIGH);
    break;
  case 3:
  digitalWrite(led4k1, LOW);
 digitalWrite(led4k2,  HIGH);
 digitalWrite(led4k3,  LOW);
 digitalWrite(led4k4,  LOW);
 digitalWrite(led4k5,  HIGH);
digitalWrite(led4k6,   LOW);
digitalWrite(led4k7,    LOW);
    break;
	case 4:
  digitalWrite(led4k1, LOW);
 digitalWrite(led4k2,  LOW);
 digitalWrite(led4k3,  HIGH);
 digitalWrite(led4k4,  LOW);
 digitalWrite(led4k5,  HIGH);
digitalWrite(led4k6,   HIGH);
digitalWrite(led4k7,    LOW);
    break;
	case 5:
  digitalWrite(led4k1,  LOW);
 digitalWrite(led4k2,    LOW);
 digitalWrite(led4k3,    LOW);
 digitalWrite(led4k4,    HIGH);
 digitalWrite(led4k5,    HIGH);
digitalWrite(led4k6,     LOW);
digitalWrite(led4k7,      LOW);
    break;
	case 6:
  digitalWrite(led4k1, LOW);
 digitalWrite(led4k2,   LOW);
 digitalWrite(led4k3,   HIGH);
 digitalWrite(led4k4,   HIGH);
 digitalWrite(led4k5,   LOW);
digitalWrite(led4k6,     LOW);
digitalWrite(led4k7,     LOW);
    break;
	case 7:
  digitalWrite(led4k1,  HIGH);
 digitalWrite(led4k2,  HIGH);
 digitalWrite(led4k3,  LOW);
 digitalWrite(led4k4,  LOW);
 digitalWrite(led4k5,  HIGH);
digitalWrite(led4k6,    HIGH);
digitalWrite(led4k7,     LOW);
    break;
	case 8:
  digitalWrite(led4k1, LOW);
 digitalWrite(led4k2, LOW);
 digitalWrite(led4k3, LOW);
 digitalWrite(led4k4, LOW);
 digitalWrite(led4k5, LOW);
digitalWrite(led4k6, LOW);
digitalWrite(led4k7, LOW);
    break;
	case 9:
  digitalWrite(led4k1, LOW);
 digitalWrite(led4k2,   LOW);
 digitalWrite(led4k3,   LOW);
 digitalWrite(led4k4,   LOW);
 digitalWrite(led4k5,   HIGH);
digitalWrite(led4k6,    HIGH);
digitalWrite(led4k7,     LOW);
    break;
  }

 

  
 
  
  num -= 1;

   if (num == -1)
   
   { num = 9;
   
   num2 -= 1; if(num2 == -1)
   {
     num2 = 5;
     num3 -= 1;
     if(num3 == -1)
     {num3 = 7;
     }}

   }
  delay(500);



}

Det är millis() jag inte får till.
Hur och var skall jag skriva in den?
Ersätter jag bara den med delay så "rusar" bara siffrorna. tex millis()+1000.

[Krille Krokodil]

Deklarera en global variabel först som håller reda på tidpunkten för nästa nedräkning:

unsigned long NextCountdownTime = 0;

Sedan i loopen kan du skriva:

if(millis() >= NextCountdownTime){

NextCountdownTime += 1000;

//Här lägger du koden för att räkna ner 1 sekund och ändra displayen.

}

[Jonaz]

Tack, funkade nästan.
Nu tar det nästan två sekunder för att räkna ner en sekund?
Tog givetvis bort delay.

[Jonaz]

Förresten kan det ha något att göra med att jag kör på interna klockan på 8mHz ?

[Icecap]

Nu kanske jag låter hård men ärligt: din kod visar att du inte har fattat hur en mikroprocessor fungerar.

Alla dessa "ledxky" är variabler och du använder "digitalWrite()" för att styra dessa, det är nog det sämsta sättet jag har sett på länge.

Dessutom bör du, för enkelhetens skull, ha detta att skriva en siffer i en display som en egen rutin, programmet blir mycket mer läsbart då.

Sedan kan man inte basera en klocka på delay() i någon form! Du kan inte veta exakt hur lång tid resten av programmet tar vilket betyder att din cykeltid blir (delay() + okänd värde =) okänd värde.

Du måste starta en interrupt, baserat på en timer, för att klara detta om den ska hålla tiden.

Sist av allt tror jag inte att du kör mikroprocesorn på 8mHz, snarare på 8MHz! Det är bara en faktor 1 000 000 000 i skillnad men 0,008Hz (= 8mHz) är väldigt långsamt och mycket ovanlig som CPU-klocka.

EDIT:
Steg 1: Klura ut vilken port och bit som varje av de angivna pinnar motsvarar.
Steg 2: Med dessa data i handen kan du göra en uppslagstabell som enkelt och smart kan skriva ut siffrorna.
Steg 3: Skapa en rutin som skriver ut ett värde till displayen.
När du har kommit så långt börjar ditt program dels att köra ganska mycket snabbare och dels att vara läsbart.

Steg 4: Starta en timer-interrupt i lämplig hastighet, jag använder ofta 10, 20, 25 eller 100Hz då det gör det hela enkelt. Orsaken till denna högre hastighet är dels att det inte är ofta att man kan landa precis på 1,00000Hz och dels att man inte ofta faktisk kan kan ha så pass lång tid mellan interrupterna. Samtidig kan man enklare starta "mellan" sekunderna.
Steg 5: När interrupten kör är det dags att lägga in en prescaler som delar ner timer-interruptens hastighet till 1 sekund-pulser och sedan är resten enkelt. Varje upp/nedräkning markeras med en flagga som anger att displayen behöver uppdateras och programmet gör då det.