Tag Archives: PORT MANIPULATION

Arduino, Electronics, Programming

328P PORT MANIPULATION

Leave a comment

#122 ATMEGA 328P Port Manipulation

Pinout of the 328P
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
//
Pinout of the 328P:
                            __  __
   1              (RESET) |1  \/28| [D19][A5] PC5 (SDA)
   2       (RX) PD0  [D0] |2    27| [D18][A4] PC4 (SDA)
   3       (TX) PD1  [D1] |3    26| [D17][A3] PC3
   4            PD2  [D2] |4    25| [D16][A2] PC2
   5            PD3 [~D3] |5    24| [D15][A1] PC1
   6            PD4  [D4] |6    23| [D14][A0] PC0
   7                  VCC |7    22| GND
   8                  GND |8    21| AREF
   9           (XTAL) PB6 |9    20| VCC
   10          (XTAL) PB7 |10   19| [D13] PB5
   11           PD5 [~D5] |11   18| [D12] PB4
   12           PD6 [~D6] |12   17| [D11~] PB3
   13           PD7  [D7] |13   16| [D10~] PB2
   14           PB0  [D8] |14   15| [D9~] PB1
                           -------
*/

Port manipulation was not important to me when I started working with microcontrollers, in fact I didn’t even know it existed and never felt the need for it especially after programming mostly in java script and PHP using functions like digitalread(pin); or digitalwrite(pin); etc. was second nature and speed or efficiency considerations were not really necessary or thought about that much.

Then after intermittently playing around with embedded ICs I got serious during the corruption virus of 2019 during lockdowns and other dilemmas while a lot of corrupt and diabolical cronies enriched themselves. I had a lot of time to focus on a few different things. There was no way I was going to let the circumstances get to me I made sure I was achieving at least one big goal each year and not get bogged down.

I took a look at the IC market and even though there was a chip shortage there were some IC’s available. This mad me try and get into efficient code and cost per IC. I came to the conclusion that I could get hold of IC’s with low memory + flash and very affordable prices. However in order to use them I would have to learn to use port manipulation, macros and interrupts in very efficient ways to the best of my ability at the time.

Now I needed to find new and comprehensive writeups of the principal and so I found the SpenceKonde
megaTinyCore for the new at the time tinyAVR 0/1/2-series IC’s. The core has a lot explained over the years and was very helpful and easy enough to understand but took a bit of time and real world practical implementations which made learning way more fun and easy. I always need to do practical with theory when it comes to learning I find it very hard to picture learning anything without using it practically.

Now this is about port manipulation on the 328P and I’ll get into the actual implementation now without further ado.

The ATMEGA 328P has 3 ports namely B, C, D with B (digital pin 8 to 13), C (Analog input pins) and D (digital pins 0 to 7).

For the basics you only need to understand 3 types of registers you will be manipulating.

For example:

Port B
PORTB – Maps to Arduino digital pins 0 to 7 Data Register – read/write
DDRB – The Port B Data Direction Register – read/write
PINB – The Port B Input Pins Register – read only

Port C
PORTC – Maps to Arduino digital pins 8 to 7 Data Register – read/write
DDRC – The Port C Data Direction Register – read/write
PINC – The Port C Input Pins Register – read only

Port D
PORTD – Maps to Arduino digital pins 14 to 19 Data Register – read/write
DDRD – The Port D Data Direction Register – read/write
PIND – The Port D Input Pins Register – read only

So an example using DDRD (Data Direction Register) to set input and output pins:

example using DDRD
C
1
2
3
4
//
DDRD = 0b11111110;  // sets Arduino pins 1 to 7 as outputs, pin 0 as input
DDRD = DDRD | 0b11111100;  // this is safer as it sets pins 2 to 7 as outputs
                          // without changing the value of pins 0 & 1, which are RX & TX

Another example is to set digital pins 7,5,3 high:

set digital pins high binary example
C
1
2
//
PORTD = 0b10101000; // sets digital pins 7,5,3 HIGH

Now you can do port manipulation with a bit shift instead of binary or hex. this makes things a bit more readable… excuse the pun. 🙂

For example to set the input or output of a single pin you could use:

input or output example
C
1
2
3
//
DDRB |= (1 << PB3);//replaces pinMode(DATA_PIN, OUTPUT);
DDRB &= ~(1 << PB3); //replaces pinMode(LEARN_PIN, INPUT);

Example using hexadecimal:

hexadecimal input example
C
1
2
//
DDRC = 0x00; // Define all Pins As Input

Now to initiate a pullup on a single pin you could use:

initiate pullup
C
1
2
//
PORTB |= (1 << PB3);//initiate learn pin pullup

