Nach 8 kommt 19 und danach 10 - 7 Seg Uhr mit MAX7219

[BeastyK (Gast)]

Moin Leute,

ich hab hier ein Problem mit PIC18F4455, MAX7219 mit 8Digit 
7Segment-Modul.
Mir scheint das die Zählroutine etwas buggy ist, er zählt von 0 bis 8 
ganz normal und anstatt 9 zeigt er mir 19 an und danach kommt die 10.
Das funktioniert nicht nur bei den Sekunden sondern auch bei den Minuten 
so.
Ich häng mal die Main mit ran:

/*
 * File:   main7219.c
 * Author: BeastyK
 *
 * Created on 9. Oktober 2016, 17:54
 */


#include <xc.h>
#include <delays.h>
#include <spi.h>
#include <timers.h>
#include <stdio.h>
#include <stdlib.h>
#include "m7219.h"

#define _XTAL_FREQ 20000000

void Timer1Init();
void interrupt_isr(void);
//void max7219_time_write(unsigned int std, unsigned int min, unsigned int sek);

/*****************************************************************************/  
/** C O N F I G U R A T I O N ************************************************/
/*****************************************************************************/


// PIC18F4455 Configuration Bit Settings

// 'C' source line config statements

// CONFIG1L
#pragma config PLLDIV = 5       // PLL Prescaler Selection bits (Divide by 5 (20 MHz oscillator input))
#pragma config CPUDIV = OSC1_PLL2// System Clock Postscaler Selection bits ([Primary Oscillator Src: /1][96 MHz PLL Src: /2])
#pragma config USBDIV = 2       // USB Clock Selection bit (used in Full-Speed USB mode only; UCFG:FSEN = 1) (USB clock source comes from the 96 MHz PLL divided by 2)

// CONFIG1H
#pragma config FOSC = HSPLL_HS  // Oscillator Selection bits (HS oscillator, PLL enabled (HSPLL))
#pragma config FCMEN = OFF      // Fail-Safe Clock Monitor Enable bit (Fail-Safe Clock Monitor disabled)
#pragma config IESO = OFF       // Internal/External Oscillator Switchover bit (Oscillator Switchover mode disabled)

// CONFIG2L
#pragma config PWRT = OFF       // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOR = ON         // Brown-out Reset Enable bits (Brown-out Reset enabled in hardware only (SBOREN is disabled))
#pragma config BORV = 3         // Brown-out Reset Voltage bits (Minimum setting 2.05V)
#pragma config VREGEN = ON      // USB Voltage Regulator Enable bit (USB voltage regulator enabled)

// CONFIG2H
#pragma config WDT = OFF        // Watchdog Timer Enable bit (WDT disabled (control is placed on the SWDTEN bit))
#pragma config WDTPS = 32768    // Watchdog Timer Postscale Select bits (1:32768)

// CONFIG3H
#pragma config CCP2MX = ON      // CCP2 MUX bit (CCP2 input/output is multiplexed with RC1)
#pragma config PBADEN = OFF     // PORTB A/D Enable bit (PORTB<4:0> pins are configured as digital I/O on Reset)
#pragma config LPT1OSC = OFF    // Low-Power Timer 1 Oscillator Enable bit (Timer1 configured for higher power operation)
#pragma config MCLRE = ON       // MCLR Pin Enable bit (MCLR pin enabled; RE3 input pin disabled)

// CONFIG4L
#pragma config STVREN = ON      // Stack Full/Underflow Reset Enable bit (Stack full/underflow will cause Reset)
#pragma config LVP = OFF        // Single-Supply ICSP Enable bit (Single-Supply ICSP disabled)
#pragma config ICPRT = OFF      // Dedicated In-Circuit Debug/Programming Port (ICPORT) Enable bit (ICPORT disabled)
#pragma config XINST = OFF      // Extended Instruction Set Enable bit (Instruction set extension and Indexed Addressing mode disabled (Legacy mode))

// CONFIG5L
#pragma config CP0 = OFF        // Code Protection bit (Block 0 (000800-001FFFh) is not code-protected)
#pragma config CP1 = OFF        // Code Protection bit (Block 1 (002000-003FFFh) is not code-protected)
#pragma config CP2 = OFF        // Code Protection bit (Block 2 (004000-005FFFh) is not code-protected)

