Collaboration diagram for Max7219< N >:

[legend]

Public Member Functions
	Max7219 (SpiDevice &spi, Gpio *cs)

void	RefreshThread ()

void	Initialize ()

void	SetIntensity (uint8_t value)

void	Clear ()

void	DrawPixel (size_t chip_index, uint8_t row, uint8_t col, bool on)

void	DrawPixelMatrix2 (uint8_t row, uint8_t col, bool on)

void	Refresh ()

void	WriteToChip (size_t index, uint8_t addr, uint8_t data)

void	TestEachChip ()

void	Lock ()

void	Unlock ()

void	SetLight (uint8_t light)

Static Public Attributes
static constexpr uint8_t	REG_NOOP = 0x00

static constexpr uint8_t	REG_DIGIT0 = 0x01

static constexpr uint8_t	REG_DIGIT7 = 0x08

static constexpr uint8_t	REG_DECODE_MODE = 0x09

static constexpr uint8_t	REG_INTENSITY = 0x0A

static constexpr uint8_t	REG_SCAN_LIMIT = 0x0B

static constexpr uint8_t	REG_SHUTDOWN = 0x0C

static constexpr uint8_t	REG_DISPLAY_TEST = 0x0F

Private Member Functions
void	WriteAll (uint8_t addr, uint8_t value)

void	WriteCommand (uint8_t addr, const std::array< uint8_t, N > &data)

void	WriteCommandRaw (const std::array< uint8_t, N > &regs, const std::array< uint8_t, N > &data)

Private Attributes
SpiDevice &	spi_

Gpio *	cs_

std::array< std::array< uint8_t, 8 >, N >	framebuffer_

std::thread	thread_

std::mutex	mutex_

Detailed Description

template<size_t N>
class Max7219< N >

Definition at line 20 of file max7219.hpp.

Constructor & Destructor Documentation

◆ Max7219()

template<size_t N>

Max7219< N >::Max7219	(	SpiDevice &	spi,
		Gpio *	cs
	)

inline

Definition at line 33 of file max7219.hpp.

                                    : spi_(spi), cs_(cs) {
    if (!cs_) {
      std::perror("CS GPIO is not initialized");
    }
    cs_->Write(1); /* CS active low, initialize to high */
    for (auto& chip : framebuffer_) {
      chip.fill(0); /* Clear frame buffer */
    }
 
    thread_ = std::thread(&Max7219::RefreshThread, this);
 
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
    TestEachChip();
  }

Member Function Documentation

◆ Clear()

template<size_t N>

void Max7219< N >::Clear ( )

inline

Definition at line 84 of file max7219.hpp.

               {
    for (auto& chip : framebuffer_) {
      chip.fill(0);
    }
  }

◆ DrawPixel()

template<size_t N>

void Max7219< N >::DrawPixel	(	size_t	chip_index,
		uint8_t	row,
		uint8_t	col,
		bool	on
	)

inline

Definition at line 94 of file max7219.hpp.

                                                                       {
    if (chip_index >= N || row >= 8 || col >= 8) {
      return;
    }
    if (on) {
      framebuffer_[chip_index][7 - row] |= (1 << col);
    } else {
      framebuffer_[chip_index][7 - row] &= ~(1 << col);
    }
  }

◆ DrawPixelMatrix2()

template<size_t N>

void Max7219< N >::DrawPixelMatrix2	(	uint8_t	row,
		uint8_t	col,
		bool	on
	)

inline

Definition at line 107 of file max7219.hpp.

                                                           {
    if (row >= 16 || col >= 32) {
      return;
    }
 
    /* Serpentine layout chip index mapping */
    static constexpr int CHIP_INDEX_MAP[] = {0, 2, 1, 3};
 
    /* Calculate chip position in virtual matrix */
    size_t chip_index = (row / 8) + (col / 8) * 2;
    /* Apply physical layout mapping */
    chip_index = CHIP_INDEX_MAP[chip_index % 4] + (chip_index - chip_index % 4);
    uint8_t local_row = row % 8;
    uint8_t local_col = col % 8;
 
    DrawPixel(chip_index, local_row, local_col, on);
  }

◆ Initialize()

template<size_t N>

void Max7219< N >::Initialize ( )

inline

Definition at line 59 of file max7219.hpp.

                    {
    for (size_t i = 0; i < N; ++i) {
      WriteToChip(i, REG_SHUTDOWN, 0x00);     /* Enter shutdown mode */
      usleep(5);                              /* Short delay */
      WriteToChip(i, REG_DISPLAY_TEST, 0x00); /* Normal operation */
      WriteToChip(i, REG_DECODE_MODE, 0x00);  /* Matrix mode (no decoding) */
      WriteToChip(i, REG_SCAN_LIMIT, 0x07);   /* Scan all 8 rows */
      WriteToChip(i, REG_INTENSITY, 0x03);    /* Medium brightness */
      WriteToChip(i, REG_SHUTDOWN, 0x01);     /* Normal operation */
    }
    Clear();
    Refresh();
  }

◆ Lock()

template<size_t N>

void Max7219< N >::Lock ( )

inline

Definition at line 206 of file max7219.hpp.

             {
    mutex_.lock();
  }

◆ Refresh()

template<size_t N>

void Max7219< N >::Refresh ( )

inline

Definition at line 126 of file max7219.hpp.

                 {
    mutex_.lock();
    for (uint8_t row = 0; row < 8; ++row) {
      std::array<uint8_t, N> regs;
      std::array<uint8_t, N> data;
      regs.fill(REG_DIGIT0 + row);
      for (size_t i = 0; i < N; ++i) {
        data[i] = framebuffer_[i][row];
      }
      WriteCommandRaw(regs, data);
    }
    mutex_.unlock();
  }

◆ RefreshThread()

template<size_t N>

void Max7219< N >::RefreshThread ( )

inline

Definition at line 49 of file max7219.hpp.

                       {
    Initialize();
 
    while (true) {
      Refresh();
      std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
  }

◆ SetIntensity()

template<size_t N>

void Max7219< N >::SetIntensity ( uint8_t value )

inline

Definition at line 74 of file max7219.hpp.

                                   {
    mutex_.lock();
    if (value > 0x0F) {
      value = 0x0F;
    }
    WriteAll(REG_INTENSITY, value);
    mutex_.unlock();
  }

◆ SetLight()

template<size_t N>

void Max7219< N >::SetLight ( uint8_t light )

inline

Definition at line 214 of file max7219.hpp.

                              {
    SetIntensity(light);
  }

◆ TestEachChip()

template<size_t N>

void Max7219< N >::TestEachChip ( )

inline

Definition at line 155 of file max7219.hpp.

                      {
    Clear();
    /* Draw left border */
    for (int i = 0; i < 16; ++i) {
      DrawPixelMatrix2(i, 0, true);
      std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
 
    /* Draw bottom border */
    for (int i = 0; i < 16; ++i) {
      DrawPixelMatrix2(15, i, true);
      std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
 
    /* Draw middle vertical line */
    for (int i = 0; i < 16; ++i) {
      DrawPixelMatrix2(i, 16, true);
      std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
 
    /* Draw right border */
    for (int i = 16; i < 32; ++i) {
      DrawPixelMatrix2(15, i, true);
      std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
 
    /* Draw right vertical line */
    for (int i = 15; i > 0; --i) {
      DrawPixelMatrix2(i, 31, true);
      std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
 
    /* Draw top right border */
    for (int i = 31; i > 16; --i) {
      DrawPixelMatrix2(0, i, true);
      std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
 
    /* Draw middle horizontal line */
    for (int i = 15; i > 0; --i) {
      DrawPixelMatrix2(i, 15, true);
      std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
 
    /* Draw top left border */
    for (int i = 15; i > 0; --i) {
      DrawPixelMatrix2(0, i, true);
      std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
  }

◆ Unlock()

template<size_t N>

void Max7219< N >::Unlock ( )

inline

Definition at line 210 of file max7219.hpp.

               {
    mutex_.unlock();
  }

◆ WriteAll()

template<size_t N>

void Max7219< N >::WriteAll	(	uint8_t	addr,
		uint8_t	value
	)

inlineprivate

Definition at line 227 of file max7219.hpp.

                                             {
    std::array<uint8_t, N> data;
    data.fill(value);
    WriteCommand(addr, data);
  }

◆ WriteCommand()

template<size_t N>

void Max7219< N >::WriteCommand	(	uint8_t	addr,
		const std::array< uint8_t, N > &	data
	)

inlineprivate

Definition at line 234 of file max7219.hpp.

                                                                    {
    std::array<uint8_t, N> regs;
    regs.fill(addr);
    WriteCommandRaw(regs, data);
  }

◆ WriteCommandRaw()

template<size_t N>

void Max7219< N >::WriteCommandRaw	(	const std::array< uint8_t, N > &	regs,
		const std::array< uint8_t, N > &	data
	)

inlineprivate

Definition at line 241 of file max7219.hpp.

                                                         {
    std::array<uint8_t, N * 2> tx_buf{};
    for (size_t i = 0; i < N; ++i) {
      const size_t HW_INDEX = N - 1 - i;
      tx_buf[i * 2] = regs[HW_INDEX];
      tx_buf[i * 2 + 1] = data[HW_INDEX];
    }
 
    spi_ioc_transfer transfer{};
    transfer.tx_buf = reinterpret_cast<uint64_t>(tx_buf.data());
    transfer.len = tx_buf.size();
    transfer.speed_hz = 1000000;
    transfer.bits_per_word = 8;
    transfer.delay_usecs = 10;
 
    usleep(100);
    cs_->Write(0);
    usleep(100);
#ifndef TEST_BUILD
    if (ioctl(spi_.Fd(), SPI_IOC_MESSAGE(1), &transfer) < 0) {
      cs_->Write(1);
      std::perror("SPI transfer failed");
    }
#endif
 
    usleep(100);
    cs_->Write(1);
    usleep(100);
  }

◆ WriteToChip()

template<size_t N>

void Max7219< N >::WriteToChip	(	size_t	index,
		uint8_t	addr,
		uint8_t	data
	)

inline

Definition at line 141 of file max7219.hpp.

                                                             {
    std::array<uint8_t, N> regs;
    std::array<uint8_t, N> data_all;
    regs.fill(REG_NOOP);
    data_all.fill(0x00);
    if (index >= N) {
      return;
    }
    regs[index] = addr;
    data_all[index] = data;
    WriteCommandRaw(regs, data_all);
  }

Field Documentation

◆ cs_

template<size_t N>

Gpio* Max7219< N >::cs_

private

Definition at line 221 of file max7219.hpp.

◆ framebuffer_

template<size_t N>

std::array<std::array<uint8_t, 8>, N> Max7219< N >::framebuffer_

private

Definition at line 222 of file max7219.hpp.

◆ mutex_

template<size_t N>

std::mutex Max7219< N >::mutex_

private

Definition at line 224 of file max7219.hpp.

◆ REG_DECODE_MODE

template<size_t N>

constexpr uint8_t Max7219< N >::REG_DECODE_MODE = 0x09

staticconstexpr

Definition at line 26 of file max7219.hpp.

◆ REG_DIGIT0

template<size_t N>

constexpr uint8_t Max7219< N >::REG_DIGIT0 = 0x01

staticconstexpr

Definition at line 24 of file max7219.hpp.

◆ REG_DIGIT7

template<size_t N>

constexpr uint8_t Max7219< N >::REG_DIGIT7 = 0x08

staticconstexpr

Definition at line 25 of file max7219.hpp.

◆ REG_DISPLAY_TEST

template<size_t N>

constexpr uint8_t Max7219< N >::REG_DISPLAY_TEST = 0x0F

staticconstexpr

Definition at line 30 of file max7219.hpp.

◆ REG_INTENSITY

template<size_t N>

constexpr uint8_t Max7219< N >::REG_INTENSITY = 0x0A

staticconstexpr

Definition at line 27 of file max7219.hpp.

◆ REG_NOOP

template<size_t N>

constexpr uint8_t Max7219< N >::REG_NOOP = 0x00

staticconstexpr

Definition at line 23 of file max7219.hpp.

◆ REG_SCAN_LIMIT

template<size_t N>

constexpr uint8_t Max7219< N >::REG_SCAN_LIMIT = 0x0B

staticconstexpr

Definition at line 28 of file max7219.hpp.

◆ REG_SHUTDOWN

template<size_t N>

constexpr uint8_t Max7219< N >::REG_SHUTDOWN = 0x0C

staticconstexpr

Definition at line 29 of file max7219.hpp.

◆ spi_

template<size_t N>

SpiDevice& Max7219< N >::spi_

private

Definition at line 220 of file max7219.hpp.

◆ thread_

template<size_t N>

std::thread Max7219< N >::thread_

private

Definition at line 223 of file max7219.hpp.

The documentation for this class was generated from the following file:

src/device/max7219.hpp

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Max7219()

Member Function Documentation

◆ Clear()

◆ DrawPixel()

◆ DrawPixelMatrix2()

◆ Initialize()

◆ Lock()

◆ Refresh()

◆ RefreshThread()

◆ SetIntensity()

◆ SetLight()

◆ TestEachChip()

◆ Unlock()

◆ WriteAll()

◆ WriteCommand()

◆ WriteCommandRaw()

◆ WriteToChip()

Field Documentation

◆ cs_

◆ framebuffer_

◆ mutex_

◆ REG_DECODE_MODE

◆ REG_DIGIT0

◆ REG_DIGIT7

◆ REG_DISPLAY_TEST

◆ REG_INTENSITY

◆ REG_NOOP

◆ REG_SCAN_LIMIT

◆ REG_SHUTDOWN

◆ spi_

◆ thread_