All posts by Cale

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:

ATTiny, Experimental, Radio

MAKING A DIY PIR SENSOR

Leave a comment

#121 Making a DIY PIR sensor on protoboard

Front of PCB on proto board

A few years ago I wanted to use some type of sensor for security purposes in my workshop.
I just needed something to sense movement and send a radio signal to my Roboguard device.
An actual Roboguard beam was too expensive, too bulky and large and was not rechargeable… not to mention a bit overkill for my application.

So I decided to look for a low power and small sized PIR sensor. Eventually I was able to find an affordable and small PIR sensor that can operate at 3.3V. I found the MH-SR602 PIR sensor which offers an adjustable delay time with a detection distance of 0 – 3.5 Metres. it has a built in regulator with a range of 3.3 – 15VDC but adds a bit of extra current draw… since I was already using 3.3V for my IC and RF circuits I was able to de-solder the included regulator to save a bit of current. This would help me greatly especially since I was going to use deep sleep.

PCB inside the box I designed it for.
Lid closed only the PIR sensor is sticking out (Radar does not have this problem)

Now the main MCU is the ATTiny212 and the RF module used is the WL102-341… not sure on the authenticity of the module but it works range is good and the current draw is up to spec + the EN pin does disable the unnecessary current draw when pulled low. The LDO regulator I used is the classic HT7333-A.

After soldering everything and checking for shorts I was able to program the MCU and then power up the device with an recycled 550mAh vape battery. First thing I noticed the device would constantly trigger the PIR. Eventually after a long time of troubleshooting I replaced one of the ceramic capacitors used to stabilize the output of the HT7333-A and now everything worked… Now when looking at the capacitor I didn’t understand exactly why it was not working, there was no short only a really high resistance and the capacity was a bit higher than the specified uf.

Before hand I made sure the PCB would fit into a standard rectangular project box. I just needed to drill a hole for the PIR sensor to stick out. After drilling a hole for the micro USB charging port the project was complete and working.

While testing I was able to achieve a very low current draw in deep sleep mode. I did some basic calculations and the MCU should last more then a year without needing a charge. Later after leaving the device in my workshop I was able to confirm this with the device lasting over a year and a half with mild triggering whenever I was working in the workshop. making use of the ATtiny PIT for long sleep timing and interrupts for waking up the device after some code refactoring I was able to make things super efficient. I programmed everything in C. ASMM is a bit to much for low level stuff in my opinion though I would like to make time to learn it one day. Still I was able to create a program of 956 bytes using ram of 18 bytes. So under 1k was nice since the smallest ATtiny size is 2k so I’ve still got plenty of space.

Current when the MCU is in sleep mode (the PIR is always running) 121.9uA roundabouts
772.2uA of current when the MCU is running but RF is not TX’ing
13.1mA during TX

One thing I can say for sure is that this project really activated a habit in me to try make everything as small and as efficient as possible whenever I program 8-bit microcontrollers for my personal projects. I must say I was also able to save some money when buying IC’s by improving my code and what can I say it feels very good once a project is completed and as small and efficient as I could make it.

With that being said sometimes when using a microcontroller like the ESP8266 or ESP32 the resource abundance feels crazy but once I start populating all that space with HTML and bitmaps + other media I quickly realized that even that space can get used up very fast.

C.A Torino

Back of the protoboard
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:

Arduino, Experimental, Programming

MPLABX VS ARDUINO IDE

Leave a comment

#119 Differences and similarities between the two

Recently I wrote about the pros and cons etc. about different programmers used to program embedded devices. I mentioned a few examples like ST-Link, PicKit and standard DIY programmers. Now since programmers work hand in hand with the programming software on your PC I decided to talk a bit about the 2 IDEs I use often. (Although you can easily setup platform IO with a compiler for embedded devices I will be focusing mostly on full IDEs but will make mentions to using text editors)

So I’ll start with the Arduino IDE. it’s simple to install and to get started with. There’s many libraries and there’s a wide support on the internet. Note: at least in my experience in South Africa at the public school I went to there was basically no interest or effort to promote Arduino and similar platforms. Looking back this was very disappointing since I’m 99% sure I would have gotten into Arduino much earlier in life if certain educational departments had made an effort in promoting Science instead of supporting political nonsense like the “science must fall” movement but I digress.

