AVR Freaks

Ok, so basically you are going for project number 2 on your list. I think it's a good choice, because using a LED matrix you will have total control over the display, that is, you need to write everything.

Learning about multiplexing, display memory and stuff like that is important. For this, you should buy LED matrices that do not come with a controller, this way you will need to implement the control stuff yourself using the ATMega.

Instead of a 16x8 display, it will be cheaper for sure to get 2x 8x8 LED matrices.

You will need a MCU with plenty of pins, so I guess a 40 pin DIP like the Mega32 is ok. If you want to be adventurous and try out the new generation of MCUs, the Mega4809 also comes in a 40 pin DIP version. But in this case I guess you should stick to the mega32, there is much more info.

Soon, you will discover that the MCU can't handle the necessary current for the display. The chip you will need is the ULN2803A.

Your display setup would be something like this, but with 16 columns instead of 5 (adapted from https://www.mikrocontroller.net/...):

Ok, so basically you are going for project number 2 on your list. I think it's a good choice, because using a LED matrix you will have total control over the display, that is, you need to write everything.

Learning about multiplexing, display memory and stuff like that is important. For this, you should buy LED matrices that do not come with a controller, this way you will need to implement the control stuff yourself using the ATMega.

Alright. Most of the LED Matrix I see in local stores don't come with any datasheet attached so I can't really write which model I'm planning on buying. Anyways, here are some links: 1 2 3. Those don't come with any controller I suppose, so any of them should work (?).

Instead of a 16x8 display, it will be cheaper for sure to get 2x 8x8 LED matrices.

We thought about this aswell. What drove us away was the fact that we thought it would be harder to code 2x8 matrix instead of a 1x16 one (given that, in the game Snake i.e., we would need to constantly send data to BOTH the matrix). Nonetheless, if that's your suggestion, I will happily take it!

  You will need a MCU with plenty of pins, so I guess a 40 pin DIP like the Mega32 is ok. If you want to be adventurous and try out the new generation of MCUs, the Mega4809 also comes in a 40 pin DIP version. But in this case I guess you should stick to the mega32, there is much more info.

We noticed that (the fact that we needed lots of pins), that's why we didn't choose our default ATMega328p and instead went with the 32 version.

  Soon, you will discover that the MCU can't handle the necessary current for the display. The chip you will need is the ULN2803A

Will search about it tomorrow. Had no idea about that! 

About the image, how do I connect 16 data lines to the ATMega32 (given that I don't have those much pins)?

Also, I asked my teacher about a protocol named SPI (in order to connect the display to the ATMega, many projects referenced the use of this protocol). What he told me was that I could use the SPI library if I know what the code does (since I need to explain and present the work to my class, I will need to explain each line in case someone has any doubt). With this, he also told me that he would not take this part of the code into account when giving us our grade (it basically counts for nothing). I'm still unsure if that's bad or if it doesn't matter much. Any way of getting around that (from what I read / heard, creating an SPI protocol by myself isn't something THAT easy).

What do you mean?  I think there are enough pins. You need 16 + 8 pins total for display control. There are still 8 more left for other things, like control buttons and UART interface if needed. If you load a bootloader on the chip, the UART can also be used to upload firmware.

I thought that I could only connect my display to the ADC pins on the ATMega (every project I've seen connects it this way so I thought that it was needed). With this, can I simply connect the 24 pins needed in any ATMega Pin I want? (besides the ones in which I'll place my external oscilator, vcc, aref, etc,etc)

Well, not exactly, you need to respect the current limits indicated in the datasheet, since the AVR is sourcing all the current. The current then sinks through the ULN chip, which can handle lots of current, so that shouldn't be a problem.

For example, if each LED needs 10mA, you may need a maximum of 160mA (only one row is on at any moment in the multiplexing scheme). This is within the total limit (200mA), but you need to source half from port A and the other half from one of ports B, C or D to be within the 100mA port group limit.

edit: in practice, there will be problems with voltage drops on the AVR and ULN pins possibly causing uneven LED brightness. These are real world problems that I think you, as a student, need to experience yourself, that's how humans learn best. Analysing these kind of things will also help to beef up your report later and maybe get a better grade.

I've seen multiple projects using the Nokia 5510 display (I think one of them was linked in my previous response) but I kinda forgot it as I didn't find any datasheets / thought the LED Matrix was easier to code. It can also be a solution though!

Just to noted that the Nokia 3310 display is 84x84 pixels. It looks like in the game there is a bit of a border so maybe call the active area 80x80 then the snake/etc are about 4 pixels wide so reduce that by /4 and the active area is 20x20. I do wonder if 16x8 (done as LED) will be enough "pixels" ?

 Not sure whether or not it's enough. The idea (if I choose to go with the LED matrix) will be to implement a 16x16 matrix (2* 8x8 LED Matrix) or one 16x16. Otherwise, like others suggested, I could use a nokia 5510 (or another model like you mentioned) and figure that out then.

Update:

After buying my microcontroller (ATMega32) and some other components I was missing, I'm now at this stage (Image 1):

• Created a simple voltage regulator circuit (since I have a 12V battery, I'm using a LM7805 voltage regulator in order to supply 5V to my micro).
• Added a 10Mhz crystal in order to get more accurate time measurements. This means that TimerCounters / Interrupts will be more precise.

With this, I still haven't connected my LED Matrix. I'm going to use 4x(5*8) Led Matrix (TA16-11GWA by Kingbright). Read the datasheet and understood what was needed in order for each LED to work. 

Given this, my idea is to connect all 4x14 pins (there are 14 pins in each Led Matrix) to my ATMega32 (with the help of 4x[14*1k] resistors in order to protect the matrix). I would then set each pin to a high level (no LED is turned on given that there's no voltage drop between the anode and the cathode of the LED). With this, whenever I want to turn a specific LED on, I would simply need to set the respective cathode pin to 0 (low). I'm still brainstorming on how to do this but my idea is to create a function which recieves, by parameters, the number of the line and the column of that specific LED. With this, I would know which led is it and set the pins in order to turn it on / off.

Is something like this a good approach or am I on a constant stupidity loop?

This seems really confusing and I'm not even thinking on how to build the game yet.. Just interfacing the matrix lol.

One question as well:

Given that I'll be using an external 10 Mhz crystal, do I need to turn off my micro's internal oscillator / mess with its' fuses?

EDIT1: Thinking about it, I can't even connect 4*14 pins to my ATMega32. Am I beeing stupid or is it really impossible to connect 4 matrix to this ATMega (given the number of pins avaliable)? Can stick with just 2 led matrix if needed.

Bough this micro because of the number of pins tbh. I really don't know much about each micro besides the basic features like memory, speed, pins, etc...

Would the 324P be a massive improvement over this? I have some on school (can rent them basically). Sad that I bought this one online though 

Got it. Will take that into account and if needed, I'll make the switch. Beeing fully compatible is a big plus in this scenario. Thanks for the suggestion!

When I first studied micros, I had an atmega board with a 7 segment display just like that. I controlled all 4 digits and I never knew how it was wired/connected on the inside. I guess I now know.

Thanks for clearing it up and helping me understand how multiplexing / interfacing these kind of displays works.

How could you have written software to drive it without knowing the layout? Or are you saying it just came with some pre-made display_7seg(...) or similar that you just called without knowing what was going on inside?

When I had that subject, everything was already built. Everything was connected inside so all we had to do was code the pins. I attatched an image so you could understand what I was dealing with. The teacher would ask us to make a led blink or things like that so we would only have to worry about coding. Wiring, building and interfacing the ATMega + the components was already done.

To be honest, it was hard at first because I had never coded anything like that but I would have prefered to know how to wire a micro with other components (i.e., the 7 segment display, a buzzer, etc.) since it would have helped me massively at the moment. Nonetheless, I try my best to study and understand it alone.

The key thing about multiplexing (esp if not current limiting) is often "never stop" ! If you don't keep hopping from one to the next and only illuminating each for a short time (essentially "PWM") then you can stop with one fixed  pattern that sucks huge current and lets the smoke dragon out of its cave !

Will pay attention while doing the routines / using the interruptions. Thank you! 

That means, for example, creating a LED.c file in order to interface the matrix with the atmega and such + a Snake.C in which I code the actual game itself, right? 

I was planning on starting by creating the LED.c file, that means, interfacing the display and the micro.

Sure. That's the obvious starting point and it's fine. I was just pointing out that you could start at either end. For example, if this was a team, each person could be working on a different section.

This one, of course. Sorry if I mislead you.

Considering what was suggested before (and hoping I didn't make any errors), this is the general schematic of the whole circuit:

I'm still missing connecting the required LED (for blinking purposes) and the push buttons / joystick in order to control the menus / ingame movements. Besides that, I think that everything else required is already connected.

But if I connect all of them to portA I would "lose" my ADC (I'm not sure if I need it for the joystick but still). As for portB, I'll be using the USBasp in order to transfer the code into the ATMega. Can I still use those ports for circuitry? (Kind of a dumb question but to be honest my first time using usbasp was barely 2 months ago).

I haven't decided yet (if I'm going for the simple push buttons or the joystick). Nonetheless, I'm not at home so I can't really link the one I saw. If, i.e., I would choose to go with push buttons (up, down, left, right), wouldn't need the adc right?

Alright. As for the other pins (MOSI, MISO, etc..) can I still use them for circuitry (given that I'll need them in order to connect my usbasp)? I've seen projects where these pins have nothing connected (which I'm not sure if it's because of this issue or if it was a simple coincidence) while others use them for circuitry (though most of them don't even show how they programmed the micro).

Having connected everything on the same port (using PA and PB for the LED Matrix columns), I now have the following circuit:

I also connected 4 push buttons in order to control the game (though the usage of a joystick could still be a possibility later on). Anyways, will build the circuit on 2 breadboards and proceed to code the led matrix and the game.

I hope you didn't connect it directly without the current limiting resistor. You risk burning the LED if you connect it directly as described.

PC0=0 is connecting PC0 to GND. However, the ULN chip is a kind of inverter, to connect the output of the ULN to GND, you need to connect the ULN input PCx to VDD, that is, PCx=1.

In fact you can see it described in the datasheet with the inverter symbol:

The COM pin is a return path for current when driving inductive loads (via internal diodes), so you only need to connect it when driving such loads, like motors. For LEDs, you can leave COM unconnected.

Quoting from the datasheet:

8.4.2 Resistive Load Drive

(...)The COM pin can be left floating for these applications.

Finally, you initialization function doesn't execute automatically. You need to call it from main():

int main(void) {
    inic();
    PORTA = (1<<PA0);
    PORTC = (0<<PC0);
}

Yes.

Update:

After dicussing the project with my professor and messing around with my circuit multiple times, I built the last version of my project (or at least I think so). It is supposed to run the game "Pong" in a 8x8 Led Matrix, using an ATMega32 as well as 2x 7 Segment Displays (with the help of a Shift Register and 2x 74LS47N chips).

Besides the components mentioned above, I also used 1x ULN2803 and 1x UDN2981A (I haven't tested the code yet since I can't buy this component, it either costs 15€ or it doesn't exist in a local market). Thought about using individual PNP transistors in order to imitate the UDN functioning but have no idea which ones to choose. I'm also having doubts on whether or not my Shift Registor connections are alright (I used an already made project to guide me through the coding / circuitry but seems weird connecting VCC / GND to other pins rather than the VCC / GND pins of the chip (lol). Would love some insight if someone cares to explain as I've never messed with shift registors (though I learnt some theory about how they work some years ago).

I will also post my code, even though I haven't commented everything (it's on my native language as well). If needed, I have no problem translating the comments. The code has 4 warnings while compiling, given the fact that some variables are declared / initialized but not used. I have no idea if this is ok to happen as I wrote my code according to the already made project I talked earlier. Nothing bad was reported so I figured that everything was up and running. Will read through the whole code and try to comment / understand as much as I can in order to explain if anyone has any doubt (meaning, not understanding why the use of this or that). The compiler also reported an error "_builtin_avr_delay_cycles expects a compile time integer constant”. I browsed online and found out that writing the line "#define __DELAY_BACKWARD_COMPATIBLE__" fixed this, no idea why.

Followed this project for circuitry + coding of the game PONG.

Feedback would be appreciated! Cheers!

#define __DELAY_BACKWARD_COMPATIBLE__
#include <avr/io.h>
#include <stdlib.h>
#define F_CPU 8000000UL                                                        // Oscilador interno a correr a 8MHz.
#include <util/delay.h>

#define nCol 8                                                                // Número de colunas = 8.
#define periodo 10                                                            // periodo = 10 ms.
#define DCycle 32                                                            // Respetivo ao funcionamento do buzzer.
#define CLK 0                                                                // Ligação ao ShiftRegister via PB0.
#define S_IN 1                                                                // Ligação ao ShiftRegister via PB1.
#define LATCH 2                                                                // Ligação ao ShiftRegister via PB2.
#define _B_TIME 200


//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------//
uint8_t column[nCol];
uint8_t l[12]={0,0,1,2,4,8,16,32,64,128,0,0};                                // Linhas para mapeamento.
uint8_t sw,sw1,sw2,score1,score2;                                            // Variáveis para controlo de scores, etc.
uint8_t PSPEED=10, BSPEED=20;                                                // Speed do jogador = 10.        Speed da bola = 20.
uint8_t go;

struct coord {
    int8_t x;
    int8_t y;
    
    int8_t old_x;
    int8_t old_y;
    
    int8_t speed_x;
    int8_t speed_y;
} coord;


//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------//
void inic(void);
void display(uint8_t *column);                                                // Demora "x" milisegundos (periodo) a realizar. uint8_t = unsigned integer of length 8 bits.

// Lê o estado de um botão (1=pressionado; 0=não pressionado).
uint8_t readButton(uint8_t index);                                            // Index: Define qual o botão a ler (Jogador 1: 1,2        Jogador 2: 3,4).

void start_buzzer();                                                        // Ativa o buzzer de forma a reproduzir som (só termina quando stop_buzzer() for chamada).
void stop_buzzer();                                                            // Termina a reprodução de som.
void single_beep(uint16_t d_ms);                                            // Faz o buzzer tocar durante "d_ms" (milisegundos).

void shift_data(uint8_t data);                                                // Utilizado à frente na função update_score();
void update_score(uint8_t score_p1, uint8_t score_p2);                        // Atualiza os scores de cada jogador (Jogador 1: p1    Jogador 2: p2).


//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------//
void inic_matrix(uint8_t *column) {
    uint8_t i;
    for (i=0; i<nCol; i++)
    column[i] = 0xFF;                                                        // Liga todos os leds da matriz.
}

void clear() {
    uint8_t i;
    for (i=0; i<nCol; i++) {
        column[i] = 0;                                                        // Desliga todos os leds da matriz.
    }
}

void long_display() {
    uint8_t i;
    for (i=0; i<50; i++) {
        display(column);
    }
}

void inicBall() {
    int8_t v[2]={-1,1};
    // int8_t v2[3]={-1,0,1};
    
    coord.x=3+rand()%2;
    coord.y=3+rand()%2;
    coord.old_x=coord.x;
    coord.old_y=coord.y;
    coord.speed_x=v[rand()%2];
    coord.speed_y=0;
    
    column[0]=column[7]=0x18;
}

void move_ball() {
    // uint8_t i;
    
    coord.old_x=coord.x;
    coord.x=coord.x + coord.speed_x;
    coord.old_y=coord.y;
    coord.y=coord.y + coord.speed_y;
    
    /* Codificação da colisão da bola na parede superior / inferior */
    
    if(coord.y==7 && coord.speed_y==1)
        coord.speed_y=-1;
    if(coord.y==0 && coord.speed_y==-1)
        coord.speed_y=1;
    
    sw1=0;
    sw2=0;
    
    /* Colisão com o jogador da direita */
    
    if(coord.x==6) {
        
        if((l[2+coord.y]+l[2+coord.y-1])==column[7]) {
            coord.speed_x=-1;
            if(coord.speed_y!=1)
            coord.speed_y++;
            
            sw2=1;
        }
        
        if ((l[2+coord.y+1]+l[2+coord.y])==column[7]) {
            coord.speed_x=-1;
            if(coord.speed_y!=-1)
            coord.speed_y--;
            
            sw2=1;
        }
        
        if (((l[2+coord.y+1]+l[2+coord.y+2])==column[7]) && (coord.speed_y==1)) {
            coord.speed_x=-1;
            coord.speed_y=-1;
            
            sw2=1;
        }
        
        if (((l[2+coord.y-1]+l[2+coord.y-2])==column[7]) && (coord.speed_y==-1)) {
            coord.speed_x=-1;
            coord.speed_y=1;
            
            sw2=1;
        }
    }
    
    /* Marcação de ponto - Jogador 1 */
    
    if (sw2==0 && coord.x==6) {
        score1++;
        go=1;
        update_score(score1,score2);
        
        column[7] = 255;
        column[coord.x]=l[2+coord.y];
        
        for (sw=0; sw<100; sw++)
        display(column);
        
        inicBall();
    }
    
    /* Colisão com o jogador da esquerda */
    
    if(coord.x==1) {
        
        if((l[2+coord.y]+l[2+coord.y-1])==column[0]) {
            coord.speed_x=1;
            if(coord.speed_y!=1)
            coord.speed_y++;
            
            sw1=1;
        }
        

        if ((l[2+coord.y+1]+l[2+coord.y])==column[0]) {
            coord.speed_x=1;
            if(coord.speed_y!=-1)
            coord.speed_y--;
            
            sw1=1;
        }
        

        if (((l[2+coord.y+1]+l[2+coord.y+2])==column[0]) && (coord.speed_y==1)) {
            coord.speed_x=1;
            coord.speed_y=-1;
            
            sw1=1;
        }

        if (((l[2+coord.y-1]+l[2+coord.y-2])==column[0]) && (coord.speed_y==-1)) {
            coord.speed_x=1;
            coord.speed_y=1;
            
            sw1=1;
        }
    }
    
    /* Marcação de ponto - Jogador 2 */
    
    if (sw1==0 && coord.x==1) {
        score2++;
        go=1;
        update_score(score1, score2);

        column[0]=255;
        column[coord.x]=l[2+coord.y];
        
        for (sw=0;sw<100;sw++)
        display(column);
        
        inicBall();
    }
    
    /* Condições para cantos do chão ??????? */
    
    if (coord.x==1 && coord.y==0 && coord.speed_y==-1)
    coord.speed_y=1;

    if (coord.x==6 && coord.y==0 && coord.speed_y==-1)
    coord.speed_y=1;

    if (coord.x==1 && coord.y==7 && coord.speed_y==1)
    coord.speed_y=-1;

    if (coord.x==6 && coord.y==7 && coord.speed_y==1)
    coord.speed_y=-1;
    
    /* Bola */
    
    column[coord.x]=l[2+coord.y];
}

void game() {
    uint8_t i;
    clear();
    
    column[0] = 0x18;
    column[7] = 0x18;
    sw1=0; sw2=0;
    score1 = 0; score2 = 0;

    uint8_t bot1 = 0, bot2 = 0, bot3 = 0, bot4 = 0;
    uint8_t counter = 0;
    uint8_t counter2 = 0;
    uint8_t c1 = column[0], c2 = column[7];

    inicBall();

    for(;;) {
        
        /* Leitura de botões */
        
        bot1 = readButton(1);
        bot2 = readButton(2);
        bot3 = readButton(3);
        bot4 = readButton(4);
        
        if(counter>PSPEED) {
            if (bot1) {
                if((column[7] << 1) <=192)
                c2 = column[7] = column[7] << 1;
            }

            if (bot2) {
                if((column[7] >> 1) >= 3)
                c2 = column[7] = column[7] >> 1;
            }

            if (bot3) {
                if((column[0] << 1) <=192)
                c1 = column[0] = column[0] << 1;
            }

            if (bot4) {
                if((column[0] >> 1) >= 3)
                c1 = column[0] = column[0] >> 1;
            }
            
            counter=0;
        }
        
        counter++;
        
        /* Atualização do score */
        
        if(score1>9 || score2>9) {
            score1=0;
            score2=0;
            update_score(score1,score2);
        }
        
        for(i=1; i<nCol-1; i++)
        column[i]=0;
        
        /* Movimento da bola */
        
        if(counter2>BSPEED) {
            move_ball();
            counter2=0;
        }
        counter2++;
        
        display(column);
    }
}

int main(void) {
    uint8_t column[nCol];
    
    inic();
    inic_matrix(column);
    update_score(0, 0);
    
    for(;;) {                                                                // Loop infinito.
        display(column);                                                    // Demora 10ms a executar.
    }
    
    return 0;
}

void inic(void) {
    DDRA = 0xFF;                                                            // Inicializa todos os pins do portA a saídas (leds da matriz).
    PORTA = 0x00;
    
    DDRD = 0xFF;                                                            // Inicializa todos os pins do portD a saídas (leds da matriz).
    PORTD = 0x00;
    
    DDRB &= 0xF0;                                                            // Inicializa os pinos 4,5,6 e 7 do portB a entradas (push buttons para jogar).
    DDRB |= 0x0F;                                                            // Inicializa os pinos 0,1,2 e 3 do portB a saídas (ShiftRegister: 0 a 2    Buzzer: 3).
    
    TCCR0 |= (1<<WGM01) | (1<<WGM00) | (1<<COM01) | (0<<CS02) | (1<<CS01) | (0<<CS00);// Fast PWM, Clear 0C0 on compare match (non-inv), precaler a 8.
    TCCR0 &= ~((1<<COM01) | (1<<COM00));                                    // Desativa o buzzer manualmente, para já.
}

void display(uint8_t *column) {
    uint8_t i;
    uint8_t sequencia;
    
    sequencia = 0x01;
    
    for(i=0;i<nCol;i++) {
        PORTA = sequencia;
        PORTD = column[i];
        
        _delay_ms(periodo / nCol);
        sequencia = sequencia << 1;
    }
}

uint8_t readButton(uint8_t index) {
    if (index < 1 || index > 4)                                                // Se o valor de index for menor que 1 ou maior que 4, return 0 visto que não estamos no intervalo definido
    return 0;                                                                // anteriormente (Botões: 1, 2, 3 e 4).
    
    return !(PINB & (0x10 << (index -1)));
}

void start_buzzer() {
    TCCR0 |= (1<<COM01);                                                    // Ativa buzzer.
    OCR0 = DCycle;                                                            // Define o sinal aplicado ao buzzer: V = Dcycle / (256*5)
}

void stop_buzzer() {
    TCCR0 &= ~((1<<COM01) | (1<<COM00));                                    // Desativa buzzer.
    OCR0 = 0;                                                                // Define o sinal aplicado ao buzzer. Apesar de V = 0, continua a haver um sinal pequeno de tensão aplicado ao buzzer.
}

void single_beep(uint16_t d_ms) {
    start_buzzer();
    _delay_ms(d_ms);
    stop_buzzer();
}

void shift_data(uint8_t data) {
    uint8_t i;
    uint8_t bit;
    
    PORTB &= ~(1<<LATCH);                                                    // Desativa a saída LATCH do ShiftRegister
    
    for(i=0;i<8;i++) {
        PORTB &= ~(1<<S_IN);                                                // Desativa S_IN.
        PORTB &= ~(1<<CLK);                                                    // Desativa CLK.
        
        if (data & (1<<i))
        bit = 0x01;
        else
        bit = 0x00;
        
        PORTB |= (bit << S_IN);
        PORTB |= (1 << CLK);
    }
    
    PORTB &= ~(1<<CLK);                                                        // Desativa CLK.
    PORTB |= (1<<LATCH);                                                    // Ativa a saída LATCH do ShiftRegister.
}

void update_score(uint8_t score_p1, uint8_t score_p2) {
    shift_data((score_p2 & 0x0F) | ((score_p1 & 0x0F) << 4));
}

Sadly there's no reference to that part in local markets. Could only find one on Mouser's website but it would cost 20€ to buy a 0.5€ piece. Will not using the chip cause any problems? Since this is a proof of concept, I only need to test the game for 5-10 minutes in order to get a grade (could talk about future implementations - like the use of the said chip - in my report, afterwards, which would somewhat backup the fact that I researched and tried to solve issues regarding circuitry, etc.).

Got the components today and built the circuit like shown below. Sadly nothing happens. My guess is the code written is wrong since I was very careful while placing the components on the breadboard. Any idea what could be wrong (code is posted on some past replies)?

(The connections on the SN74HC595N / SN74LS47N seem a bit dodgy as well since I'm not connecting any VCC or GND, idk if I have to tbh).

edit1: Worth noticing that I'm not using the UDN2981 chip for the reasons stated before. Instead, I'm connecting the matrix's rows directly to the ATMega32.

I'm sorry, I posted everything in the same code in order to be more brief in my explanation. You're totally right anyways.

I started by testing if the matrix was ok. For this, I connected my VCC to PA0 (column 1) via a resistor. Afterwards, I connected all row pins to the ground. The column lighted up properly.

I then connected the led matrix columns to the resistors (similar to how it is connected in reply #61) and the matrix rows to the ULN chip (ATMega pins connected to the input pins of the ULN chip, the outputs connected directly to the matrix rows).

I then proceeded to write this code:

#include <avr/io.h>
#include <stdlib.h>
#define F_CPU 8000000UL                                                        // 8Mhz Internal Oscillator
#include <util/delay.h>
#include <stdio.h>

void inic (void) {
	DDRA = 0xFF;							       // Defined as outputs.

	DDRD = 0xFF;							       // Defined as outputs.
	PORTD = 0xFF;				// Setting all pins of PORTD to High (1). Since it is connected to the ULN chip, it will invert the signal, setting it to 0 (setting all rows to GND).

}

int main (void) {
	inic();
	PORTA |= (1<<PORTA0);						       // Setting Pin0 of PORTA to High (1). Basically, column 1 is connected to VCC.
}

Everything went well.

Ok. I meant for you to do the other way around, that is, only 1 of the ULN outputs to be on (that is, only one of PORTD high), while all of PORTA are high. It has to be done this way, because the ULN has the larger current capacity, so 1 ULN pin can handle the current for 8 MCU pins, not the other way around (you can burn the MCU that way).

Will get right on it. If I understood correctly, you're advising me to connect the columns, that is, PORTAx to the ULN output and PORTD (rows) directly to the MCU? (What I did was the opposite, I connected the columns to the MCU through the resistors and the rows to the ULN chip).

Then, to test all LEDs, cycle the PORTD bit that is on, i.e. first D0 is on, then D1, etc. waiting 1s or so so that you can observe all the LEDs.

 

Then, to test display memory, create some array with 8 bytes, and initialize the array with some pattern. When the active ULN bit is 0 (D0=1), copy array[0] to PORTA, when ULN bit is 1 (D1=1) copy array[1] to PORTA and so on. Do an infinite cycle. You should see the pattern being displayed in the LED matrix.

Got it, will do! I'll post a video when I'm done.

Ok. I meant for you to do the other way around, that is, only 1 of the ULN outputs to be on (that is, only one of PORTD high), while all of PORTA are high. It has to be done this way, because the ULN has the larger current capacity, so 1 ULN pin can handle the current for 8 MCU pins, not the other way around (you can burn the MCU that way).

 

Then, to test all LEDs, cycle the PORTD bit that is on, i.e. first D0 is on, then D1, etc. waiting 1s or so so that you can observe all the LEDs.

Given this code, I obtained the results shown in video 1:

void inic (void) {
	DDRA = 0xFF;						// Defined as outputs.
	PORTA = 0xFF;						// Set to HIGH value in order to obtain a voltage drop (anode-cathode).

	DDRD = 0xFF;						// Defined as outputs.

}

int main (void) {
	inic();
	while (1) {
		PORTD = (1<<PORTD0);
		_delay_ms(1000);
		PORTD = (1<<PORTD1);
		_delay_ms(1000);
		PORTD = (1<<PORTD2);
		_delay_ms(1000);
		PORTD = (1<<PORTD3);
		_delay_ms(1000);
		PORTD = (1<<PORTD4);
		_delay_ms(1000);
		PORTD = (1<<PORTD5);
		_delay_ms(1000);
		PORTD = (1<<PORTD6);
		_delay_ms(1000);
		PORTD = (1<<PORTD7);
		_delay_ms(1000);
	}
}

Then, to test display memory, create some array with 8 bytes, and initialize the array with some pattern. When the active ULN bit is 0 (D0=1), copy array[0] to PORTA, when ULN bit is 1 (D1=1) copy array[1] to PORTA and so on. Do an infinite cycle. You should see the pattern being displayed in the LED matrix.

void inic (void) {
	DDRA = 0xFF;						// Defined as outputs.
	
	DDRD = 0xFF;						// Defined as outputs.

}

int main (void) {
	inic();	
	int array1[8] = {194,0,255,3,128,255,0,96};
	
	while (1) {
		PORTD = (1<<PORTD0);
		PORTA = array1[0];
		_delay_ms(1000);
		PORTD = (1<<PORTD1);
		PORTA = array1[1];
		_delay_ms(1000);
		PORTD = (1<<PORTD2);
		PORTA = array1[2];
		_delay_ms(1000);
		PORTD = (1<<PORTD3);
		PORTA = array1[3];
		_delay_ms(1000);
		PORTD = (1<<PORTD4);
		PORTA = array1[4];
		_delay_ms(1000);
		PORTD = (1<<PORTD5);
		PORTA = array1[5];
		_delay_ms(1000);
		PORTD = (1<<PORTD6);
		PORTA = array1[6];
		_delay_ms(1000);
		PORTD = (1<<PORTD7);
		PORTA = array1[7];
		_delay_ms(1000);
	}
}

Included another video (2) as well!

Cool. Now if you speed it up, that is, remove the 1s delay, the display will change so fast that it will look like a static display, showing your pattern.

The display kinda gets messed up when the delay functions are removed. The leds I want on are on, though the ones next to it light up slightly. I'll attach an image. I guess this is normal, from what I've learned, but could be wrong.

I'm sure you learned in class about interrupts and interrupt service routines (ISRs). The next step, is setting up a timer so that it generates an interrupt at about every millisecond or so.

Each time the interrupt fires, the ISR will move the display to the next column. That is, it will copy the data from the next position in the array and display it, like you are doing in the while loop of the second program.

Yes. I already used my ATMega's Timer/Counter2  in order to have a blinking led (required for the project). Will code the next interrupt like advised using the Timer/Counter0. Should I write everything present in the while loop inside the interrupt function (i.e., PORTD = (1<<PORTD0); PORTA = array1[0]; ........) or only the array / PORTA lines?

Edit1: Though I've learned ISRs (and used them already in this project, like said above), I'm unsure about which mode to use. For the blinking led I used the CTC mode. Besides that, I've only used the Fast Pwm mode (on college and outside of it) in order to control brightness / fans / etc. With this, I suppose CTC mode is the way to go (?)

That's probably because the ULN can't respond so fast. Try to set the delay to 1ms instead of removing it completely.

U were right. With a 1ms delay inbetween the tasks it shows the pattern properly!

No. Set up a volatile global variable with the current position on the array, for example "uint8_t index". Then the ISR just does one line at a time i. e. PORTD = (1<<index); PORTA = array1

; nothing more, and then increments "index" to the next time the ISR is called. Also add if (index == 8) index = 0; in the ISR to make it cycle again to the beginning.

Got it. Coded an exactly 1ms interrupt. The matrix displays the array properly! Pic attached.

#include <avr/io.h>
#include <stdlib.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include <stdint.h>

#define LED 1
#define F_CPU 8000000UL                 // 8Mhz Internal Oscillator.
#include <util/delay.h>

volatile unsigned char count = 30;		// In order to have a blinking led with 1s timer.
volatile unsigned char led;				// Verifies if LED is turned ON or OFF.
volatile unsigned char pos = 0;
volatile unsigned int array1[8] = {194,0,255,3,128,255,0,96};

void inic (void) {
	DDRA = 0xFF;						// Defined as outputs.
	DDRD = 0xFF;						// Defined as outputs.
	DDRC = 0x01;						// PC0 defined as output (blinking led).
	DDRB = 0x0F;						// First 4 pins defined as outputs (buzzer and shift register) and last 4 pins defined as inputs (switches).

	TCCR0 |= (1<<WGM01)|(0<<COM01)|(0<<COM00)|(1<<CS01);						// CTC Mode with normal port operation. T = [8/8MHz] * (OCR0 + 1).
	OCR0 = 99;

	TCCR2 |= (1<<WGM21)|(0<<COM21)|(0<<COM20)|(1<<CS22)|(1<<CS21)|(1<<CS20);	// CTC Mode with normal port operation. T = [1024/8MHz] * (OCR2 + 1).
	OCR2 = 255;

	TIMSK |= (1<<OCIE0)|(1<<OCIE2);				// Timer/Counter Compare Match interrupt enabled.

	sei();
}

ISR(TIMER0_COMP_vect) {

	if (pos == 8)									// Means it has displayed the 8 values of the array.
		pos = 0;									// Resets value so it can loop the code again.
	else {
		PORTD = (1<<pos);
		PORTA = array1[pos];
		pos++;
	}
}

ISR(TIMER2_COMP_vect) {											// Led blink interruption

	count--;													// Counts 500ms
	led = (PORTC & LED);										// Blinking LED

	if (count==0 && led==0) {									// Count = 15 by default. 32.7ms * 15 = 491ms. Half a second on, Half a second off. Comes here if led is turned off
		PORTC |= LED;											// LED ON
		count = 30;												// Reset counter
	}

	if (count==0 && led==1) {									// Comes here if led is turned on
		PORTC &= ~LED;											// LED OFF
		count = 30;												// Resets counter
	}
}

int main (void) {
	inic();

	while (1) {
	}
}

Now you can offload button detection to an ISR also, that then sets some variables depending on the button states, if it was pressed or released, etc. and handles debouncing behind the scenes.

The game code just reads these variables and reacts accordingly.

 I was trying to make a simple code to test a button press but it's doing the opposite.

DDRB = 0x0F;						// First 4 pins defined as outputs (buzzer and shift register) and last 4 pins defined as inputs (switches).

int main (void) {
	inic();

	while (1) {
		if (PINB & (1<<PINB4)) {			// Switch pressed.
			PORTD = 0xFF;
			PORTA = 0xFF;
		}
		else {
			PORTD = 0x00;
		}
	}
}

In my mind, when the button placed on PB4 is pressed, the matrix would light up. Otherwise, it wouldn't (PORTD = 0x00) but it's doing the exact opposite.

How is your button wired?

The button was broken (somehow). I replaced it with another one and it's working properly. I'm connecting it by wiring one side of the button to VCC and the other one (which connects to the MCU port) to GND through a 1k resistor.

Now you can offload button detection to an ISR also, that then sets some variables depending on the button states, if it was pressed or released, etc. and handles debouncing behind the scenes.

The game code just reads these variables and reacts accordingly.

 

Next step, maybe build a test program that just moves a dot around the screen, controlled by the buttons, and you will be well on your way to complete the project.

 I built a code, which I think is correct, though the program isn't working properly. My guess is that due to the fact that the ISR has a 1ms delay inbetween repetitions, pressing a button once equals to pressing a button a thousand times (given the fact that I can't press the button in less than 1 ms). Tried to troubleshoot it by placing some code lines on the main function etc. etc. but nothing changed:

volatile unsigned int array1[8] = {1,2,4,8,16,32,64,128};
volatile unsigned char posy = 4;

void inic (void) {
	DDRA = 0xFF;						// Defined as outputs.
	DDRD = 0xFF;						// Defined as outputs.
	DDRC = 0x01;						// PC0 defined as output (blinking led).
	DDRB = 0x0F;						// First 4 pins defined as outputs (buzzer and shift register) and last 4 pins defined as inputs (switches).

	TCCR0 |= (1<<WGM01)|(0<<COM01)|(0<<COM00)|(1<<CS01);						// CTC Mode with normal port operation. T = [8/8MHz] * (OCR0 + 1).
	OCR0 = 99;

	TIMSK |= (1<<OCIE0)|(1<<OCIE2);					// Timer/Counter Compare Match interrupt enabled.

	sei();
}

ISR(TIMER0_COMP_vect) {

		if (PINB & (1<<PINB4)) {				// Switch 1 (up) pressed.
			posy++;
			if (posy > 8)
				posy = 8;
			PORTA = array1[posy];
		}

		if (PINB & (1<<PINB5)) {				// Switch 2 (down) pressed.
			posy--;
			if (posy < 0)
				posy = 0;
			PORTA = array1[posy];
		}
}

int main (void) {
	inic();

	PORTD = (1<<3);
	PORTA = array1[posy];

	while (1) {

	}
}

Edit1: I'm stupid.. I should have created a new interrupt in order to read button presses right? Or a function, since I suppose it's easier.

Oh right. Totally forgot about interrupt flags. In order to do so, should I create an external interrupt in order to read button state, etc.?

While waiting for a reply, I decided to look at my code and figure out what was wrong. I managed to fix it and it's working properly now with the help of a function readButton();. Don't know if this is ok to use or if the ISR is a must.

#define F_CPU 8000000UL                 // 8Mhz Internal Oscillator.
#include <util/delay.h>

volatile unsigned int array1[8] = {1,2,4,8,16,32,64,128};
volatile signed char posy = 4;
volatile unsigned int btn1 = 0;
volatile unsigned int btn2 = 0;

void inic (void) {
	DDRB = 0x0F;						// First 4 pins defined as outputs (buzzer and shift register) and last 4 pins defined as inputs (switches).

	TCCR0 |= (1<<WGM01)|(0<<COM01)|(0<<COM00)|(1<<CS01);						// CTC Mode with normal port operation. T = [8/8MHz] * (OCR0 + 1).
	OCR0 = 99;
	TIMSK |= (1<<OCIE0)|(1<<OCIE2);					// Timer/Counter Compare Match interrupt enabled.

	sei();
}

ISR(TIMER0_COMP_vect) {

	if (btn1 == 1) {
		if (posy > 7)
			posy = 7;
		PORTA = array1[posy];
		btn1 = 0;
	}

	if (btn2 == 1) {
		if (posy < 0)
			posy = 0;
		PORTA = array1[posy];
		btn2 = 0;
	}
}

void readButton (void) {
	if (PINB & (1<<PINB4)) {			// Switch 1 (up) pressed.
		btn1 = 1;
		posy++;
	}

	if (PINB & (1<<PINB5)) {			// Switch 2 (down) pressed.
		btn2 = 1;
		posy--;
	}
}

int main (void) {
	inic();

	PORTD = (1<<3);
	PORTA = array1[posy];

	while (1) {
		_delay_ms(200);
		readButton();
	}
}

Oh alright. My bad I wasn't understanding, sorry.

Thing is, If I'm going to use that ISR (1ms interrupt), the matrix just stays the same (the refresh time is so High that I can't see the ball moving). If I change the duration (prescaler from 8 -> 1024, OCR0 from 99->255) I can now see the ball moving in the required axis.

Ok. I guess I have to demonstrate with code since words are not working. Here, see if this works, it's just a small change from your code:

Oh... This simple lol. I'm sorry... Makes sense. While I'm changing the array

Alright, nice to know since I'll have to talk about it on my presentation! One doubt:

Should I code the buttons (i.e., sw1 equals to the ball moving right, sw2 equals to the ball moving left, sw3 moving up, sw4 moving down) on another function or on main?

Here we go again...

ISR(TIMER0_COMP_vect) {

    if (pos == 8)                                    // Means it has displayed the 8 values of the array.
        pos = 0;                                    // Resets value so it can loop the code again.
    else {
        PORTD = (1<<pos);
        if (btn1 == 1) {
            PORTA = array1[pos];
            pos++;
        }
        if (btn2 == 1)
            PORTA = array1[pos];
    }
}

Man! Keep things separate! This ISR should just handle the display, not react to buttons! Do you think in you PC, the keyboard is connected directly to your graphics card? That your graphics card reacts to keyboard presses directly?

No, of course not. That would be absurd, right?

Everything goes through the CPU. In your case, everything has to go through main().

So just keep the ISR like this

ISR(TIMER0_COMP_vect) {

	if (pos == 8)									// Means it has displayed the 8 values of the array.
		pos = 0;									// Resets value so it can loop the code again.
	else {
		PORTD = (1<<pos);
		PORTA = array1[pos];
		pos++;
	}
}

Forever! OK? It's working, doing it's one and only job, so don't touch it any more, ever. Unless you want to optimize it or something.

Buttons should also have an ISR, I think the LED ISR should also handle buttons.

If a button is pressed for a certain time, then the button ISR sets a flag.  You achieve this by setting a counter for each button, similar to the counter you are using to blink the LED. The counter increases for as long as the button is pressed and when it reaches a value that corresponds to, let's say, 200ms, a button action is generated (that is, you write 1 to btn1 or btn2 or whatever) and the counter is reset to zero. If the button is released, the counter is also reset to zero.

The main() function detects this by waiting in a loop until any of btn1/2/3/4 becomes 1.

Then it takes the proper action (i.e. if btn1 then action1, if btn2 then action2, etc.), that is moving the ball by writing new values to the frame buffer. And then it writes 0 to the button flag that was processed, so that it can wait again for it to become 1.

I strongly recommend that you write functions set_pixel(x,y) and clear_pixel(x,y). These functions shall take (x,y) coordinates on the LED matrix, and set or clear the corresponding point by manipulating the frame buffer.

Look again at the code in #90. You tested it? It works, I hope. You should see a point moving back and forth. So how is this happening, if the ISR function is unchanged?

Exactly, that's why you never need to change the ISR, only the array.

The screen is mapped like

So, if you want to set a point (x,y) you can do array[y] |= 1 << x; and if you want to clear a point, you can do array[y] &= ~(1 << x); but it's better to have this code in functions that are called when needed.