Example using hexadecimal:

initiate pullup hexadecimal
C
1
2
//
PORTC = 0x20; // Enable Internal Pull Up Resistor on Pin 5

Example using binary:

initiate pullup binary
C
1
2
//
PORTC = 0b00110000;// Enable Internal Pull Up Resistor on Pin 5 and Pin 4

Looking at how to read a pin you can use the Input Pins Register PINB:

read pins example
C
1
2
3
4
//
uint8_t alarmState = PINB&8;//read alarm pin 3, notice 8
uint8_t learnState = PINB&16;//read learn pin 4, notice 16
uint8_t pinValue = (PINB & (1 << PINB4)) >> PINB4;//read a 0 or 1

it is also possible to toggle a pin and there’s different ways. Some are faster then others:

toggle pins examples
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//
PINB = (1 << PB3);//toggle fastest
PINB |= (1 << PB3);//toggle 2nd fastest
PINB |= _BV(PINB5);//toggle 2nd fastest also
PORTB ^= 0b00100000;//toggle 3rd fastest
PORTB ^= (1 << PB3);// toggle 3rd fastest also
 
// ~70ns pulse using 4 bytes FASTEST
PINB = 0b00100000;//toggle
PINB = 0b00100000;//toggle
 
// ~130ns pulse using 2 bytes
PINB |= _BV(PINB5);//toggle
PINB |= _BV(PINB5);//toggle
 
// ~200ns pulse using 8 bytes
PORTB ^= B00100000;//toggle
PORTB ^= B00100000;//toggle

You can also easily write to a pin low or high:

write high/low example
C
1
2
3
4
//
PORTB |= (1 << PB3);//write high
PORTB |= (1 << PORTB3);//write high with PORTB3
PORTB &= ~(1 << PB3);//write low

There’s also an atomic operation to writing low or high:

atomic writing example
C
1
2
3
//
PORTB &= ~_BV(PB3); // write single pin (atomic op) write low
PORTB |= _BV(PB3); // write single pin (atomic op) write high

So now that we understand the basics we can get into making life easy by creating macros

Below are 4 functions made easy to iterate over all the pins in each port B, C, D

set_PIN_HIGH(pin);
set_PIN_LOW(pin);
read_PIN_STATE(pin);
toggle_PIN_STATE(pin);

This makes it easy to call the function without having to define the port each time and it’s still fast.

See the example below:

DIY macros example
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
//
// LED pin masks
#define LP0  1<<0
#define LP1  1<<1
#define LP2  1<<2
#define LP3  1<<3
#define LP4  1<<4
#define LP5  1<<5
#define LP6  1<<6
#define LP7  1<<7
#define LP8  1<<0
#define LP9  1<<1
#define LP10 1<<2
#define LP11 1<<3
#define LP12 1<<4
#define LP13 1<<5
#define LP14 1<<0
#define LP15 1<<1
 
// pin mask array
uint8_t ledpin_mask[] = {LP0,LP1,LP2,LP3,LP4,LP5,LP6,LP7,LP8,LP9,LP10,LP11,LP12,LP13,LP14,LP15};
 
// turn on LED
void set_PIN_HIGH(uint8_t pin)
{
  if (pin < 8)
  {
       PORTD |= (ledpin_mask[pin]);
  }
  else if ( pin < 14)
  {
       PORTB |= (ledpin_mask[pin]);
  }
  else
  {
       PORTC |= (ledpin_mask[pin]);
  }
}
 
// turn off LED
void set_PIN_LOW(uint8_t pin)
{
  if (pin < 8)
  {
       PORTD &= ~(ledpin_mask[pin]);//write low
  }
  else if ( pin < 14)
  {
       PORTB &= ~(ledpin_mask[pin]);//write low
  }
  else
  {
       PORTC &= ~(ledpin_mask[pin]);//write low
  }
}
 
// read button
uint8_t read_PIN_STATE(uint8_t pin)
{
  if (pin < 8)
  {
       //uint8_t pinValue = (PIND & (ledpin_mask[pin])) >> ledpin_mask[pin];//read 1 or 0
       uint8_t pinValue = PIND & (ledpin_mask[pin]);
       return pinValue;
  }
  else if ( pin < 14)
  {
       //uint8_t pinValue = (PINB & (ledpin_mask[pin])) >> ledpin_mask[pin];//read 1 or 0
       uint8_t pinValue = PINB & (ledpin_mask[pin]);
       return pinValue;
  }
  else
  {
       //uint8_t pinValue = (PINC & (ledpin_mask[pin])) >> ledpin_mask[pin];//read 1 or 0
       uint8_t pinValue = PINC & (ledpin_mask[pin]);
       return pinValue;
  }
}
 
