Controller hängt sich unregelmäßig auf

[Mike M. (mikeii)]

Hi,

ich habe ein umfangreicheres Programm für meine Wordclock geschrieben.
Die Frage ist, wann und wo es sich aufhängt, da die Uhr einfach 
irgendwann mal stehen bleibt.
Den Code habe ich jetzt schon zwei mal durch, sehe aber keine 
Möglichkeit wo ein Überlauf entstehen kann, es gibt keine Interrupts, 
Wertzuweisungen  sind alle okay, etc.

Gibt es eine Möglichkeit, wie ich rausfinden kann, wo das Problem hängt?

Danke

[Udo S. (urschmitt)]

Sind die Spannungen ok?
Wenn du noch Pins frei hast kannst du an den Verdachtsstellen 
(Schleifen) Port Pins auf eindeutige Werte setzen und wenn er 
"abgestürzt" ist anhand der Port Pin Spannungen schauen in welcher 
Schleife er kreist.

[Kevin (Gast)]

Hm, meine Glaskugel ist beim Service.
Vielleicht hast du die Uhr zu wenig aufgezogen.

Schaltung, Programmcode usw. wären sehr hilfreich,
ansonsten sehe ich 'dunkelschwarz'.

[Mike M. (mikeii)]

Spannungen passen alle, sind bei 4,9 Volt laut Multimeter.

Die Schleifen habe ich auch schon alle geprüft, beim Eintritt der 
Schleife einen Pin auf High, und direkt danach auf Low.
"Leider" hängt er sich in keiner Schleife auf.
Und das Programm ist sehr komplex, als das ich überall diese Checks 
machen könnte.
Aber wahrscheinlich geht es erstmal nicht anderst und ich sollte einfach 
mal alles durchechecken

[Mike M. (mikeii)]

Ich hoffe der Code ist nicht zu "minderwertig"
Als Echtzeituhr kommt eine DS1307 zum Einsatz.

Unter der Settime.c nicht wundern, warum ich das byte zum Senden so 
komisch generiere, da ich gestern Nacht ein paar Denkfehler hatte, bis 
ich wieder ins Datenblatt der DS3017 geschaut habe. Man kann es um 
einiges kürzer machen, aber ich denke so müsste es passen.
Format ist folgendes:

Für die Minuten:

0  | 3bit für die Zehnerstelle der Minuten  |  4 bit für die Einer der 
Minuten

Für die Stunden im 24h Modus:

00 | 2 bit für Zehnerstelle der Stunden | 4 bit für die Einer der 
Minuten


das TWI_SEND(0x00,0x00) ist dafür da, falls jemand die Batterie aus der 
RTC nimmt, damit der Clock wieder aktiviert wird.

main.c

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <util/delay.h>
#include <stdlib.h>
#include <avr/pgmspace.h>
#include <stdint.h>
#include "i2c.c"
#include "settime.c"


#define BAUD 9600UL
#define UBRR_VAL 51

#define SHOW    PORTB |= _BV(PB4)

#define BLAU    0,0,1
#define GRUEN   0,1,0
#define TURKIS  0,1,1
#define ROT     1,0,0
#define LILA    1,0,1
#define ORANGE  1,1,0
#define WEISS   1,1,1
#define FASTPWM TCCR2 &= ~(1<<CS22);TCCR2 |= (1<<CS21);
#define SLOWPWM TCCR2 &= ~(1<<CS21);TCCR2 |= (1<<CS22);
#define PWM_AUS TCCR2 &= ~(1<<WGM20) & ~(1<<COM21) & ~(1<<CS22) & ~(1<<CS20);
#define PWM_AN TCCR2 |= (1<<WGM20) | (1<<COM21) | (1<<CS22) | (1<<CS20);




uint8_t karth_to_line(uint8_t x,uint8_t y);
void set_global_colors(uint8_t r,uint8_t g,uint8_t b);
uint8_t get_color_code(uint8_t r,uint8_t g,uint8_t b,uint8_t modr,uint8_t modg,uint8_t modb,uint8_t latch);
void put_pixel_on_strip(uint8_t x,uint8_t y,uint8_t modus,uint8_t r,uint8_t g,uint8_t b);
void timer1 (void);
void master_init (void);
void master_transmit (uint16_t data);
void init_line(void);
void init_strip(void);
void grid_add_pixel(uint8_t x,uint8_t y);
void grid_flush(void);
void send_line(uint8_t effect);
void init_grey_line(void);
void init_grey_line_buffer(void);
void buffer_grey_line(void);
void grid_push_up(uint8_t n);
void grid_push_down(uint8_t n);
void flush(void);
void display_time(uint8_t fade, uint8_t effect);
void matrix_effect(void);


unsigned char status = 0;
volatile unsigned char count;
uint8_t globalcoloron = 0b10000010;
uint8_t globalcolor_fade_on = 0b10000000;
uint8_t globalcolor_fade_off = 0b10000000;
uint8_t global_r;
uint8_t global_g;
uint8_t global_b;
uint8_t line[100];
uint8_t grey_line[100];
uint8_t grey_line_buffer[100];
uint8_t grid[10][10];
uint8_t hours=5,minutes=0;
uint8_t nightmode = 0;



void time_to_array(uint8_t hours,uint8_t minutes)
{

    //Array leeren
    grid_flush();

    //Pixel in Array füllen

    //ES IST
    grid_add_pixel(0,0);
    grid_add_pixel(1,0);
    grid_add_pixel(4,0);
    grid_add_pixel(5,0);
    grid_add_pixel(6,0);



    //Minuten anzeige
    if(minutes >= 5 && minutes < 10)
    {
        //Fünf

        grid_add_pixel(1,1);
        grid_add_pixel(2,1);
        grid_add_pixel(3,1);
        grid_add_pixel(4,1);
        //Nach
        grid_add_pixel(0,3);
        grid_add_pixel(1,3);
        grid_add_pixel(2,3);
        grid_add_pixel(3,3);
    }
    else if(minutes >= 10 && minutes < 15)
    {
        //Zehn
        grid_add_pixel(6,1);
        grid_add_pixel(7,1);
        grid_add_pixel(8,1);
        grid_add_pixel(9,1);
        //Nach
        grid_add_pixel(0,3);
        grid_add_pixel(1,3);
        grid_add_pixel(2,3);
        grid_add_pixel(3,3);
    }
    else if(minutes >= 15 && minutes < 20)
    {
        //Viertel
        grid_add_pixel(3,2);
        grid_add_pixel(4,2);
        grid_add_pixel(5,2);
        grid_add_pixel(6,2);
        grid_add_pixel(7,2);
        grid_add_pixel(8,2);
        grid_add_pixel(9,2);

        //Nach
        grid_add_pixel(0,3);
        grid_add_pixel(1,3);
        grid_add_pixel(2,3);
        grid_add_pixel(3,3);
    }
    else if(minutes >= 20 && minutes < 25)
    {

        //Zehn
        grid_add_pixel(6,1);
        grid_add_pixel(7,1);
        grid_add_pixel(8,1);
        grid_add_pixel(9,1);
        //Vor
        grid_add_pixel(6,3);
        grid_add_pixel(7,3);
        grid_add_pixel(8,3);
        //Halb
        grid_add_pixel(0,4);
        grid_add_pixel(1,4);
        grid_add_pixel(2,4);
        grid_add_pixel(3,4);

    }
    else if(minutes >= 25 && minutes < 30)
    {
        //Fünf
        grid_add_pixel(1,1);
        grid_add_pixel(2,1);
        grid_add_pixel(3,1);
        grid_add_pixel(4,1);
        //Vor
        grid_add_pixel(6,3);
        grid_add_pixel(7,3);
        grid_add_pixel(8,3);
        //Halb
        grid_add_pixel(0,4);
        grid_add_pixel(1,4);
        grid_add_pixel(2,4);
        grid_add_pixel(3,4);
    }
    else if(minutes >= 30 && minutes < 35)
    {
        //Halb
        grid_add_pixel(0,4);
        grid_add_pixel(1,4);
        grid_add_pixel(2,4);
        grid_add_pixel(3,4);
    }
    else if(minutes >= 35 && minutes < 40)
    {
        //Fünf
        grid_add_pixel(1,1);
        grid_add_pixel(2,1);
        grid_add_pixel(3,1);
        grid_add_pixel(4,1);
        //Nach
        grid_add_pixel(0,3);
        grid_add_pixel(1,3);
        grid_add_pixel(2,3);
        grid_add_pixel(3,3);
        //Halb
        grid_add_pixel(0,4);
        grid_add_pixel(1,4);
        grid_add_pixel(2,4);
        grid_add_pixel(3,4);
    }
    else if(minutes >= 40 && minutes < 45)
    {
        //Zehn
        grid_add_pixel(6,1);
        grid_add_pixel(7,1);
        grid_add_pixel(8,1);
        grid_add_pixel(9,1);
        //Nach
        grid_add_pixel(0,3);
        grid_add_pixel(1,3);
        grid_add_pixel(2,3);
        grid_add_pixel(3,3);
        //Halb
        grid_add_pixel(0,4);
        grid_add_pixel(1,4);
        grid_add_pixel(2,4);
        grid_add_pixel(3,4);
    }
    else if(minutes >= 45 && minutes < 50)
    {
        //Viertel
        grid_add_pixel(3,2);
        grid_add_pixel(4,2);
        grid_add_pixel(5,2);
        grid_add_pixel(6,2);
        grid_add_pixel(7,2);
        grid_add_pixel(8,2);
        grid_add_pixel(9,2);
        //Vor
        grid_add_pixel(6,3);
        grid_add_pixel(7,3);
        grid_add_pixel(8,3);
    }
    else if(minutes >= 50 && minutes < 55)
    {
        //Zehn
        grid_add_pixel(6,1);
        grid_add_pixel(7,1);
        grid_add_pixel(8,1);
        grid_add_pixel(9,1);
        //Vor
        grid_add_pixel(6,3);
        grid_add_pixel(7,3);
        grid_add_pixel(8,3);

    }
    else if(minutes >= 55 && minutes < 60)
    {

        //Fünf
        grid_add_pixel(1,1);
        grid_add_pixel(2,1);
        grid_add_pixel(3,1);
        grid_add_pixel(4,1);
        //Vor
        grid_add_pixel(6,3);
        grid_add_pixel(7,3);
        grid_add_pixel(8,3);
    }

    //Stunden auf 12h-Format Konvertieren
    if(hours >= 12)
    {
        hours -= 12;
    }

    if(minutes >= 20)
    {
        hours++;
    }
    if(hours == 12)
    {
        hours = 0;
    }



    switch(hours)
    {
    case 0:
        //Zwölf
        grid_add_pixel(0,9);
        grid_add_pixel(1,9);
        grid_add_pixel(2,9);
        grid_add_pixel(3,9);
        grid_add_pixel(4,9);
        break;
    case 1:
        //EIN(S)
        grid_add_pixel(2,7);
        grid_add_pixel(3,7);
        grid_add_pixel(4,7);
        if(minutes > 4)
        {
            grid_add_pixel(5,7);
        };
        break;
    case 2:
        //Zwei
        grid_add_pixel(6,8);
        grid_add_pixel(7,8);
        grid_add_pixel(8,8);
        grid_add_pixel(9,8);
        break;
    case 3:
        //Drei
        grid_add_pixel(0,7);
        grid_add_pixel(1,7);
        grid_add_pixel(2,7);
        grid_add_pixel(3,7);
        break;
    case 4:
        //Vier
        grid_add_pixel(1,6);
        grid_add_pixel(2,6);
        grid_add_pixel(3,6);
        grid_add_pixel(4,6);
        break;
    case 5:
        //Fünf
        grid_add_pixel(2,8);
        grid_add_pixel(3,8);
        grid_add_pixel(4,8);
        grid_add_pixel(5,8);
        break;
    case 6:
        //Sechs
        grid_add_pixel(5,7);
        grid_add_pixel(6,7);
        grid_add_pixel(7,7);
        grid_add_pixel(8,7);
        grid_add_pixel(9,7);
        break;
    case 7:
        //Sieben
        grid_add_pixel(4,5);
        grid_add_pixel(5,5);
        grid_add_pixel(6,5);
        grid_add_pixel(7,5);
        grid_add_pixel(8,5);
        grid_add_pixel(9,5);
        break;
    case 8:
        //Acht
        grid_add_pixel(0,5);
        grid_add_pixel(1,5);
        grid_add_pixel(2,5);
        grid_add_pixel(3,5);
        break;
    case 9:
        //Neun
        grid_add_pixel(6,4);
        grid_add_pixel(7,4);
        grid_add_pixel(8,4);
        grid_add_pixel(9,4);
        break;
    case 10:
        //Zehn
        grid_add_pixel(5,6);
        grid_add_pixel(6,6);
        grid_add_pixel(7,6);
        grid_add_pixel(8,6);
        break;
    case 11:
        //Elf
        grid_add_pixel(0,8);
        grid_add_pixel(1,8);
        grid_add_pixel(2,8);
        break;
    }
    if(minutes < 5)
    {
        grid_add_pixel(7,9);
        grid_add_pixel(8,9);
        grid_add_pixel(9,9);
    }


}

