Apprendre à dessiner sur une matrice de LED avec Arduino en langage C

#include <util/delay.h>
#include "ledmatrix.h"  // The header of my library.

#define FRAME_RATE_HZ 50 // This feels sufficient
#define SUBFRAME_RATE_HZ (FRAME_RATE_HZ * N_SUBFRAMES) // N_SUBFRAMES is in ledmatrix.h
#define SUBFRAME_DELAY_US (1000000 / SUBFRAME_RATE_HZ)

int main(void)
{
 struct ledmatrix_frame fB = // struct ledmatrix is a 5-bytes struct holding a 7x5 frame.
  LEDMATRIX_FRAME_INIT( // A helper macro to write frames easily
   11110,  // This structure contains a 'B'
   10001,  // 1 means LED is on
   10001,  // 0 means LED is off
   11110,  // they are transformed into binary numbers by 'magic' in LEDMATRIX_FRAME_INIT()
   10001,
   10001,
   11110);

 ledmatrix_setup(); // Initializes ports and stuff.

 while(1)
 {
  ledmatrix_draw_next_subframe(&fB); // Turns on the LEDs of the next subframe.
  _delay_us(SUBFRAME_DELAY_US); // This loop+delay might be replaced by a periodic interrupt.
 }
 return 0;
}

/*
 * Copyright (c) 2014 Francesco Balducci
 *
 * This file is part of arduino_c.
 *
 *    arduino_c is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU Lesser General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    arduino_c is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public License
 *    along with arduino_c.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef LEDMATRIX_H
#define LEDMATRIX_H

#include <stdint.h>

/* Using LTP-7357AG
 * 7x5 LED matrix
 */

#define N_COLS 5
#define N_ROWS 7
#define N_DOTS_ON_MAX 2

#define N_SUBFRAMES (((N_ROWS + N_DOTS_ON_MAX - 1)/ N_DOTS_ON_MAX) * N_COLS)

struct ledmatrix_frame {
    uint8_t cols[N_COLS];
};

#define BITCONST_(bits) 0b ## bits

#define GETCOLDOT_(i_col, i_row, row) (((BITCONST_(row) >> (N_COLS - 1 - (i_col))) & 0x01) << (i_row))

#define GETCOL_(i_col, r0,r1,r2,r3,r4,r5,r6) \
    ( \
      GETCOLDOT_(i_col, 0, r0)| \
      GETCOLDOT_(i_col, 1, r1)| \
      GETCOLDOT_(i_col, 2, r2)| \
      GETCOLDOT_(i_col, 3, r3)| \
      GETCOLDOT_(i_col, 4, r4)| \
      GETCOLDOT_(i_col, 5, r5)| \
      GETCOLDOT_(i_col, 6, r6)  \
    )

#define LEDMATRIX_FRAME_INIT(r0,r1,r2,r3,r4,r5,r6) \
    {{ \
        GETCOL_(0, r0,r1,r2,r3,r4,r5,r6), \
        GETCOL_(1, r0,r1,r2,r3,r4,r5,r6), \
        GETCOL_(2, r0,r1,r2,r3,r4,r5,r6), \
        GETCOL_(3, r0,r1,r2,r3,r4,r5,r6), \
        GETCOL_(4, r0,r1,r2,r3,r4,r5,r6), \
    }}

#define LEDMATRIX_FRAME_SET(f, r0,r1,r2,r3,r4,r5,r6) \
    do { \
        (f)->cols[0] = GETCOL_(0, r0,r1,r2,r3,r4,r5,r6); \
        (f)->cols[1] = GETCOL_(1, r0,r1,r2,r3,r4,r5,r6); \
        (f)->cols[2] = GETCOL_(2, r0,r1,r2,r3,r4,r5,r6); \
        (f)->cols[3] = GETCOL_(3, r0,r1,r2,r3,r4,r5,r6); \
        (f)->cols[4] = GETCOL_(4, r0,r1,r2,r3,r4,r5,r6); \
    } while(0)

extern void ledmatrix_setup(void);

extern void ledmatrix_draw_next_subframe(const struct ledmatrix_frame *f);

#endif /* LEDMATRIX_H */

/*
 * Copyright (c) 2014 Francesco Balducci
 *
 * This file is part of arduino_c.
 *
 *    arduino_c is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU Lesser General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    arduino_c is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public License
 *    along with arduino_c.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <avr/io.h>
#include <stdint.h>
#include "ledmatrix.h"

static
const uint8_t COL_MASK =
          _BV(DDB0)
        | _BV(DDB1)
        | _BV(DDB2)
        | _BV(DDB3)
        | _BV(DDB4);

static
const uint8_t ROW_MASK_D = 
          _BV(DDD2)
        | _BV(DDD3)
        | _BV(DDD4)
        | _BV(DDD5)
        | _BV(DDD6)
        | _BV(DDD7);

static
const uint8_t ROW_MASK_B = 
          _BV(DDB5);

static
void cols_off(void)
{
    DDRB &= ~COL_MASK;
}

static
void col_on(int i_col)
{
    DDRB |= _BV(i_col);
}

static
void cols_setup(void)
{
    cols_off();
    PORTB &= ~COL_MASK; /* disable pull-up */
}

static
void rows_setup(void)
{
    DDRD |= ROW_MASK_D;
    PORTD &= ~ROW_MASK_D; /* everything off */
    DDRB |= ROW_MASK_B;
    PORTB &= ~ROW_MASK_B; /* everything off */
}

static
uint8_t dots_portd(uint8_t dots)
{
    uint8_t dots_d;
    dots_d = dots & 0x7E; /* bit 0 is on PB5 */
    dots_d |= (dots & 0x02)?_BV(DDD7):0x00; /* bit 1 is on PD7 */
    dots_d &= ~0x02;
    return dots_d;
}

static
uint8_t dots_portb(uint8_t dots)
{
    uint8_t dots_b;
    dots_b = (dots & 0x01)?_BV(DDB5):0x00;
    return dots_b;
}

static
void draw_dots_portd(uint8_t dots)
{
    uint8_t dots_d = dots_portd(dots);
    uint8_t dots_on = ROW_MASK_D & dots_d;
    uint8_t dots_off = ROW_MASK_D & ~dots_d;
    PORTD |= dots_on;
    PORTD &= ~dots_off;
}

static
void draw_dots_portb(uint8_t dots)
{
    uint8_t dots_b = dots_portb(dots);
    uint8_t dots_on = ROW_MASK_B & dots_b;
    uint8_t dots_off = ROW_MASK_B & ~dots_b;
    PORTB |= dots_on;
    PORTB &= ~dots_off;
}

static
void draw_dots(uint8_t dots)
{
    draw_dots_portd(dots);
    draw_dots_portb(dots);
}

static
void ledmatrix_draw_col(int i_col, uint8_t dots)
{
    cols_off();
    draw_dots(dots);
    col_on(i_col);
}

void ledmatrix_setup(void)
{
        cols_setup();
    rows_setup();
}

void ledmatrix_draw_next_subframe(const struct ledmatrix_frame *f)
{
    static int i_next_col = 0;
    static int i_next_row = 0;

    uint8_t dots;
    uint8_t dots_mask = (1<<N_DOTS_ON_MAX)-1;

    dots = f->cols[i_next_col];
    dots_mask <<= i_next_row;
    dots &= dots_mask;
    ledmatrix_draw_col(i_next_col, dots);
    i_next_row += N_DOTS_ON_MAX;
    if (i_next_row >= N_ROWS)
    {
        i_next_row = 0;
        i_next_col++;
        if (i_next_col == N_COLS)
        {
            i_next_col = 0;
        }
    }
}