That being said Arduino is not all fun and games, it’s a great learning introduction tool but can promote bad code practices and reliance on libraries for work. Arduino also heavily promotes using easy functions instead of port manipulation methods… even in advanced projects… this can be a bit annoying especially when you want to use a library in a project with a different MCU and also when you want to keep code small and efficient. This can really bloat your MCU code and as you can imagine there is really not much room “literally” when programming embedded devices. Macros for port manipulation can really help but relying on digitalwrite(pin1); to pull a pin high or low can really cause some confusion later on

There may be more pros and cons not mentioned above but really I just want to get into the stuff that I can mention off the top of my head for this article.

Now switching to the free MPLABX IDE. I can say that the learning curve is quite steep but easy to get into with repetitive use. Once you get familiar with the layout you can start seeing quite a few pros compared to Arduino. having the ability to view the entire file structure in the IDE helps a ton. Also AVR has been integrated into MPLABX for some years now so you can easily program Arduino style. The IDE promotes professional main.c files and avr-main.c files which is very cool (I’m not really into ASM programming at least for now there’s a very big learning curve but one day I’ll get into it I hope 🙂 ) MPLABX also supports a huge variety of ICs and you can easily download updates for these as well as some libraries. Another pro is the GUI MCC (MPLAB Code Configurator) ok, ok I’m not a huge fan because I always somehow bloat up my project and break things but I can totally see how it could help by providing a GUI for setting clocks and bits etc. Another cool feature is that there are options for dark mode in the ide and it uses NetBeans.

There are a few downsides to the MPLABX IDE for example when using a 4k screen the Nebeans part always has blurry visuals now you can adjust the DPI but then all the text is super small and when adjusting the text it becomes inconsistent in certain places. Like for example the IDE text is small but your code text is big. This has always been an issue for me but I guess I’m just suffering from a 4k screen 🙂 Another issue is that I have always had to use expensive dedicated programmers when using MPLABX non of my DIY CH340N etc. programmers will work with MPLABX. Also programming AVR requires an AVR programmer so you can’t just use a PicKit3 for everything. Another pro is that it’s easy to choose compilers in a list. You cans install multiple compilers without issue. Another great feature is that you can install the so called MPLABEXT extension using visual studio code so you don’t have to use the IDE but can keep compatibility. Another cool feature is the ability to read and program the fuses or (configuration bits for PIC). Once again there may be some pros and cons not mentioned but I’m just writing this off the top of my head.

An honourable mention goes to the text editor approach. This is very light weight and generally bloat free and offers a lot of flexibility which makes using visual studio code a great choice but of course it’s not really a dedicated IDE.

Now to close off I will include to code samples to show the differences between the Arduino IDE and MPLABX IDE I will be programming an AVR device the ATtiny826 in the comparison examples.

Arduino blink code example including a blink without delay and a fast blink sample I made :

Arduino Advanced Blink Example
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
/*
* RoboTiny
*
* Arduino ATTINY3226-SU Tester
*
* @category   Arduino ATTINY3226-SU Advanced Blink Sketch
* @package    C++ Alarm Sketch
* @author     C.A Torino
* @version    V1.0.0
* @since      13th Mar 2024
* @hardware   ATTINY3226-SU Modified
* @notes      null
 
Pinout of the ATTINY3226-SU:
  20 pin SOIC, SSOP
                            __  __
   1                  VDD |1  \/20| GND
   2                  PA4 |2    19| PA3 (EXTCLK)
   3                  PA5 |3    18| PA2
   4                  PA6 |4    17| PA1
   5                  PA7 |5    16| PA0 (UPDI/RESET)
   6                  PB5 |6    15| PC3
   7                  PB4 |7    14| PC2
   8                  PB3 |8    13| PC1
   9           (TOSC1)PB2 |9    12| PC0
   10           TOSC2 PB1 |10   11| PB0
                           -------
                          
Sketch uses 430 bytes (5%) of program storage space. Maximum is 8192 bytes.
Global variables use 9 bytes (0%) of dynamic memory, leaving 1015 bytes for local variables. Maximum is 1024 bytes.
 
*/
 
#define D_LED_AMOUNT 1//Amount of LEDs
 
bool AN_LED_BLINKING = false;//Is an LED blinking
 
uint32_t previousMillis = 0;// will store last time LED was updated
 
const uint16_t interval_time = 2000;// interval at which to blink (milliseconds)
 
const uint16_t ON_TIME = 10;//Blink on time 10ms=good as well, 50=good flash
 
const uint8_t LEDS[D_LED_AMOUNT] = {
  PIN3_bm//PA3 LED
};
 
void setup() {
  PIN_config();//Initiate pin settings
  DISABLE_peripherals();//Disable unused
 
}
 
void DISABLE_peripherals()
{
  ADC0.CTRLA = 0;//Disable ADC, saves ~230uA
  TCA0.SPLIT.CTRLA = 0; //If you aren't using TCA0 for anything
  TCB0.CTRLA = 0; //disable TCB0
  USART0.CTRLA = 0;//disable usart
  SPI0.CTRLA = 0;//disable spi
  BOD.CTRLA = 0;//disable bod
  AC0.CTRLA = 0;//disable AC
  //DAC0.CTRLA = 0;//disable DAC (Not in AVR-2 series)
}
 
void PIN_config()
{
  //all pins start as an input but it's good to make a human readable note
  VPORTA.DIR = 0b11111111; //read from right to left: 0b11111111 same as p7=1 p6=1 p5=1 p4=1 p3=1 p2=1 p1=1 p0=1;  1=output 0=input
}
 
void Blinking() {
  // check to see if it's time to blink the LED; that is, if the difference
  // between the current time and last time you blinked the LED is bigger than
  // the interval at which you want to blink the LED.
  uint32_t currentMillis = millis();
 
  if (currentMillis - previousMillis >= interval_time) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;
    // set the LED with the ledState of the variable:
    //digitalWrite(ledPin, ledState);
    VPORTA.IN |= LEDS[0];//toggle LED
  }
}
 
void Blinking_Fast() {
  
uint32_t currentMillis = millis();//Get current millis
  
if(AN_LED_BLINKING)//If an LED is blinking
{
    if( (currentMillis - previousMillis) >= ON_TIME)//determine the on time and logic for rollover
    {
      AN_LED_BLINKING = false;// change the state of LED
      previousMillis = millis();// remember Current millis() time
    }
}
else
{  
   if( (currentMillis - previousMillis) >= interval_time)//determine the off time and logic for rollover
   {    
     AN_LED_BLINKING = true;// change the state of LED
     previousMillis = millis();// remember Current millis() time
   }
}
 
for (uint8_t i = 0; i < D_LED_AMOUNT; i++) //loop through LEDS
{
   if(AN_LED_BLINKING)//If the led is blinking
   {
      VPORTA.OUT |= LEDS[i];// LED HIGH
   }
   if(!AN_LED_BLINKING)//If the led is not blinking
   {
      VPORTA.OUT &= ~LEDS[i];// LED LOW
   }    
}
      
}
 
void loop() {
//Blinking();
Blinking_Fast();
}



MPLABX blink code example including a blink without delay and a fast blink sample I made :

MPLABX Advanced Blink Example
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
/*
* MAIN Generated Driver File
*
* @file main.c
*
* @defgroup main MAIN
*
* @brief This is the generated driver implementation file for the MAIN driver.
*
* @version MAIN Driver Version 1.0.2
*
* @version Package Version: 3.1.2
 
© [2024] Microchip Technology Inc. and its subsidiaries.
 
    Subject to your compliance with these terms, you may use Microchip
    software and any derivatives exclusively with Microchip products.
    You are responsible for complying with 3rd party license terms  
    applicable to your use of 3rd party software (including open source  
    software) that may accompany Microchip software. SOFTWARE IS ?AS IS.?
    NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS
    SOFTWARE, INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT,  
    MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
    WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
    INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY
    KIND WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF
    MICROCHIP HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE
    FORESEEABLE. TO THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP?S
    TOTAL LIABILITY ON ALL CLAIMS RELATED TO THE SOFTWARE WILL NOT
    EXCEED AMOUNT OF FEES, IF ANY, YOU PAID DIRECTLY TO MICROCHIP FOR
    THIS SOFTWARE.
 
* File:   avr-main.c
* Author: User501
*
* Created on November 4, 2024, 5:27 PM
*
*  * RoboTiny
*
* MPLAB X ATTINY3226-SU Tester
*
* @category   MPLAB X ATTINY3226-SU Advanced Blink
* @package    C++ Alarm Sketch
* @author     C.A Torino
* @version    V1.0.0
* @since      4th Nov 2024
* @hardware   ATTINY3226-SU Modified
* @notes      null
 
Pin out of the ATTINY3226-SU:
  20 pin SOIC, SSOP
                            __  __
   1                  VDD |1  \/20| GND
   2                  PA4 |2    19| PA3 (EXTCLK)
   3                  PA5 |3    18| PA2
   4                  PA6 |4    17| PA1
   5                  PA7 |5    16| PA0 (UPDI/RESET)
   6                  PB5 |6    15| PC3
   7                  PB4 |7    14| PC2
   8                  PB3 |8    13| PC1
   9           (TOSC1)PB2 |9    12| PC0
   10           TOSC2 PB1 |10   11| PB0
                           -------
ATtiny826
Packs
ATtiny_DFP (3.1.260)
PICkit 5 (2.6.557)
Compiler Toolchain
XC8 (v2.50) [C:\Program Files\Microchip\xc8\v2.50\bin]
Production Image: Optimization: +space +asm
Device support information: ATtiny_DFP (3.1.260)
Memory
Data 1,024 (0x400) bytes
Data Used: 1.3%
Data Used: 13 (0xD) Free: 1,011 (0x3F3)
Program 8,192 (0x2000) bytes
Program Used: 6.3%
Program Used: 516 (0x204) Free: 7,676 (0x1DFC)
 
*/
 
//this gives an accurate time
#define F_CPU 2500000// 2.5Mhz; cpu frequency in Hz
 
#include <avr/io.h>//AVR functions
#include <avr/interrupt.h>// for interrupts
#include <util/delay.h>//for delay
 
#define D_LED_AMOUNT 1//define led amount
 
const uint16_t interval_time = 2000;// interval at which to blink (milliseconds)
 
const uint8_t LEDS[D_LED_AMOUNT] = {
  PIN3_bm//PA3 LED
};
 
const uint16_t ON_TIME = 10;//LED on time 10ms=good as well, 50=good flash
volatile uint32_t MIL_counter = 0;// millis counter variable
 
uint32_t interval, nowmillis, previousMillis = 0;// for timing calculation in millis
 
_Bool AN_LED_BLINKING = 0;//LED blinking set to false=0
 
// Init millis counter
void MIL_init(void) {
  TCB1.CCMP    = (F_CPU / 1000) - 1;              // set TOP value (period)
  TCB1.CTRLA   = TCB_ENABLE_bm;                   // enable timer/counter
  TCB1.INTCTRL = TCB_CAPT_bm;                     // enable periodic interrupt
}
 
// Read millis counter
uint32_t MIL_read(void) {
  cli();                                          // disable interrupt for atomic read
  uint32_t result = MIL_counter;                  // read millis counter
  sei();                                          // enable interrupt again
  return result;                                  // return millis counter value
}
 
// TCB0 interrupt service routine (every millisecond)
ISR(TCB1_INT_vect) {
  TCB1.INTFLAGS = TCB_CAPT_bm;                    // clear interrupt flag
  MIL_counter++;                                  // increase millis counter
}
 
void PIN_config()
{
  //all pins start as an input but it's good to make a human readable note
  VPORTA.DIR = 0b11111111; //read from right to left: 0b11111111 same as p7=1 p6=1 p5=1 p4=1 p3=1 p2=1 p1=1 p0=1;  1=output 0=input
}
 
void DISABLE_peripherals()
{
  ADC0.CTRLA = 0;//Disable ADC, saves ~230uA
  TCA0.SPLIT.CTRLA = 0; //If you aren't using TCA0 for anything
  TCB0.CTRLA = 0; //disable TCB0
  USART0.CTRLA = 0;//disable USART
  SPI0.CTRLA = 0;//disable SPI
  BOD.CTRLA = 0;//disable bod
  AC0.CTRLA = 0;//disable ACl
  //DAC0.CTRLA = 0;//disable DAC (not used in Tiny-2 series)
}
 
void Blink_LED_Blocking() {
    VPORTA.OUT |= LEDS[0];       // LED HIGH
    _delay_ms(interval_time);//blocking delay
    VPORTA.OUT &= ~LEDS[0];      // LED LOW
    _delay_ms(interval_time);//blocking delay
}
 
void Blink_LED_Non_Blocking(uint32_t currentMillis) {
 
  if (currentMillis - previousMillis >= interval_time) {//set rollover and calculate delay time
    previousMillis = currentMillis;//set millis global var
    VPORTA.IN |= LEDS[0];//toggle LED
  }
}
 
void Blinking_Fast(uint32_t currentMillis) {
  
if(AN_LED_BLINKING)//if LED is HIGH
{
    if( (currentMillis - previousMillis) >= ON_TIME)//on time check rollover
    {
      AN_LED_BLINKING = 0;// change the state of LED
      previousMillis = currentMillis;// remember Current millis() time
    }
}
else
{  
   if( (currentMillis - previousMillis) >= interval_time)//check off time rollover
   {    
     AN_LED_BLINKING = 1;// change the state of LED
     previousMillis = currentMillis;// remember Current millis() time
   }
}
 
      for (uint8_t i = 0; i < D_LED_AMOUNT; i++) //0,1,2,3 first 4
      {
          if(AN_LED_BLINKING)//if LED is blinking
          {
            VPORTA.OUT |= LEDS[i];// LED HIGH
          }
          if(!AN_LED_BLINKING)//if LED is not blinking
          {
            VPORTA.OUT &= ~LEDS[i];// LED LOW
          }    
      }
      
}
 
int main(void)
{
    //volatile uint32_t MIL_counter;
    PIN_config();//configure the pins
    DISABLE_peripherals();//disable unused
    MIL_init();//initiate harware timer TCB1
    
    while(1)
    {
      nowmillis   = MIL_read();// read custom DIY millis counter
      Blinking_Fast(nowmillis);//Blink LED fast
      //Blink_LED_Non_Blocking(nowmillis);//Blink LED non blocking delay
      //Blink_LED_Blocking();//Blink Blocking
    }        
}

Electronics, Programming

DIFFERENT PROGRAMMERS

Leave a comment

#118 A look at different types of programmers

Different programmers for different IC’s some work with others.. some don’t

Over the years I have used different programmers for PIC,AVR,ST,ESP and WCH microcontrollers from simple FTDI TX RX programming to more advanced PICKit 5 dedicated programmers.

All the different types have their pros and cons but by far the most used by me is the cheap FTDI and serial TTL types for example programmers using the CH340, PL2303 and FT232 IC’s

Though the PL2303 is outdated there’s still many floating around and certain applications require the IC like when interfacing with old radios.

PICKit3, PICKit3.5 and the new PICKit5

With that being said you may ask why do we need a dedicated programmer? Well it depends…

Using the cheap common options I just mentioned above is good enough for a hobbyist but when you design a product you want something that’s is reliable common and has a guaranteed life span with support for the foreseeable future so that you will always have parts available for projects and the programmer.

USBasp AVR Programmer using SPI
STM Programmer


WCH-LinkE programmer can also program STM IC’s

Another big point is uniformity, dedicated programmers will usually be using parts with certain thresholds and voltages + current etc. all that data will be kept constant and accurate while a cheap programmer will most likely have a huge threshold..

A very important point is the ISP + debugging. A dedicated programmer will be able to do programming and debugging easily with a few pins. While a cheap programmer will require more pins and many times 2x programmers… 1 for debugging and 1 for programming.

BUS PIRATE can program with SPI
Arduino Nano with built in CH340 IC for serial programming
A n old DIY programmer of mine based on the CH340N IC

Dedicated programmers also have full support by the IC company as long as you have an original also they offer some really useful features like the PicKit5’s blue tooth option and stand alone programming or changing of source binaries on a phone.

All you need is the programmer and a phone is optional if you need to change things like binaries but really you can give a pickit5 to any technician and they can easily update supported IC’s without needing to mess around on a desktop/laptop computer. This is a very useful feature.

Now there also are EEPROM programmers and true universal programmers that can do EEPROMS and MCU’s like the old TL866II Plus which has a list here of all the supported IC’s. These programmers work well and allow easy access for single IC’s some can also read and write when an IC is in circuit but others require de-soldering. These programmers are usually quite large with Zif sockets.

EEPROM Programmer CH341B
Universal programmer the TL866II Plus

Now I just mentioned a few examples there is much more to talk about but I’m not going to be writing books here…

Electronics, Experimental

DIY UPDI PROGRAMMER

Leave a comment

#117 A DIY UPDI plug and play board

Making fast and crude but reliable programmers

When getting into the new ATtiny series (tinyAVR-0 tinyAVR-1 tinyAVR-2 IC’s) of microcontrollers a few years ago I noticed how easy it had become to program them with only a few extra components.

I started out with just a 4.7k resistor and a cheap CH340 programmer. Then 3 wire hook-ups later I could easily program my IC’s. The only downside was that I had to sacrifice the UPDI pin to the dedicated Pin gods.. so I couldn’t use that pin unless I wanted to make my life more difficult.

Well this was okey for me and ever since I always have the UPDI pin open only for programming. So all my designs incorporate this principal. If I really need more pins I would use an affordable IO expander IC.

Now with that being said it’s all good and well programming with a mini rats nest… but I wanted to create a simple plug and play DIY programmer with commonly available parts and plug and play compatibility.

So I came up with a small circuit that’s easy to build on stripboard. I created a few versions over the years. Since I was the only one using this contraption I didn’t think of creating a professionally made PCB but that will come in future..

Front of the stripboard
Back of the stripboard

How do I use this?

Basically I solder the SMD package ATtiny to a suitable breakout PCB then I plug the ATtiny breakout PCB into my programmers female headers making sure the orientation is correct and presto all I need to do is upload my firmware. Then I can just remove the PCB and Plug it into my project

Simple and to the point… plus it’s been working for years.

Experimental

30W LED DAYNIGHT REPAIR

Leave a comment

#116 Repairing A 30W Day Night LED Light.

30W LED with added 2.2UF film capacitor in series with Live wire.

Over the past year I’ve had to replace multiple LED lights with Day Night switch sensors in them. after multiple failures I decided to open one up to take a closer look at the cause for failure. Usually the LEDs are running hot and driven very hard from the factory so it’s not uncommon to see many black spots indicating burnt out LEDs in the light.

One way of extending the life of the led light is to reduce the power burning out the LEDs. This can be done easily by inserting an AC film capacitor in series with the live wire before connecting it to the light. this works great for reducing power and thus reducing the brightness of the light but it did not solve my issue.

2.2uf film capacitor helps reduce the power and strain on the LEDs.

In this case my light fails to switch on. when I opened it… The LEDs were still ok now on looking at the day night sensor I determined that the circuitry had failed. Failed how?

Well I had to investigate for a bit but eventually determined that the capacitive dropper was not supplying enough current for the transistor to swich from day to night. Why?

Day night sensor in the 30W light.


Well because the capacitor value had decreased somehow.
seems that low quality film AC capacitors are used and their capacity drops maybe they deteriorate or loose electrolytic liquid I’m not exactly sure but when I replaced the capacitor with a new one everything worked again.

Faulty capacitor should be 220nf.
Replacement and faulty. Both questionable quality…
Electronics, Experimental

DIY LORA MODULE

Leave a comment

#115 Making A DIY LoRa Module

2x DIY LoRa RFM95W modules with adapter boards.

When taking a closer look at the DIY aspect of lora I wanted to test LoRa peer to peer.. E.G multiple peers to one peer (NOT LoRa WAN) I noticed that the actual radio PCB is difficult to use when going the traditional through hole way… adapter boards do exist but are few and far between at least in SA. you can make your own for manufacture but then rather create your entire product PCB for manufacture.

Even with this drawback I was able to source old adapters for one of the very firs modules the: RFM95W. In South Africa we are mostly using 868Mhz although 433Mhz modules are around I don’t see them being super common in terms of LoRa modules.

The modules I used have a footprint for adding a female SMA connecter for easy antenna connecting.

Parts used:

  • 2x RFM95W 868Mhz LoRa module transceiver
  • 2x 3.3v active buzzer
  • 2x 1 pole dip switch
  • 2x TP4056 module with protection ICs
  • 2x ATtiny404 MCU
  • 2x NCV8163 3.3V LDO
  • 2x SSD1306 128×32 OLED
  • 2x 2pin 2.5mm JST battery connector
  • 2x Headers and jumpers
  • 2x 13400 3.7V 550mAh
  • 2x 10k resistors
  • 2x 220R resistors
  • 2x SOIC to DIP adapter PCB
  • 2x BC547 transistors
  • Some 0.9mm tin plated copper wire
  • Some 0.255mm PVC insulated wire
Soldering made slightly easier…

After checking the PCB I commenced with testing the devices. Unfortunately the test area has largely mountains terrain
the signal works really well and penetrates better through foliage on the mountains terrain but once there is a full on mountain in the way the signal stops. so in this retrospect the devices are better then a radio which was quite interesting but makes sense because data is being sent and uses less bandwidth then interpreting voice audio. Also the error checking for LoRa helps a lot.

Some more pros for the LoRa is that its a transceiver out of the box with RSSI functions included. Also for increased range and/or quality the spreading factor and signal bandwidth can be adjusted.

Although there’s many pros regarding LoRa I still tend to use simple 433.92 RF modules without issue at least in my situation with rural areas under about 3KM at and given point.

So it really becomes more of a cost factor than anything else. Although I’m happy selling a custom LoRa product for compatibility with LoRa WAN or some other requirement with a similar principal. Plain old generic RF is still cool in my book.

Back of one of the PCBs

Electronics

WACO GP16 REPAIR

Leave a comment

#114 Repairing a 2 year old Waco day night switch

Inside the module I noticed the relay has no cover on it and a resistor and MOV were kind of in the way of the relay terminals…

Recently I had a Waco day night switch start to show faulty signs. Namely once dusk came the relay in the device would oscillate very fast for a few seconds effectively switching the light on/off very fast making a racket while stressing the LEDs out.

The relay would finally settle… mostly on the ON setting but sometimes it would settle on the OFF position. Then if you slightly bang the relay it would oscillate and settle on the ON position.

So I removed the switch and notices there was a lot of spider webs and critters close to the external AC connections. I cleaned the outer case and also notices a brown burn mark where the relay was located. This was due to sparks from the constant ON/OFF switching since the relay in this module had no cover.

The PCB was covered in a white powdery substance.

Now technically I did not have to open the module but I wanted to see if anything else was damaged. I opened the module and everything looked good except for the relay contacts which looked a bit beat up but were working ok..

I noticed that a resistor and a varistor were very close to the relay and could technically jam it’s opening/closing capability so I moved then away from the contacts and put everything back together again.

I now tested the module again and voila there is no more oscillations. So the grimy critters on top of the AC leads and the resister MOV combo close to the relay contacts were the likely culprits however my money is on the latter. So on re-installing I added extra tape and some silicon to seal the AC terminal blocks completely. A thin layer of silicone can still easily be removed for further maintenance and/or repair.

Testing the module to make sure the relay is getting the correct voltage etc.
Electronics

MULTIMETER VOLTAGE ADJUSTMENT

Leave a comment

#113 2011 Major Tech MTD84 Voltage Adjustment

The old meter has been through various toolbox banging battles..
Guts of the old multimeter. Very crusty with lots of through hole components and electrolytic capacitors. I replaced a damaged button as well as adjusting the voltage.

I have had the Major Tech MTD84 multimeter for 11 years now. Before I went off to another city far away for my first job my father purchased it for me as a parting gift. It was a low to mid range meter at that time and seems to be currently discontinued.

Now my meter is beat up but it reads just fine for the may DC projects I make however the voltage started to drift and has slowly become less accurate.

Luckily there is a few variable potentiometers on the PCB which can be adjusted to bring the accuracy back up to spec again. They allow for the DC, AC and Temp values to be adjusted no current option from what I could see. Even though I have a few multimeters I still can’t seem to throw this old one away…

Adjustable pots found on the back for easy access. Though they are very crusty…

So in order to set the correct voltage I had to connect a known working accurate multimeter to a battery along with the faulty one. For this I used the aneng8009 which has very good current and voltage accuracy for a cheapie.. Know I slowly adjusted the voltage variable potentiometer until the volts were mostly the same on each meter. (even though the MTD84 only has 2 decimal places it’s still close enough)

Very cool now the old multimeter is not so bad anymore with all it’s through hole resistors and electrolytic capacitors… perhaps next time I’ll have to replace a dry capacitor.

Button replacement success.