void array_to_line(uint8_t *array)
{

    for(uint8_t x = 0; x<10; x++)
    {
        for(uint8_t y = 0; y<10; y++)
        {
            grey_line[karth_to_line(x,y)] = array[x*10+y];
        }
    }


}

void grid_add_pixel(uint8_t x,uint8_t y)
{

    grid[x][y] = 1;

}
void grid_flush(void)
{

    for(uint8_t i=0; i<10; i++)
    {
        for(uint8_t j=0; j<10; j++)
        {
            grid[i][j] = 0;
        }
    }

}

void assemble_line(uint8_t mode)
{

    //Mode 1 = Faden
    //Mode X = Static On
    //Mode 2 = Nightmode
    //GreyLine Buffern
    buffer_grey_line();
    //Array in Line convertieren
    init_grey_line();

    array_to_line(&grid[0][0]);




    //Löschen der Line
    init_line();

    if(mode == 1)
    {

        for (int i=0; i<100; i++)
        {

            if((grey_line[i] == 0) && (grey_line_buffer[i] == 0))
            {
                line[i] = 0b10000000;
            }
            if((grey_line[i] == 1) && (grey_line_buffer[i] == 1))
            {
                //ON
                line[i] = globalcoloron;
            }
            if((grey_line[i] == 1) && (grey_line_buffer[i] == 0))
            {
                //Fade On
                line[i] = globalcolor_fade_on;
            }
            if((grey_line[i] == 0) && (grey_line_buffer[i] == 1))
            {
                //Fade Off
                line[i] = globalcolor_fade_off;
            }


        }
    }
    else if(mode == 2)
    {
        for(uint8_t i = 0; i<100; i++)
        {
            if(grey_line[i] == 1)
            {
                line[i] = globalcolor_fade_on;

            }
        }

    }
    else
    {
        for(uint8_t i = 0; i<100; i++)
        {
            if(grey_line[i] == 1)
            {
                line[i] = globalcoloron;

            }
        }
    }

}