// CONFIG5H
#pragma config CPB = OFF        // Boot Block Code Protection bit (Boot block (000000-0007FFh) is not code-protected)
#pragma config CPD = OFF        // Data EEPROM Code Protection bit (Data EEPROM is not code-protected)

// CONFIG6L
#pragma config WRT0 = OFF       // Write Protection bit (Block 0 (000800-001FFFh) is not write-protected)
#pragma config WRT1 = OFF       // Write Protection bit (Block 1 (002000-003FFFh) is not write-protected)
#pragma config WRT2 = OFF       // Write Protection bit (Block 2 (004000-005FFFh) is not write-protected)

// CONFIG6H
#pragma config WRTC = OFF       // Configuration Register Write Protection bit (Configuration registers (300000-3000FFh) are not write-protected)
#pragma config WRTB = OFF       // Boot Block Write Protection bit (Boot block (000000-0007FFh) is not write-protected)
#pragma config WRTD = OFF       // Data EEPROM Write Protection bit (Data EEPROM is not write-protected)

// CONFIG7L
#pragma config EBTR0 = OFF      // Table Read Protection bit (Block 0 (000800-001FFFh) is not protected from table reads executed in other blocks)
#pragma config EBTR1 = OFF      // Table Read Protection bit (Block 1 (002000-003FFFh) is not protected from table reads executed in other blocks)
#pragma config EBTR2 = OFF      // Table Read Protection bit (Block 2 (004000-005FFFh) is not protected from table reads executed in other blocks)

// CONFIG7H
#pragma config EBTRB = OFF      // Boot Block Table Read Protection bit (Boot block (000000-0007FFh) is not protected from table reads executed in other blocks)

// #pragma config statements should precede project file includes.
// Use project enums instead of #define for ON and OFF.

/*****************************************************************************/
/**** M A I N  P R O G R A M  ************************************************/
/*****************************************************************************/

unsigned char i;
unsigned int second = 0, minute = 0, hour = 0;

void Timer1Init() {

    //Timer1 ist ein 16bit Timer (FFFFh oder 65535) mit jeweils 8bit Timer High 
    //und 8bit Timer Low mit externen Uhrenquarz von 32768Hz wird der Interrupt nach
    //2 Sekunden gesetzt, daher wird TMR1H auf 80h gesetzt (8000h ist der gesamte 
    //Timer1 aus TMR1H und TMR1L und entspricht 32768)
TMR1H = 0x80;                //setzt Msb des oberen 8bit des Timer1 auf 1     
TMR1L = 0;                //setzt die unteren 8bit des Timers1 auf Null
  TRISCbits.TRISC0 = 1;       //setzt TRISC0 auf Eingang (warum aber nicht TRISC1?)
  LATBbits.LATB6 = 1;        //setzt den PM-Zeit bit
  T1CON = 0b00001111;           // 2x8bit, externer Takt, Osc enabled, asynch, start!
    PIE1bits.TMR1IE = 1;
    INTCONbits.PEIE = 1;
    //RCONbits.IPEN=0x01;
    //IPR1bits.TMR1IP=0x01;            // TMR1 high priority ,TMR1 Overflow Interrupt Priority bit
    INTCONbits.GIE = 1;
    PIR1bits.TMR1IF = 0;        //setzt den Timerinterrupt von Timer1 auf Null
}

void interrupt  isr(void)
{
//TMR1H |= 0x80;
  if (PIR1bits.TMR1IF) 
  {
    unsigned int d = 0, e = 0, f = 0, std = 0, min = 0, sek = 0;
        second++;
  //  max7219new++;
    TMR1H = 0x70;    
    //PIR1bits.TMR1IF = 0;    //TMR1IF überlauf muß per software zurückgesetzt werden (Datenblatt Seite 102)
    
   
    if (second >= 60)     //ist second gleich oder größer 60 dann
      {
        minute++;      //Variable minute um 1 erhöhen (60 Sekunden sind eine Minute)
          second = 0;      //die Variable second beim Timerinterrupt wieder von 0 anfangen lassen zu zählen
      }

  if (minute >= 60)    //ist minute gleich oder größer 60 dann
      {
        hour++;        //Variable hour um 1 erhöhen (60 Minuten sind eine Stunde)
          minute = 0;      //die Variable minute wieder auf 0 setzen damit eine neue Minute gezählt wird
      }
  if (hour >= 24)
      {
        hour = 0;
      }
  
    //if (max7219new >= 1)
  //    {
  //      max7219_time_write(hour, minute, second);
  //      max7219new = 0;
  //    }
  //d = hour / 10;
  //std = hour - (d * 10);
  //max7219_digitwrite(3, d);
  //max7219_digitwrite(4, std);
  //e = minute / 10;
  //min = minute - (e * 10);
  //max7219_digitwrite(5, e);
  //max7219_digitwrite(6, min);
  f = second / 10;
  sek = second - (f * 10);
  max7219_digitwrite(7, f);
  max7219_digitwrite(8, sek);
    
    PIR1bits.TMR1IF = 0;    //TMR1IF überlauf muß per software zurückgesetzt werden (Datenblatt Seite 102)
  }
}

/*void max7219_time_write(unsigned int std, unsigned int min, unsigned int sek)
{
  unsigned int d = 0, e = 0, f = 0;
  
  d = std / 10;
  std = std - (d * 10);
  max7219_digitwrite(3, d);
  max7219_digitwrite(4, std);
  e = min / 10;
  min = min - (e * 10);
  max7219_digitwrite(5, e);
  max7219_digitwrite(6, min);
  f = sek / 10;
  sek = sek - (f * 10);
  max7219_digitwrite(7, f);
  max7219_digitwrite(8, sek);
    
  
}
*/
void main(void)
{
  __delay_ms(25);  //Delay of 100ms
  __delay_ms(25);
  __delay_ms(25);  
  __delay_ms(25);
  OpenSPI(SPI_FOSC_16, MODE_00, SMPMID);  // MODE besteht aus CKP/CKE, ist CKP gleich 1, SCK sendet nicht bei hohen Pegel oder CKP ist 0, SCK
                      //sendet nicht bei niedrigen Pegel.           
  __delay_ms(25);  //Delay of 100ms
  __delay_ms(25);
  __delay_ms(25);  //Delay of 100ms
  __delay_ms(25);
                       
  TRISC &= 0xFB;    // 1111 1011
  TRISD = 0xF0;      // 1111 0000  
  LATDbits.LATD0 = 1; //Set D0 high  
  __delay_ms(25);  //Delay of 100ms
  __delay_ms(25);
  __delay_ms(25);  //Delay of 100ms
  __delay_ms(25);
  max7219_init();
  __delay_ms(25);  //Delay of 100ms
  __delay_ms(25);
  __delay_ms(25);  //Delay of 100ms
  __delay_ms(25);
  Timer1Init();
  __delay_ms(25);  //Delay of 100ms
  __delay_ms(25);
  __delay_ms(25);  //Delay of 100ms
  __delay_ms(25);
  
while(1)
  {

  } 
}

Vieles ist auskommentiert und dann in die ISR gerutscht, zuletzt hab ich 
mich nur noch auf die Sekunden konzentriert.
Die MAX7219 sieht dabei so aus:

//MAX 7219 chip_util Library
#include <p18f4455.h>
#include <spi.h>

#define SELMAX      PORTCbits.RC2 = 1;
#define DESELMAX    PORTCbits.RC2 = 0;

void max7219_init() {

  SELMAX;           // SELECT MAX
  WriteSPI(0x09);         // BCD mode for digit decoding
  WriteSPI(0xFF);
  DESELMAX;              // DESELECT MAX

  SELMAX;           // SELECT MAX
  WriteSPI(0x0A);
  WriteSPI(0x0F);         // Segment luminosity intensity
  DESELMAX;              // DESELECT MAX

  SELMAX;           // SELECT MAX
  WriteSPI(0x0B);
  WriteSPI(0x07);
 // WriteSPI(x-1);         // Set how many digits mit max7219_init(int x)
  DESELMAX;              // DESELECT MAX

  SELMAX;           // SELECT MAX
  WriteSPI(0x0C);
  WriteSPI(0x01);         // Turn on the display
  DESELMAX;              // DESELECT MAX

  SELMAX;           // SELECT MAX
  WriteSPI(0x00);
  WriteSPI(0xFF);         // No test
  DESELMAX;              // DESELECT MAX
}

void max7219_clear(int x) {

unsigned char ii;

  for (ii = 1; ii<=x; ii++)
  {
    SELMAX;          // select max7219
    WriteSPI(ii);           // send i to max7219 (digit place)
    WriteSPI(0);         // send i to max7219 (digit)
    DESELMAX;             // deselect max7219
  }
}

