AVR Freaks

Thanks for all the help.

I was avoiding templates because I find them too confusing to understand. But after reading the article below and curtvm's template code for ARM I understand it a bit better now. As a sidenote, the article below uses the AVR0/1 series. 

https://www.tablix.org/~avian/blog/archives/2019/10/specializing_c_templates_on_avr_pins/

Essentially templates can't accept pointers and thus you have to do some casting to trick the template.

I've updated my code for the gpio.

#pragma once

#include <stddef.h>
#include <stdint.h>
#include <avr/io.h>

static const int PORTB_ADDR = (int) &PORTB; 
static const int PORTC_ADDR = (int) &PORTC; 
static const int PORTD_ADDR = (int) &PORTD;
 
template <uint16_t port_addr, uint8_t  pins> 
class GPIO {
	
	public:
		
	void setOutput(void){ *(volatile uint8_t*)(port_addr-1) |= pins; }		
	void setPullUp(void){ *(volatile uint8_t*)(port_addr-1) &=~ pins; *(volatile uint8_t*)(port_addr) |= pins; }		
	void on(void){ *(volatile uint8_t*)port_addr |= pins; }
	void off(void){	*(volatile uint8_t*)port_addr &=~ pins; }		
	void toggle(void){ *(volatile uint8_t*)(port_addr-2) |= pins; }	
};

This works as expected, but now my problem is that I don't know/understand the syntax for allowing the MAX class to inherit the template class. I've read a few different sources and tutorials, but I can't make heads or tails of it. What I've done so far is:

//class declaration
class MAX7219 : public SPI, public GPIO<uint16_t,uint8_t>

//class constructors
MAX7219(SPI& spi, GPIO<uint16_t,uint8_t>);

int main(void)
{
	
	SPI spi;
	spi.init();
	
	GPIO<PORTB_ADDR,2> select;
	select.setOutput();
	select.on();
		
	MAX7219 display0(spi,select);
	 while (1) 
	{};
}

I keep getting errors related to mismatching. 

I appreciate everyone's comments, this template stuff is just killing me though. curt your example would is great, except I still need the MAX class to inherit spi and I don't the know syntax for making that work. More specifically I need to know the syntax for the constructor and initialize in main.  I've looked at many different sources to understand what I need to do, but every example fails to provide any insight. I think I'm just misunderstanding how all of this template inheritance stuff is suppose to work.

There are a few workarounds, but I was trying to stick to the coding principle that all the peripheral dependencies would be hidden by the class functions. Obviously the easy way is just to forget about inheriting a GPIO class and toggling the SS pin for each device in the main loop. Or the brute force way of creating a gpio class with each value for the port and pin hardcoded and then just let the spi device inherit the specific gpio class. 

Many thanks to curtvm, your examples are great. I have one more piece of code I want you guys to look at because it gets pretty close to what I wanted. Based off this stackoverflower answer I came up with:

class GPIO
{
	constexpr static volatile uint8_t *const PORTb() { return &PORTB; }
	constexpr static volatile uint8_t *const DDRb() { return &DDRB; }
	constexpr static volatile uint8_t *const PINb() { return &PINB; }
	constexpr static volatile uint8_t *const PORTc() { return &PORTC; }
	constexpr static volatile uint8_t *const DDRc() { return &DDRC; }
	constexpr static volatile uint8_t *const PINc() { return &PINC; }
	constexpr static volatile uint8_t *const PORTd() { return &PORTD; }
	constexpr static volatile uint8_t *const DDRd() { return &DDRD; }
	constexpr static volatile uint8_t *const PINd() { return &PIND; }	
	
	public:	
	enum PORTS_ : uint8_t {B,C,D};
	enum PINS_ : uint8_t  {P0=1,P1=2,P2=4,P3=8,P4=16,P5=32,P6=64,P7=128};
		
	GPIO(PORTS_ port, PINS_ pin) : port_(port), pin_(pin)
	{};
			
	const enum PORTS_ port_;
	const enum PINS_  pin_;
	
	void setOutput() 
	{ 		
		switch (port_)
		{
			case B: *DDRb() |= pin_; break;
			case C: *DDRc() |= pin_; break;
			case D: *DDRd() |= pin_; break;
		}		
				
	}

	void on()
	{	
		switch (port_)
		{
		
		case B: *PORTb() |= pin_; break;
		case C: *PORTc() |= pin_; break;
		case D: *PORTd() |= pin_; break;
		}
	}
	
	void off()
	{
		switch (port_)
		{
			case B: *PORTb() &= ~pin_; break;
			case C: *PORTc() &= ~pin_; break;
			case D: *PORTd() &= ~pin_; break;
		}
	}
	
};

The assembly code gets pretty close, except with inheritance it will actually create the lookup code. 

    void off()
MOVW R30,R24        
        switch (port_)
LDD R24,Z+0        
CPI R24,0x01       
BREQ PC+0x0B      
BRCS PC+0x04        
CPI R24,0x02     
BREQ PC+0x0E       
RET        
            case B: *PORTb() &= ~pin_; break;
IN R25,0x05        
LDD R24,Z+1      
COM R24        
AND R24,R25   
OUT 0x05,R24       
RET         
            case C: *PORTc() &= ~pin_; break;
IN R25,0x08        
LDD R24,Z+1     
COM R24         
AND R24,R25        
OUT 0x08,R24        
RET         
            case D: *PORTd() &= ~pin_; break;
IN R25,0x0B        
LDD R24,Z+1       
COM R24        
AND R24,R25      
OUT 0x0B,R24        
RET