// read button
void toggle_PIN_STATE(uint8_t pin)
{
  if (pin < 8)
  {
       PIND = (ledpin_mask[pin]);//toggle fastest
  }
  else if ( pin < 14)
  {
       PINB = (ledpin_mask[pin]);//toggle fastest
  }
  else
  {
       PINC = (ledpin_mask[pin]);//toggle fastest
  }
}
 
//example of using it
void StartUp()
{
  for(uint8_t i = 0; i < LED_AMOUNT; i++)//
  {
    tone(D_SPEAKER_PIN, D_NOTE_HIGH);
    set_PIN_HIGH(LEDS[i]);
    delay(D_DELAY_TIME);
    noTone(D_SPEAKER_PIN);
    set_PIN_LOW(LEDS[i]);
    delay(D_DELAY_TIME);
  }
}

Links:

Electronics, Programming

328P PIN CHANGE INTERRUPTS

Leave a comment

#120 ATMEGA 328P Pin Change Interrupts

The 328P has 3 ports B, C, D you will need to know the basics of how they work to before reading this.

The 328P only has 2x external interrupts however there are also 23x pin change interrupts and I will be focusing on the latter for now.

INTx (external interrupts) can report events under four situations: low, any, falling, rising. PCINTx (pin change interrupts) can report events on only one situation: any, which is basically a change in the pin so we can categorise the 23x as change interrupts only.

Using these pin change interrupts are surprisingly easy but require a few steps. However once they are configured code size and complexity can be reduced significantly. Also never forget you paid for the IC and it’s hardware peripherals.. so USE THEM.

You can run a loop checking button states with multiple variables including timing and state variables etc. or…. you can run a similar reduced loop with the use of the pin change interrupts making your life so much easier while not compromising much resources.

So to get started you need to follow 3 steps:

  1. Turn the pin change interrupts on
  2. Choose the pins to interrupt
  3. Use the ISR for the chosen pins

STEP 1:

To turn on the pin change interrupts you will need to use the PCICR register.

Writing 1 to bit 0 will turn on the portB (PCINT0 – PCINT7)
Writing 1 to bit 1 will turn on the portC (PCINT8 – PCINT14)
Writing 1 to bit 2 will turn on the portD (PCINT16 – PCINT23)
From bit 3 onwards (from right to left) bits are ignored.

turn on the pin change interrupts
C
1
2
3
4
PCICR |= 0b00000001;//PCIE0 // turn on port b
PCICR |= 0b00000010;//PCIE1 // turn on port c
PCICR |= 0b00000100;//PCIE2 // turn on port d
PCICR |= 0b00000111;//ALL   // turn on all ports

STEP 2:

Now you need to choose which pins you want to interrupt.
You will need to use a mask and the 328P has 3 masks: PCMSK0, PCMSK1, and PCMSK2
These masks are set in the same way as the PCICR register was set.

choose pins to interrupt
C
1
2
3
PCMSK0 |= 0b00000001;// turn on pin PB0, which is PCINT0, physical pin 14
PCMSK1 |= 0b00010000;// turn on pin PC4, which is PCINT12, physical pin 27
PCMSK2 |= 0b10000001;// turn on pins PD0 & PD7, PCINT16 & PCINT23

STEP 3:

Now you need to use the correct ISR for the chosen pins.
make sure to keep the ISR as fast as possible and use as little code as possible in the ISR.
Also if you have any variables in the ISR make sure to make them volatile. This tells the compiler that it could change at any time and to reload it each time instead of optimizing it.

choose correct ISR
C
1
2
3
ISR(PCINT0_vect){}// Port B, PCINT0 - PCINT7
ISR(PCINT1_vect){}// Port C, PCINT8 - PCINT14
ISR(PCINT2_vect){}// Port D, PCINT16 - PCINT23

Full Super Simple Example:

simple example
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <avr/interrupt.h>
 
volatile int value = 0;//make var volatile
 
void setup()
{
cli();//disable interrupts
PCICR |= 0b00000011; // Enables Ports B and C Pin Change Interrupts
PCMSK0 |= 0b00000001; // PCINT0 choose pin PB port
PCMSK1 |= 0b00001000; // PCINT11 choose pin PC port
sei();//enable interrupts
 
Serial.begin(9600);//start serial
}
 
void loop()
{
Serial.println(value);//print value when interrupt is triggered
}
 
ISR(PCINT0_vect)// Port B, PCINT0 - PCINT7
{
value++;//increase value
}
 
ISR(PCINT1_vect)// Port C, PCINT8 - PCINT14
{
value–;//decrease value
}

Links: