DIRECT PORT MANIPULATION help

[dattasaurabh82]

Hey everyone.
Just going through direct port manipulation to test a small code.
Note: I come from Arduino's digitalPin() world, so know not much about direct PORT manipulation. 😅

I have a small setup where I have 2-2x7 segment displays (Common Anode configuration).
They are wired to each other like this:

The pins are connected to ATTINY1607 as such:

A -> PA1
B -> PA2
C -> PA3
D -> PA4
E -> PA5
F -> PA6
G -> PA7
Top display digit 1 Anode -> PC4
Top display digit 2 Anode -> PC5
Bot display digit 1 Anode -> PC2
Bot display digit 1 Anode -> PC3

Now I'm trying to write a code, something like, with functions, as below, running from void loop():

showNums(0 /*first top segment*/, 1  /*2nd top segment*/, 2  /*first bottom segment*/, 3  /*second bot segment*/);
delay(1000);
showNums(4, 5, 6, 7);
delay(1000);

I hope it is understandable what I'm trying to do here. 😶

Here's the full code I wrote so far (after reading directPortManipulation ):

void setupDisplay() {
  //  Cathode Pins for LEDS
  PORTA.DIRSET = 0b11111110; // [ PA 1-7 as Outputs]
  //  Anode Pins for LEDS
  PORTC.DIRSET = 0b00111100; // [ PC 2-5 (PC-4&5 for top displays and PC-2&3 for bottom display) as Outputs or in Arduino world, digital Pins 14-17 ]
}

void setup() {
  //--- Seven segment display initialization ---//
  setupDisplay();
}


unsigned char num_array[10] = {
  0b01111110, //0
  0b00001100, //1
  0b10110110, //2
  0b10011110, //3
  0b11001100, //4
  0b11011010, //5
  0b11111010, //6
  0b00001110, //7
  0b11111110, //8
  0b11001110, //9
};



void showNums(int segOneDigit, int segTwoDigit, int segThreeDigit, int segFourDigit) {
  // segment 1
  // clear all leds of a segment
  PORTA.OUTCLR = 0b11111110;
  // deactivatec all segments by setting them HIGH (My segments are in common Anode config)
  PORTC.OUTSET = 0b00111100 ;
  // activate the 1st segment
  PORTC.OUTCLR = 0b00010000;
  // set the number
  PORTA.OUTSET = num_array[segOneDigit];


  // segment 2
  // clear all leds of a segment
  PORTA.OUTCLR = 0b11111110;
  // deactivatec all segments by setting them HIGH (My segments are in common Anode config)
  PORTC.OUTSET = 0b00111100 ;
  // activate the 2nd segment
  PORTC.OUTCLR = 0b00100000;
  // set the number
  PORTA.OUTSET = num_array[segTwoDigit];

  // segment 3
  // clear all leds of segment leds
  PORTA.OUTCLR = 0b11111110;
  // deactivatec all segments by setting them HIGH (My segments are in common Anode config)
  PORTC.OUTSET = 0b00111100 ;
  // activate the 3rd segment
  PORTC.OUTCLR = 0b00000100;
  // set the number
  PORTA.OUTSET = num_array[segThreeDigit];

  // segment 3
  // clear all leds of segment leds
  PORTA.OUTCLR = 0b11111110;
  // deactivatec all segments by setting them HIGH (My segments are in common Anode config)
  PORTC.OUTSET = 0b00111100 ;
  // activate the 3rd segment
  PORTC.OUTCLR = 0b00001000;
  // set the number
  PORTA.OUTSET = num_array[segFourDigit];
}


void loop() {
  showNums(0, 1, 2, 3);
  delay(1000);
  showNums(4, 5, 6, 7);
  delay(1000);
}

I see an unexpected behaviour.
The last digit is only updating and not all the segments !! 🤔

Any good way to write a proper port manipulation method for this task?

[hmeijdam]

You only have a delay after showing your last number, so it is showing the first 3 numbers for 0,00000001 second and then the fourth number

[grandaspanna]

As per other response, the other digits are not switched on long enough to be visible. A 'scope should see the small on signal they are getting. I've historically used display drivers, but for a variety of reasons have explored alternatives recently. There are some readily-found libraries that will save you time and they mostly require you to "refresh" the display often enough for the user to see. One example here - have a read through to understand this strategy: https://github.com/DeanIsMe/SevSeg/blob/master/SevSeg.cpp

[SpenceKonde]

Others have covered the issue - the time between when you set the segments and when clear them for the next digit is ... 3 clock cycles (LDI followed by STS.

[dattasaurabh82]

Sorry for the late reply. 😕
So I have moved the common pins to PORTB

A -> PA1
B -> PA2
C -> PA3
D -> PA4
E -> PA5
F -> PA6
G -> PA7
Top display digit 1 Anode -> PB4
Top display digit 2 Anode -> PB5
Bot display digit 1 Anode -> PB6
Bot display digit 2 Anode -> PB7

I have created a displayManager.h for keeping the code separate and re-wrote the multiplexing part as below. (Thanks for @grandaspanna and everyone else for the guidance so far)

unsigned long startMicros;
unsigned long currentMicros;
const unsigned long period = 1;  // the value is a number of Microseconds

void setupDisplay() {
  startMicros = micros();

  //  Cathode Pins for LEDS
  PORTA.DIRSET = 0b11111110; // [ PA 1-7 as Outputs]
  //  Anode Pins for LEDS
  PORTB.DIRSET = 0b11110000;
}

unsigned char num_array[11] = {
  0b01111110, //0
  0b00001100, //1
  0b10110110, //2
  0b10011110, //3
  0b11001100, //4
  0b11011010, //5
  0b11111010, //6
  0b00001110, //7
  0b11111110, //8
  0b11011110, //9
};

int c = 0;

void showOnDisplay(uint8_t * digits) {
  currentMicros = micros();

  if (currentMicros - startMicros >= period) {

    // clear all leds of a segment
    PORTA.OUTCLR = 0b11111110;
    // deactivate all segments by setting them HIGH (My segments are in common Anode config)
    //    PORTC.OUTSET = 0b00111100 ;
    PORTB.OUTSET = 0b11110000;

    // activate the 1st segment
    if (c == 0) PORTB.OUTCLR = 0b00010000;

    // activate the 2nd segment
    if (c == 1) PORTB.OUTCLR = 0b00100000;

    // activate the 3rd segment
    if (c == 2) PORTB.OUTCLR = 0b01000000;

    // activate the 3rd segment
    if (c == 3) PORTB.OUTCLR = 0b10000000;

    // set the number
    PORTA.OUTSET = num_array[digits[c]];

    c++;
    if (c > 3) c = 0;

    startMicros = currentMicros;
  }
}

So I was thinking that void showOnDisplay(uint8_t * digits){} can be further optimised.

#define COMM 0b00010000

void showOnDisplay(uint8_t * digits) {
  currentMicros = micros();

  if (currentMicros - startMicros >= period) {

    // clear all leds of a segment
    PORTA.OUTCLR = 0b11111110;
    // deactivatec all segments by setting them HIGH (My segments are in common Anode config)
    PORTB.OUTSET = 0b11110000;

    // Method 2 (How to bitshift to reduce the previous if else)??
    //------------------------------------------------------------
    // https://github.com/SpenceKonde/megaTinyCore/blob/master/megaavr/extras/DirectPortManipulation.md
    // https://playground.arduino.cc/Code/BitMath/

    //    PORTB.OUTCLR |= (1 << c + 4);    // ??
    //    PORTB.OUTCLR = 0b00000000;  // ??
    //    PORTB.OUT |= 1 << (c);                 // ??

    // set the number one by one
    PORTA.OUTSET = num_array[digits[c]];

    c++;
    if (c > 3) c = 0;

    startMicros = currentMicros;
  }
}

But a bit confused of bit-shifting and there's no one to ask around? 😅🙏🏽

[SpenceKonde]

byte c = 0; //byte (uint8_t ) not int, int takes two instructions to act on instead of 1, even though you're eventually assigning it to an 8-bit register that will truncate it to 8 bits.

uint16_t period = 100;

//1 us is not going to happen, that's 20 instructions :-P 32 if you overclock that thing as hard as you can without busting out the dry ice & acetone bath or liquid nitrogen. So use something sane.

Never do this, it's silly and inefficient:

PORTB.OUT |= anything;
// or
PORTB.OUT &= anything;

That generates:
LDS (3 clock cycles) to load the value into a working register (let's say r0, because that's a perfectly reasonable one for it to pick)
OR/AND what it just read with the anything.
STS (2 clocks) to write it back.
for a total of 5 instruction words and 6 clocks, and it's not interrupt safe (ie, if an interrupt writes PORTB.OUT, and it fires in the middle, it's change will get trashed).
This is why we have the OUTSET, OUTCLR, and OUTTGL registers, AND the why we have the VPORT registers.

Really never do something like THIS:

PORTB.OUTCLR |= anything;
PORTB.OUTTGL |= anything; 

Not only is it the same slow read-modify-write sequence, they also turn off every bit in the port instead of the ones you asked for because the OUT____ registers read the same value as the OUT register!!!

Assuming that you make a point of initializing the top half of PORTB to what it is when c = 0 (if you increment c first) or when c = 3 (if you increment c after) this is likely fastest:

byte this_digit=num_array[digits[c]]; //Hopefully this gets load
byte mask = (0b10011000 << c) & 0xF0; //you need to toggle 2 bits in PORTB.OUT to increment the digit right? 
cli(); //interrupts off so an interrupt can't fire in the middle of these two. 
PORTB.OUTTGL = mask; //Toggle those bits
VPORTA.OUT = this_digit;  //immediately do a direct write of the PORTA value using the (fast) VPORT register
sei(); //interrupts back on

Load or assignment of VPORTs is 1 clock, not 3 or 2 respectively, as is |= when all bits except one are 0, and this value is known at compile time and constant and the inverse, &= when all but one bit is a 1 - those two end up as the atomic sbi (set bit index) and cbi (clear bit index) when used on one of 32 registers in the low IO space (which on modern AVRs is just the VPORTs and the 4 GPRs - on classic AVRs they would sometimes throw other registers in there because they thought they were useful - but it was also an unpredictable mess, and didn't jive with the systematic consistentency and coherent register structure they were going for here. It looked like they chose register locations with a blindfold and a dart board sometimes. The low and high IO space (consisting of the first 64 registers) can be loaded from and stored to in a single clock with a single word instruction (IN or OUT instead of LDS or STS). The classic AVRs also used those for "useful" registers, even though they couldn't fit all the special function registers in there. I think modern AVRs only use 4 or 5 of the 32 high IO addresses; It would have been nice if they had mirrored some frequently accessed registers in the unused ones like how the VPORTs are done; my list would have included either the data registers for the USART/SPI/TWI interfaces, or timer/counter CNT registers. I'm sure there were discussions about that and they decided against it for reasons that even if I don't like, I would recognize as reasonable - it might simply be that everything for which that would be worth doing was already complicated enough)

Anyway - I would be tempted to put TCB0 into periodic interrupt mode and put the update of the digits into the ISR;If you don't have some higher priority use for TCB0 that's definitely the way to go I think (TCB1 is used for millis() timekeeping, and TCA gets used for any PWM)

[dattasaurabh82]

Hello @SpenceKonde
Thanks for such in-depth explanation (As always).
This is my current displayManager.h for Common Anode multiplexed (As shown above in schematic) LED segment displays:

unsigned long startMicros;
unsigned long currentMicros;
uint16_t period = 100;  //the value is a number of micro-seconds

void setupDisplay() {
  startMicros = micros();
  //  Cathode Pins for LEDS
  PORTA.DIRSET = 0b11111110; // [ PA 1-7 as Outputs]
  //  Anode Pins for LEDS
  PORTB.DIRSET = 0b11110000;
}

unsigned char num_array[10] = {
  0b01111110, //0
  0b00001100, //1
  0b10110110, //2
  0b10011110, //3
  0b11001100, //4
  0b11011010, //5
  0b11111010, //6
  0b00001110, //7
  0b11111110, //8
  0b11011110, //9
};


byte c = 0;

void showOnDisplay(uint8_t * digits) {
  currentMicros = micros();

  if (currentMicros - startMicros >= period) {

    // clear all leds of a segment
    PORTA.OUTCLR = 0b11111110;
    // deactivate all segments by setting them HIGH (My segments are in common Anode config)
    //    PORTC.OUTSET = 0b00111100 ;
    PORTB.OUTSET = 0b11110000;

    // ---- Activate one segment at a time ---- //
    cli(); //interrupts off so an interrupt can't fire in the middle of these two.
    byte mask = (0b00010001 << c) & 0xF0; // you need to toggle 2 bits in PORTB.OUT to increment
    PORTB.OUTTGL = mask; //Toggle those bits
    // Immediately do a direct write of the PORTA value using the (fast) VPORT register
    byte this_digit = num_array[digits[c]];
    VPORTA.OUT = this_digit;  
    // Interrupts back on
    sei(); 
    // --------------------------------------- //

    c++;
    if (c > 3) c = 0;

    startMicros = currentMicros;
  }
}

I had to change: byte mask = (0b10011000 << c) & 0xF0; to byte mask = (0b00010001 << c) & 0xF0;
for the below orientation:

A -> PA1
B -> PA2
C -> PA3
D -> PA4
E -> PA5
F -> PA6
G -> PA7
COMM 1 -> PB4 // digit 1's common pin
COMM 2 -> PB5 // digit 2's common pin
COMM 3  -> PB6 // digit 3's common pin
COMM 4  -> PB7 // digit 4's common pin

My self explanation of bit math here:
As I wanted to:
for digit 1, comm 1 needs to be activated
For digit 2, comm 2 needs to be activated
and so on...

i.e:
1st digit LED segment will Turn on in PORTB.OUTCLR = 0b00010000;
2nd digit LED segment will Turn on in PORTB.OUTCLR = 0b00100000;
and so on...

So:
0b00010001 & 0b11110000 would yield 0b00010000
0b00100010 & 0b11110000 would yield 0b00100000
and so on...

So:

0b00010001 << c // bit shifting to the left
 // where c is looping between 0->3 
c++;
if (c > 3) c = 0;

and so:
(0b00010001 << c) & 0xF0 // where 0xF0 is 0b11110000

Also thanks for the interrupt management tip here.

Thanks a lot again. 🙏🏽