void max7219_digitwrite(int x, int y) {

    SELMAX;          // select max7219
    WriteSPI(x);           // send i to max7219 (digit place)
    WriteSPI(y);         // send i to max7219 (digit)
    DESELMAX;             // deselect 
    return;
}

void max7219_write(unsigned int value) {

unsigned int d;

    d = value / 10000;
    value=value-(d*10000);
    max7219_digitwrite(5,d);
    d = value / 1000;
    value=value-(d*1000);
    max7219_digitwrite(4,128+d);
    d = value / 100;
    value=value-(d*100);
    max7219_digitwrite(3,d);
    d = value / 10;
    value=value-(d*10);
    max7219_digitwrite(2,d);
    max7219_digitwrite(1,value);

}

Wenn jemand hier weiter weiß, bin da ganz offen :)

MfG
BeastyK

[A. S. (Gast)]

Nur zum Verständnis:

Es läuft von [00] bis [59] richtig,
mit Ausnahme [09] was als [19] ausgeben wird?
Und nach [59] gehts mit [00] weiter?

Und es zählt im Sekundentakt (kein Verschlucken/Verzögern)?

Die SPI-Routinen laufen in der ISR, also ohne eigene Interrupts?

Und bei der Inbetriebnahme konntest Du erfolgreich 09 direkt im Main 
ausgeben (ohne Interrupts, ohne weitere Anzeigen)?

[Klaus (Gast)]

Schon mal mit dem Debugger versucht? Da sollte man doch leicht 
rausfinden, was da abgeht.

MfG Klaus

[int (Gast)]

>unsigned int d = 0, e = 0, f = 0,

Die Definition paßt ja nicht so ganz zu der Berechnung:

>f = second / 10;

Das solltes Du nochmals überdenken. Oder Copy und Paste besser benutzen.

[Peter D. (peda)]

BeastyK schrieb:
> Ich häng mal die Main mit ran:

Lesen kannst Du aber schon?
Siehe Anhang!

[KingJulian (Gast)]

  f = second / 10;
  sek = second - (f * 10);

Weiss nicht ob gewollt oder nicht, aber

sek

 ist hier immer 0

[JensM (Gast)]

@KingJulian

Schnell aber falsch.

Datentypen von second, f und sek ist unsigned int

second = 52;

f = second / 10;
-> f = 5

 sek = second - (f * 10);

-> sek = 52 - (5 * 10)
-> sek = 52 - 50
-> sek = 2

das war wohl so gedacht

Gruß JensM

[Norbert (Gast)]

KingJulian schrieb:
>

  f = second / 10;
>   sek = second - (f * 10);

>
> Weiss nicht ob gewollt oder nicht, aber

sek

 > ist hier immer 0

Wie kommst du denn darauf?
'f' ist ein integer!

[MaWin (Gast)]

KingJulian schrieb:
> Weiss nicht ob gewollt oder nicht,
> aber sek ist hier immer 0

Warum sollte es? Kann es sein, dass dir die Grundlagenkenntnisse im 
Programmieren fehlen?

[BeastyK (Gast)]

Moin Leute,

ich fang mal mit beantworten an, entschuldigt für das späte 
aufstehen...ich hatte ne unangenehme Nacht.
Ich fang mal mit dem Chef an!

Peter D. schrieb:
> Lesen kannst Du aber schon?

Moin Peter, ich halte mich natürlich an die Boardregeln, in dem Fall 
dachte ich mir das der Code nicht wirklich lang ist und ich ihn noch so 
posten kann.
Wahrscheinlich habe ich "lang" falsch definiert, sorry!

So, weiter:

Achim S. schrieb:
> Es läuft von [00] bis [59] richtig,
> mit Ausnahme [09] was als [19] ausgeben wird?
> Und nach [59] gehts mit [00] weiter?

Hallo Achim, die Frage ist gut, das hab ich nicht gut genug erklärt:
Er hat das immer wenn er hinten eine 9 hat, also bei 09 zeigt er 19, bei 
19 zeigt er 29 usw. bis er bei 59 die Minute und dann dahinter 09 
anzeigt. Nach 109 geht es dann mit 100 weiter.

Achim S. schrieb:
> Und es zählt im Sekundentakt (kein Verschlucken/Verzögern)?