void send_line(uint8_t effect)
{

    if((effect == 1) && (minutes%5 == 0))
    {


        for(uint8_t j=0; j<10; j++)
        {
            if(minutes < 5)
            {
                time_to_array(hours-1,59);
            }
            else
            {
                time_to_array(hours,minutes-5);
            }



            grid_push_down(j);
            assemble_line(0);
            for(uint8_t i=0; i<100; i++)
            {
                master_transmit(line[i]);
            }
            SHOW;
            _delay_ms(300);
        }

        for(uint8_t j=0; j<10; j++)
        {
            time_to_array(hours,minutes);
            grid_push_up(10-j);
            assemble_line(0);
            for(uint8_t i=0; i<100; i++)
            {
                master_transmit(line[i]);
            }
            SHOW;
            _delay_ms(300);

        }
        time_to_array(hours,minutes);
        assemble_line(0);

        for(uint8_t i=0; i<100; i++)
        {
            master_transmit(line[i]);
        }
        SHOW;
        _delay_ms(300);

    }
    else
    {
        for(uint8_t i=0; i<100; i++)
        {
            master_transmit(line[i]);

        }
        SHOW;
    }


}

///<____MATRIX EFFECT
void matrix_effect(void)
{

    uint8_t x,y,uart_zeichen;
    uint8_t feld[10][10];
    init_strip();

    //PWM AN, falss Nightmode sie aus gemacht hat
    PWM_AN;
    //Feld nullen
    for(uint8_t i = 0; i<10; i++)
    {
        for(uint8_t j = 0; j<10; j++)
        {
            feld[i][j] = 0;
        }
    }

    ///Bit von oben einfüllen

    while(1)
    {


        if(rand() % 4 > 1)

        {
            do
            {
                x = rand()%10;
                y = 9 - rand()%2;
            }
            while((feld[x][y] == 1)||(feld[x][y-1] == 1)||(feld[x][y-2] == 1));


            feld[x][y] = 1;

        }
        //Array nach unten kopieren


        for(uint8_t yc = 0; yc <9; yc++)
        {
            for(uint8_t xc = 0; xc <10; xc++)
            {
                feld[xc][yc] = feld[xc][yc+1];
            }
        }
        for(uint8_t xc = 0; xc <10; xc++)
        {
            feld[xc][9] = 0;
        }



        ///Feld Ausgeben
        for(uint8_t x = 0; x<10; x++)
        {
            for(uint8_t y = 0; y<10; y++)
            {
                if(feld[x][y]==1)
                    put_pixel_on_strip(x,y,2,0,1,0);
            }
        }

        if((UCSRA & (1<<RXC)))
        {
            uart_zeichen = UDR;
            if(uart_zeichen == 'e')
            {
                //PWM aus, wenn nightmode an!
                if(nightmode)
                {
                    PWM_AUS;
                }
                return;
            }
        }
        _delay_ms(900);

    }
}


void set_global_colors(uint8_t r,uint8_t g,uint8_t b)
{

    //OFF  00
    //ON   01
    //FON  10
    //FOFF 11
    //BBRRGG

    //BB
    globalcoloron = 0b10000000 | (b<<4 & 0b10000);
    //RR
    globalcoloron |= (r<<2 & 0b100);
    //GG
    globalcoloron |= g;
    //BB
    globalcolor_fade_on = 0b10000000 | (b<<5 & 0b100000);
    //RR
    globalcolor_fade_on |= (r<<3 & 0b1000);
    //GG
    globalcolor_fade_on |= (g<<1 & 0b10);

    //BB
    globalcolor_fade_off = 0b10000000 | (b<<5 & 0b100000);
    globalcolor_fade_off |= (b<<4 & 0b10000);
    //RR
    globalcolor_fade_off |= (r<<3 & 0b1000);
    globalcolor_fade_off |= (r<<2 & 0b100);
    //GG
    globalcolor_fade_off |= (g<<1 & 0b10);
    globalcolor_fade_off |= g;

    if(r)
    {
        global_r = 1;
    }
    else
    {
        global_r = 0;
    }

    if(g)
    {
        global_g = 1;
    }
    else
    {
        global_g = 0;
    }
    if(b)
    {
        global_b = 1;
    }
    else
    {
        global_b = 0;
    }

}

void grid_push_up(uint8_t n)
{

    for(uint8_t k=0; k<n; k++)
    {
        for(uint8_t x = 0; x<10; x++)
        {
            for(uint8_t y = 0; y<9; y++)
            {
                grid[x][y] = grid[x][y+1];
            }
        }
        for(uint8_t x = 0; x<10; x++)
        {
            grid[x][9] = 0;
        }
    }



}
void grid_push_down(uint8_t n)
{

    for(uint8_t k=0; k<n; k++)
    {
        for(uint8_t x = 0; x<10; x++)
        {
            for(uint8_t y = 9; y>0; y--)
            {
                grid[x][y] = grid[x][y-1];
            }
        }
        for(uint8_t x = 0; x<10; x++)
        {
            grid[x][0] = 0;
        }
    }


}

uint8_t get_color_code(uint8_t r,uint8_t g,uint8_t b,uint8_t modr,uint8_t modg,uint8_t modb,uint8_t latch)
{

    //MOD 0 = FADE ON
    //MOD 1 = ON
    //MOD 2 = FADE OFF

    //OFF  00
    //ON   01
    //FON  10
    //FOFF 11
    //BRG

    uint8_t color = 0b00000000;
    if(latch)
    {
        color |= 0b10000000;
    }

    //ROT
    if(r)
    {
        switch(modr)
        {
        case 0:
            color |= 0b00001000;
            break;
        case 1:
            color |= 0b00000100;
            break;
        case 2:
            color |= 0b00001100;
            break;
        }
    }
    //BLAU
    if(b)
    {
        switch(modb)
        {
        case 0:
            color |= 0b00100000;
            break;
        case 1:
            color |= 0b00010000;
            break;
        case 2:
            color |= 0b00110000;
            break;
        }
    }
    //GRÜN
    if(g)
    {
        switch(modg)
        {
        case 0:
            color |= 0b00000010;
            break;
        case 1:
            color |= 0b00000001;
            break;
        case 2:
            color |= 0b00000011;
            break;
        }
    }

    return color;

}


void put_pixel_on_strip(uint8_t x,uint8_t y,uint8_t modus,uint8_t r,uint8_t g,uint8_t b)
{


    for (int i = 0; i<=100; i++)
    {
        //Push Dummy Bytes
        master_transmit(0b00000000);
    }

    master_transmit(get_color_code(r,g,b,modus,modus,modus,1));
    for (int i = karth_to_line(x,y); i>0; i--)
    {
        //Push Dummy Bytes
        master_transmit(0b00000000);
    }
    SHOW;

}


uint8_t karth_to_line(uint8_t x,uint8_t y)
{

    if((y%2 == 0) || (y == 0))
    {
        return (y*10+(9-x));

    }
    else
    {
        return (y*10+x);
    }


}
void buffer_grey_line(void)
{

    init_grey_line_buffer();
    for(uint8_t i=0; i<100; i++)
    {
        grey_line_buffer[i] = grey_line[i];
    }

}



void heart(void)
{

    init_strip();
    put_pixel_on_strip(4,1,0,1,0,0);
    put_pixel_on_strip(5,1,0,1,0,0);
    put_pixel_on_strip(3,2,0,1,0,0);
    put_pixel_on_strip(6,2,0,1,0,0);
    put_pixel_on_strip(2,3,0,1,0,0);
    put_pixel_on_strip(7,3,0,1,0,0);
    put_pixel_on_strip(1,4,0,1,0,0);
    put_pixel_on_strip(8,4,0,1,0,0);
    put_pixel_on_strip(1,5,0,1,0,0);
    put_pixel_on_strip(8,5,0,1,0,0);
    put_pixel_on_strip(4,5,0,1,0,0);
    put_pixel_on_strip(5,5,0,1,0,0);
    put_pixel_on_strip(2,6,0,1,0,0);
    put_pixel_on_strip(3,6,0,1,0,0);
    put_pixel_on_strip(6,6,0,1,0,0);
    put_pixel_on_strip(7,6,0,1,0,0);

    for (int i = 0; i<5; i++)
    {
        _delay_ms(2000);
    }

    if(!nightmode)
    {


        put_pixel_on_strip(4,1,2,1,0,0);
        put_pixel_on_strip(5,1,2,1,0,0);
        put_pixel_on_strip(3,2,2,1,0,0);
        put_pixel_on_strip(6,2,2,1,0,0);
        put_pixel_on_strip(2,3,2,1,0,0);
        put_pixel_on_strip(7,3,2,1,0,0);
        put_pixel_on_strip(1,4,2,1,0,0);
        put_pixel_on_strip(8,4,2,1,0,0);
        put_pixel_on_strip(1,5,2,1,0,0);
        put_pixel_on_strip(8,5,2,1,0,0);
        put_pixel_on_strip(4,5,2,1,0,0);
        put_pixel_on_strip(5,5,2,1,0,0);
        put_pixel_on_strip(2,6,2,1,0,0);
        put_pixel_on_strip(3,6,2,1,0,0);
        put_pixel_on_strip(6,6,2,1,0,0);
        put_pixel_on_strip(7,6,2,1,0,0);
    }
    _delay_ms(4000);
    _delay_ms(4000);


}

void init_main(void)
{
    DDRD = 0xFF;
    master_init();

    DDRA = 0xFF;

    //PWM
    TCCR2 |= (1<<WGM20) | (1<<COM21) | (1<<CS22) | (1<<CS20);
    OCR2 = 125;

    init_line();
    init_strip();


    //INIT KEYSHICE




    ///*UART Init*/
    UBRRH=UBRR_VAL >> 8;
    UBRRL = UBRR_VAL & 0xFF;
    UCSRB |= (1<<RXEN);
    UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);

}


void init_line(void)
{
    for(uint8_t i=0; i<100; i++)
    {
        line[i] = 0b10000000;
    }
}
void init_strip(void)
{
    for(uint8_t i = 0; i<100; i++)
    {
        master_transmit(0b10000000);
    }
    SHOW;
}
void init_grey_line(void)
{
    for(uint8_t i=0; i<100; i++)
    {
        grey_line[i] = 0;
    }
}
void init_grey_line_buffer(void)
{
    for(uint8_t i=0; i<100; i++)
    {
        grey_line_buffer[i] = 0;
    }
}



void master_init (void)
{
    DDRB = _BV(PB4) | _BV(PB5) | _BV(PB7);    // setze SCK,MOSI,PB0 (SS) als Ausgang
    DDRB &= ~_BV(PB6);              // setze MISO als Eingang
    PORTB = _BV(PB5) | _BV(PB4);        // SCK und PB0 high (ist mit SS am Slave verbunden)
    SPCR = _BV(SPE) | _BV(MSTR) | _BV(SPR0);  //Aktivierung des SPI, Master, Taktrate fck/16
    status = SPSR;                //Status löschen
}

void master_transmit (uint16_t data)
{
    PORTB &= ~_BV(PB4);            //SS am Slave Low --> Beginn der Übertragung
    SPDR = data;                //Schreiben der Daten
    while (!(SPSR & (1<<SPIF)));
    //PORTB |= _BV(PB4);              //SS High --> Ende der Übertragung
}
void flush(void)
{
    init_line();
    init_grey_line();
    init_grey_line_buffer();
    init_strip();
}

void display_time(uint8_t fade, uint8_t effect)
{
    time_to_array(hours,minutes);
    if(!nightmode)
    {
        assemble_line(fade);
        send_line(effect);
    }
    else
    {
        assemble_line(2);
        send_line(0);
    }


}



int main (void)
{
    uint8_t hours_buffer,minutes_buffer;
    uint8_t fade = 0, effect = 0;
    uint8_t uart_zeichen;
    init_main();



    ///TODO
    /*
    Helligkeit prüfen

    ADC ANBINDUNG FÜR HELLIGKEITSSENSOR

    Einstellungen auf Speicher in RTC Speichern

    RTC Anbindung

    */






    set_global_colors(ROT);

    flush();
    while(1)
    {

        PORTA |= (1<<5);

        ///Machtmodus an!
        nightmode = nightmode;
        ///


        //Buffer old time, um nicht unnötige Displayrefreshs zu machen
        minutes_buffer = minutes;
        hours_buffer = hours;

        ///GET TIME FROM RTC
//        minutes = minutes;
//        hours = hours;
        minutes = TWI_GET(0x01);
        minutes = (minutes&0b00001111) + ((minutes&0b01110000)>>4) * 10;
        hours = TWI_GET(0x02);
        hours = (hours&0b00001111) + ((hours&0b01110000)>>4) * 10;
        ///


        if((UCSRA & (1<<RXC)))
        {
            uart_zeichen = UDR;

            switch(uart_zeichen)
            {
            case 'h':
                hours++;
                if(hours >= 24)
                {
                    hours = 0;
                }
                TWI_SEND(0x00,0x00);
                SET_TIME(hours,minutes);
                break;
            case 'm':
                minutes+=1;
                if(minutes > 59)
                {
                    minutes = 0;
                    hours++;
                }
                if(hours >= 24)
                {
                    hours = 0;
                }
                TWI_SEND(0x00,0x00);
                SET_TIME(hours,minutes);
                break;
            case 'b':
                set_global_colors(BLAU);
                display_time(fade,effect);
                break;
            case 'g':
                set_global_colors(GRUEN);
                display_time(fade,effect);
                break;
            case 't':
                set_global_colors(TURKIS);
                display_time(fade,effect);
                break;
            case 'r':
                set_global_colors(ROT);
                display_time(fade,effect);
                break;
            case 'l':
                set_global_colors(LILA);
                display_time(fade,effect);
                break;
            case 'o':
                set_global_colors(ORANGE);
                display_time(fade,effect);
                break;
            case 'w':
                set_global_colors(WEISS);
                display_time(fade,effect);
                break;
            case 'x':
                heart();
                display_time(fade,effect);
                break;
            case 'e':
                matrix_effect();
                init_strip();
                display_time(fade,effect);
                break;
            case '1':
                fade = 0;
                effect = 0;
                display_time(fade,effect);
                break;

            case '2':
                fade = 1;
                effect = 0;
                display_time(fade,effect);
                break;

            case '3':
                fade = 0;
                effect = 1;
                display_time(fade,effect);
                break;
            case '4':
                if(nightmode)
                {
                    PWM_AN;
                    nightmode = 0;
                }
                else
                {
                    PWM_AUS;
                    nightmode = 1;
                }

                display_time(fade,effect);
                break;
            }


        }

        if(!nightmode)
        {
            PWM_AN;
        }

        switch(minutes%5)
        {
            case 0:PORTA = 0b00000000;break;
            case 1:PORTA = 0b00000001;break;
            case 2:PORTA = 0b00000011;break;
            case 3:PORTA = 0b00000111;break;
            case 4:PORTA = 0b00001111;break;
        }


        ///Update nur wenn zeit verändert

        if((hours_buffer!=hours) || (minutes_buffer!=minutes))
        {
            display_time(fade,effect);
        }

        ///ZEIT DEBUG


//minutes += 5;
        _delay_ms(50);
        PORTA &= ~(1<<5);

    }
    return 0;
}

i2c.c

#include <util/twi.h>




#define   START           0x08

#define     WRITE           0
#define     READ            1
#define   MT_DATA_ACK     0x28
#define     MT_SLA_ACK      0x40

#define     ADRESSE        0b11010000

#define     REGISTER_SEC    0x00
#define     REGISTER_MIN    0x01
#define     REGISTER_HOUR   0x02

void ERROR(void)
{
    ///:P

}


void TWI_START(void)
{
    ///Startconditions
    TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
    ///Wait für TWINT Flag -> START condition set!
    while (!(TWCR & (1<<TWINT)));
    ///Errorhandling
    if ((TWSR & 0xF8) != START) ERROR();
}

void TWI_SLA_ADRESS(uint8_t rw)
{

    ///Adress and W
    TWDR = ADRESSE | rw;
    ///Starts Transmittion
    TWCR = (1<<TWINT) | (1<<TWEN);



}

void TWI_ACK(void)
{

    ///ACK Received?
    while (!(TWCR & (1<<TWINT)));
    ///Errorhandling
    if ((TWSR & 0xF8) != MT_SLA_ACK) ERROR();
}

void TWI_NAK(void)
{
   TWCR = (1<<TWINT) | (1<<TWEN);
  while(!(TWCR & (1<<TWINT)));


}


void TWI_DATA(uint8_t DATA)
{
    ///Datasend
    TWDR = DATA;
    TWCR = (1<<TWINT) | (1<<TWEN);
    ///Data has been send?
    while (!(TWCR & (1<<TWINT)));
    ///Errorhandling
    if ((TWSR & 0xF8) != MT_DATA_ACK)
        ERROR();
}


void TWI_STOP(void)
{
    ///Stop
    TWCR = (1<<TWINT)|(1<<TWEN)|
           (1<<TWSTO);
}


uint8_t TWI_READ(void)
{


    TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);
    while(!(TWCR & (1<<TWINT)));

    return TWDR;



}

uint8_t TWI_GET (uint8_t ADDR)
{
    uint8_t x;
    TWI_START();
    TWI_SLA_ADRESS(WRITE);
    TWI_ACK();
    TWI_DATA(ADDR);
    TWI_ACK();
    TWI_START();
    TWI_SLA_ADRESS(READ);
    TWI_ACK();
    x = TWI_READ();
    TWI_NAK();
    TWI_STOP();
    return x;
}


void TWI_SEND (uint8_t reg, uint8_t data)

{


    TWI_START();
    TWI_SLA_ADRESS(WRITE);
    TWI_ACK();
    TWI_DATA(reg);
    TWI_ACK();
    TWI_DATA(data);
    TWI_NAK();
    TWI_STOP();
}

settime.c

void SET_TIME ( uint8_t stunden,uint8_t minuten)
{
    uint8_t byte=0,modulus,buffer;




    buffer = (minuten - (minuten % 10)) / 10;
    byte = (buffer << 4) & 0b01110000;
    byte |= ((minuten % 10) & 0b00001111);



    TWI_START();
    TWI_SLA_ADRESS(WRITE);
    TWI_ACK();
    TWI_DATA(REGISTER_MIN);
    TWI_ACK();
    TWI_DATA(byte);
    TWI_NAK();
    TWI_STOP();

    if(stunden < 10)
    {
        byte = stunden;
    }
    else if(stunden < 20)
    {
        byte = stunden%10;
        byte |= 0b00010000;
    }
    else
    {
        byte = stunden%10;
        byte |= 0b00100000;
    }




    TWI_START();
    TWI_SLA_ADRESS(WRITE);
    TWI_ACK();
    TWI_DATA(REGISTER_HOUR);
    TWI_ACK();
    TWI_DATA(byte);
    TWI_NAK();
    TWI_STOP();



}

[Udo S. (urschmitt)]

Mike Mike schrieb:
> "Leider" hängt er sich in keiner Schleife auf.