Naja, ich bin der Meinung er steht etwas länger bei der 0 am Anfang, er 
sollte im Sekundentakt zählen. Manchmal kommt es mir auch vor als würde 
er etwas haken, nachgemessen hab ich das noch nicht.
Den TMR1H hab ich zum testen auch mal mit 0xC0 gefüttert, dann läuft er 
schneller über.
Interessant ist aber das ich wegen der Verzögerung am Anfang dachte das 
vielleicht second schon weiter ist und die Ausgabe auf dem 7Segment 
Display noch hängt und hab deshalb einfach mal folgendes geändert:

f = second / 10;

wurde zu

f = (second - 1) / 10;

Eine Verzweiflungstat, die aber dazu führte das er von 01 bis 09 zählte 
und dann bei der 10 einfach 1- ausgegeben hat.
Dito bei den anderen Zahlen mit 9 am Ende!

Achim S. schrieb:
> Die SPI-Routinen laufen in der ISR, also ohne eigene Interrupts?

Die SPI.h Headerdatei ist mit eingebunden, da hab ich dann nicht so 
genau draufgeschaut.

Klaus schrieb:
> Schon mal mit dem Debugger versucht? Da sollte man doch leicht
> rausfinden, was da abgeht.

Hab ich schon probiert, mit dem debuggen bei MPLABX hab ich etwas 
Probleme, ich weiß nicht wie ich die Variablen in die Watchliste 
bekomme. Bei Proteus läuft das besser, was ich gesehen hab ist das er 
bei second = 09 noch minute = 0 hat. Leider läßt sich das Display beim 
steppen nicht beobachten wegen dem multiplexen.

int schrieb:
>>unsigned int d = 0, e = 0, f = 0,
>
> Die Definition paßt ja nicht so ganz zu der Berechnung:
>
>>f = second / 10;
>
> Das solltes Du nochmals überdenken.

Ich hatte wirklich schon in betracht gezogen das er 9/10 einfach 
aufrundet.
Dann hab ich das aber schnell wieder als unsinnig abgetan.

JensM schrieb:
> Datentypen von second, f und sek ist unsigned int
>
> second = 52;
>
> f = second / 10;
> -> f = 5
>
>  sek = second - (f * 10);
>
> -> sek = 52 - (5 * 10)
> -> sek = 52 - 50
> -> sek = 2
>
> das war wohl so gedacht

Exakt so ist das gedacht!

Bin aber froh das ihr euch an dem Post so gut beteiligt, ich weiß da im 
Moment einfach nicht mehr weiter!

MfG
Beast

[Wegstaben V. (wegstabenverbuchsler)]

MaWin schrieb:
> dass dir die Grundlagenkenntnisse im
> Programmieren fehlen?

manchmal ist es hilfreich, Variablen aussagefähig zu benennen. Schon 
liest sich das viel geschmeidiger.


zum Beispiel anstelle von
f = second / 10;
sek = second - (f * 10);

-->

ZehnerSekunde = second / 10;
EinerSekunde  = second - (ZehnerSekunde * 10);

[Klaus (Gast)]

BeastyK schrieb:
> Bin aber froh das ihr euch an dem Post so gut beteiligt, ich weiß da im
> Moment einfach nicht mehr weiter!

Vielleicht doch mal den Debugger bemühen? Breakpoint setzen, 
durchsteppen und sehen was passiert. Macht viel weniger Arbeit als 
dauernd zu posten.

MfG Klaus

[BeastyK (Gast)]

Wegstaben V. schrieb:
> manchmal ist es hilfreich, Variablen aussagefähig zu benennen. Schon
> liest sich das viel geschmeidiger.

Moin Wegstaben Verbuchsler,

für den Informatikunterricht an Schulen geb ich dir da total recht.

Die Zerlegung einer Zahl findet sich so aber auch in der max7219.h Datei 
wieder, dort wurde das für eine 5 stellige Zahl durchgenommen, siehe

void max7219_write(unsigned int value)

MaWin hat das in seinem Post nur auf seine Art gesagt, übrigens: Moin 
MaWin!

Gruss
Beast

[BeastyK (Gast)]

Klaus schrieb:
> Vielleicht doch mal den Debugger bemühen? Breakpoint setzen,
> durchsteppen und sehen was passiert. Macht viel weniger Arbeit als
> dauernd zu posten.

Ich les mich noch etwas ins debuggen ein und werds mal 
probieren...darfst nir aber gern weiterhelfen!

[Eric B. (beric)]

BeastyK schrieb:
> unsigned int second = 0, minute = 0, hour = 0;

Die werden im Interruptroutine geändert --> volatile!

BeastyK schrieb:
> f = second / 10;
>   sek = second - (f * 10);
>   max7219_digitwrite(7, f);
>   max7219_digitwrite(8, sek);

Der Abschnitt an sich ist schon ok. Der Fehler muss woanders sitzen.
Wobei ich persönlich das anders aufsetzen würde und einfach jedes 
Zeichen eine eigene Zähler verpassen würde. Und die Ausgabe in die 
main-loop.

Etwa so:

volatile uint8_t hour10, hout1, min10, min1, sec10, sec1;
volatile bool_t tick = FALSE;

void interrupt isr(void)
{
  sec1 ++;

  if (sec1  == 10) { sec1  = 0; sec10  ++; }
  if (sec10 ==  6) { sec10 = 0; min1   ++; }
  if (min1  == 10) { min1  = 0; min10  ++; }
  if (min10 ==  6) { min10 = 0; hour1  ++; }
  if (hour1 == 10) { hour1 = 0; hour10 ++; }

  if ((hour10 == 2) && (hour1 == 4)) { hour10 = 0; hour1 = 0; }

  tick = TRUE; // notify main loop
}

void main()
{
  // init stuff here 

  for(;;)
  {
    if (tick) // notification from ISR
    {
       tick = FALSE;
       
       max7219_digitwrite(1,hour10);
       max7219_digitwrite(2,hour1);
       max7219_digitwrite(3,min10);
       max7219_digitwrite(4,min1);
       max7219_digitwrite(5,sec10);
       max7219_digitwrite(6,sec1);
    }
  }
}

[Programmierer (Gast)]

BeastyK schrieb:
> für den Informatikunterricht an Schulen geb ich dir da total recht

Für den normalen Programmieralltag gilt das auch.
Ein langer Variablenname kosten zwar im Quellcode einige Bytes, macht 
das fertige Programm aber nicht länger.

[Harald (Gast)]

Ich verweise mal wider auf die geniale Software "Sigrok", da kann man 
den Output zum 7219 dekodiert anschauen und so meist sehr schnell den 
Fehler lokalisieren. Die Hardware kostet in Form eines "Saleae Clone" 
weniger als 10€.

[Harald (Gast)]

wider = wieder

[Klaus (Gast)]

BeastyK schrieb:
> Ich les mich noch etwas ins debuggen ein und werds mal
> probieren...darfst nir aber gern weiterhelfen!

Und solange läßt du andere deinen Code für dich debuggen. Prima Sache, 
braucht man selbst nicht soviel lesen und nutzt die eigenen Augen nicht 
so ab.

MfG Klaus

[BeastyK (Gast)]

Klaus schrieb:
> Und solange läßt du andere deinen Code für dich debuggen. Prima Sache,
> braucht man selbst nicht soviel lesen und nutzt die eigenen Augen nicht
> so ab.

Du hast mich durchschaut, Klaus!
Gerade bei dir hab ich darauf gewartet.
Nun bin ich enttäuscht.
Kennst du eine Seite bei der das mit der Watchliste und den nicht 
globalisierten Variablen in einem Tutorial gezeigt wird?

Gruss
Beast

[Klaus (Gast)]

BeastyK schrieb:
> Nun bin ich enttäuscht.

Das bringt mein Karma wieder ins Reine. Bin heut nämlich schon gelobt 
worden.

Aber BTT, mal die Maus über eine Variable bewegen, wenn der Pic 
angehalten ist. Locale Variable werden IMHO aber auch automatisch im 
Variablenfenster angezeigt.

Ich kenne keine Tutorials, ich lese Texte, zur Not ganze Bücher. Machmal 
steht auch was in der Onlinehilfe.

MfG Klaus

[A. S. (Gast)]

Halte mich für blöd, aber drehe die Zeilen mal um. Also statt

>max7219_digitwrite(7, f);
>max7219_digitwrite(8, sek);

nun

max7219_digitwrite(8, sek);
max7219_digitwrite(7, f);

Wenn es sich dann noch immer genauso verhält, fresse ich einen Besen.

sonst sehe ich (ohne debugger) Erkenntnis nur noch darin, die 
original-Zeilen mal mit festen Zahlen laufen zu lassen, egal ob in der 
Interrupt-Routine oder stattdessen (also nur einmal in main). Also:

max7219_digitwrite(7, 9);
max7219_digitwrite(8, 0);

[BeastyK (Gast)]

Klaus schrieb:
> Aber BTT, mal die Maus über eine Variable bewegen, wenn der Pic
> angehalten ist. Locale Variable werden IMHO aber auch automatisch im
> Variablenfenster angezeigt.

Guck an, das mit dem Mauszeiger wußte ich nicht, danke!
Mhhh, sollte mal "Mieses Karma" lesen...türlich auch mehr von den 
Microchip Notes :b

Achim, das mit dem tauschen, Naja, versuch ich auch mal...feste Zahlen 
nehmen hatte ich auch schon vor, dann könnte man feststellen ob die 
Ausgabe an den Max7219 so richtig ist, spi zb.

MfG
Beast

[BeastyK (Gast)]

Achim S. schrieb:
> Wenn es sich dann noch immer genauso verhält, fresse ich einen Besen.

Du bekommst doch meinen einzigen Besen nicht als Mahlzeit, gib her 
...so!

Danke Achim, du hast mich in die richtige Richtung geschubst mit dem 
drehen der beiden Zeilen!
Ich weiß gerade nicht mehr ob es dann ganz und gar funktionierte, es hat 
mich aber auf die Idee gebracht in der MAX7219 Headerdatei mit dem CS 
Pin zu spielen. Ich fügte hinten in der void (max7219_digitwrite) 
nochmals selmax und deselmax ein und es funktionierte.
Heute morgen hab ich das MAX7219 Datenblatt konsultiert, ich zitiere 
mal...

Aus MAX7219 Datenblatt:
"For the MAX7221, CS must be low to clock data
in or out. The data is then latched into either the digit or
control registers on the rising edge of LOAD/CS.
LOAD/CS must go high concurrently with or after the
16th rising clock edge, but before the next rising clock
edge or data will be lost."

Soso, CS muß also low (0) sein wenn ich ihm über SPI die 2x 8bit Daten 
rüberschiebe, dann wieder high (1). Das deckt sich ja mal garnicht so 
mit dem was ich da fabriziert hab:

BeastyK schrieb:
> #define SELMAX      PORTCbits.RC2 = 1;
> #define DESELMAX    PORTCbits.RC2 = 0;

das drehen wir schnell mal um in

#define SELMAX      PORTCbits.RC2 = 0;
#define DESELMAX    PORTCbits.RC2 = 1;

und setzen in der main.c noch ein

LATCbits.LATC2 = 1;

 zwischen den Zeilen

BeastyK schrieb:
> TRISC &= 0xFB;    // 1111 1011
>   TRISD = 0xF0;      // 1111 0000

und nun läuft die Anzeige und zählt korrekt.
Mhhhh, leider hab ich noch eine Arbeitnehmer freundliche Variante meiner 
Uhr, sie schafft es das die Minute um die 10 Sekunden schneller um ist.

MfG
Beast

[Peter D. (peda)]

BeastyK schrieb:
> das drehen wir schnell mal um in
> #define SELMAX      PORTCbits.RC2 = 0;
> #define DESELMAX    PORTCbits.RC2 = 1;

Und wenn Du den Code angehangen hättest, wär das garantiert schon viel 
früher aufgefallen.
So wurde es durch das ständige hin und her scrollen einfach überlesen.

Kleine 20-Zeiler kann man einfügen, alles größere schaut sich erheblich 
besser in einem Editor an.

[A. S. (Gast)]

BeastyK schrieb:
> Du bekommst doch meinen einzigen Besen nicht

Uups ... Halloween steht vor der tür

[BeastyK (Gast)]

Peter D. schrieb:
> Und wenn Du den Code angehangen hättest, wär das garantiert schon viel
> früher aufgefallen.
> So wurde es durch das ständige hin und her scrollen einfach überlesen.
>
> Kleine 20-Zeiler kann man einfügen, alles größere schaut sich erheblich
> besser in einem Editor an.

Moin Peter,
ich zieh mal aus dem Post den Schluss das alles über 20 Zeilen als lang 
gilt.
Das werde ich mir für andere Beiträge merken und beherzigen!

Achim S. schrieb:
> Uups ... Halloween steht vor der tür

Oha, jaaa, dann wird der Besen noch viel unverzichtbarer ;)
Wie bist du eigentlich auf die Idee mit dem Zeilentausch gekommen?

Gruss
Beast