Ein Prozesser arbeitet einen Befehl ab und dann den nächsten.
Entweder er macht einen Reset (Brown out oder was anderes) oder er loopt 
irgendwo.
Wo musst du herausfinden.
Zerlege dein Programm in logische Blöcke
Prüfe zuerst in welchem Block er hängt.
Wenn du das weisst dann zerlege weiter.

Mike Mike schrieb:
> Und das Programm ist sehr komplex
Wirklich komplex oder Spagetticode, also nicht strukturiert.
Dann ist jetzt der Zeitpunkt Struktur reinzubringen.

[mike (Gast)]

Spagetticode? Wo fehlt es da an Struktur?

Ich bin gerade dabei und checke an verschiedenen Stellen gerade ab wo er 
sich aufhängt. Problem ist nur, dass es zwischen 10 bis 60 minuten 
dauern kann

[Purzel H. (hacky)]

Debuggen... Ist eine Kunst fuer sich. Schmeiss mal den Display raus, 
lass alternativ eine Led einmal pro Sekunde blinken. Wenn ein UART 
vorhanden ist, verwende das UART zum debuggen.

Ich sah eine beliebige Anzahl Warteschleifen. Das sollte man vermeiden. 
Mach eine Zustandsmschine und warte nur an einem Ort. Den Zustand kann 
man zB per UART , oder per blinkender LED mitteilen, dann weiss man wo 
der Code am Warten ist.

[MWS (Gast)]

Grausamer Code.
Würde die TWI-Routinen um ein Timeout mit Recovery erweitern. Die RTC 
wird im 50ms Rhythmus abgefragt, sobald die hängt, steht alles.

[mike (Gast)]

Zu der RTC, ich habe bisher noch keinen internen Timer Programmiert, 
weil ich noch nicht so weit war, aber genau das könnte das Problem sein.

Warum sollte ich ein delay im jetzigen Zustand vermeiden? Da passiert 
doch nichts anderes, als dass er so und soviel Prozessortakte nichts 
macht.
Für meine Anwendung ist das doch so völlig in Ordnung im Moment.
Wenn ich später den Timer für die Uhr laufen lasse, dann kann ich die 
Delays rausschmeissen.

Im übrigen warte ich 50ms, um sehen zu können, ob die DebugLed Flackert 
oder statisch leuchtet.

Ich werde das ganze jetzt mal mit einem internen Timer Umschreiben, denn 
es könnte echt an der sich aufhängenden RTC liegen

[MWS (Gast)]

mike schrieb:
> Ich werde das ganze jetzt mal mit einem internen Timer Umschreiben,

Gute Entscheidung.

Sowas könnte auch helfen:

   toctr = 1;
   while((!(TWCR & (1<<TWINT))) & toctr)
      toctr++;
   if (!toctr)
      {
         // Fehlerbehandlung, TWI de-/reaktivieren
      }

[mike (Gast)]

Hi, das verstehe ich jetzt nicht ganz, toctr wird doch in dem Fall nie 
0?

Ich hätte jetz das Timeout anderst gelöst, indem ich mir den Aktuellen 
Timer Wert in der while Schleife geholt hätte, und ab einer gewissen 
Differenz, hätte ich abgebrochen und die Kommunikation neu gestartet

[mike (Gast)]

Ah, du wartest darauf, bis toctr überläuft und wieder 0 wird?

[Sam .. (sam1994)]

mike schrieb:
> Spagetticode? Wo fehlt es da an Struktur?

Deine gesamte time_to_array funktion schreibt man elegant in max. 50 
Zeilen. Dafür nutzt man Daten-Arrays von denen die "Pixel" ins Array 
kopiert werden. Du wirst sehen, dass der Code nicht nur kürzer wird, die 
Performance wird auch erheblich steigen.

[MWS (Gast)]

mike schrieb:
> Ah, du wartest darauf, bis toctr überläuft und wieder 0 wird?

Yep. Kannst auch von einem vorgegebenen Wert runterzählen, wenn Dir das 
logischer erscheint, Ergebnis ist gleich.

mike schrieb:
> Ich hätte jetz das Timeout anderst gelöst, indem ich mir den Aktuellen
> Timer Wert in der while Schleife geholt hätte, und ab einer gewissen
> Differenz, hätte ich abgebrochen und die Kommunikation neu gestartet

Geht auch. Aber hier geht's ja nicht um gutes Timing, sondern nur um die 
Unterscheidung lebt / tot.

[Mike M. (mikeii)]

@Samuel, danke für den Tipp

@MWS

Habe es jetzt mal komplett entkoppelt, und lasse nur ca. alle 70 
Sekunden einen Uhrzeitabgleich machen, das ganze läuft bisher ohne 
Hänger.

Muss noch die Zeit "richtig" von der RTC entkoppeln, aber zumindest weiß 
ich jetzt, dass der Fehler an der I2C Kommunikation lag.

Danke dir :)

[Mike M. (mikeii)]

Mal eine andere Frage, wäre es verwerflich, wenn ich im Sekundentakt die 
RTC Abfragen würde?
Ergeben sich dadurch Nachteile für mich?