Category Archives: Experimental

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
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, 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

Experimental

12V BATTERY REVIVAL

Leave a comment

#110 Reviving an old 100A 12v lead acid battery

After the first zap the battery was around 4V…

Why do some South Africans have to scrape the bottom of the barrel reconditioning old batteries?

Opening themselves up to potential health concerns and pollution of the environment?

Maybe I can explain.

We’ve had load shedding for years now and with the recent shenanigans for almost half a decade it’s got exponentially worse with even the ultra wealthy feeling it a bit.

You’d think these clever a wealthy men would have come up with a solution by now… but it’s seems as if they have either found a way to get comfortable or they just don’t care… As long as they are making money from their diabolical cadres and corrupt hand shakers why should they care? After all they can run their water, washing machine, stove and medical equipment because they either don’t get loadshedding in their public servant mansions or they have installed million rand solar systems using taxpayers monies it’s a win-win “we fail upwards in life”.

All this while endorsing terrorist activities blatantly with no recourse or accountability using South Africa’s past to manipulate the current population into submission for the “election year” the audacity is unbelievable.. but yeah with the 30% pass rate these guys have dumbed us down and are extremely comfortable in the current climate they have designed. They really set an honourable bar to pass. I could go on but this is article is about a battery.

Seems bleak and it’s hard to ignore or be patriotic and loving towards your county and fellow citizens when there’s so much negative energy being pumped in by the guys we are supposed to trust in looking after us.. giving our data to, trusting their banks… No wonder there’s so much crime and hate.. these guys flourish in it like bacteria fueled by glucose eating a tooth. Even when the tooth is rotten the bacteria continuous to eat and will.. if not treated get into the bloodstream infecting the entire body. The bacteria doesn’t take into consideration that in future it will die along with the tooth it just consumes indiscriminately.

With that being said lets get into battery reconditioning.

Recently I got hold of an old 12v lead acid 100A battery. This battery was bought 20 years ago and stored in a corner for a rainy day.

The battery was never charged and never used.

Upon inspection the battery was at around a measly 1.95V.. this did not look good but luckily I have a DC MIG/MMA welder and decided to use the good old crude welding trick on this big boy.

I removed the MIG setup and installed the stick clamp to the + terminal and the ground to the – terminal. see the photo.

Welder settings:

I set the welder volts to about 21V and the amps to around 25A. Make sure you are using a DC welder AC will NOT work.

Make sure you do this outside or in a well ventilated room. It’s VERY important.. battery acid is no joke to organic materials.

First I did 21v at 25A for 5 minutes then let the battery rest for a whole day to observe it.

Once I concluded it seemed like it was fine my formula was 21v at 25A for 5 minutes then a 10 minute cooldown in between.

I did this 6 times and measured the battery in between times.

Times:

cycle: 19.17 V
cycle: 29.50 V
cycle: 310.97 V
cycle: 411.41 V
cycle: 511.75 V
cycle: 611.77 V

Once this was done I let the battery rest for a day.

Battery at 9V

Now comes the patience part… The battery could hold a charge but ever so slightly would drain and it was supper thirsty.

So I setup a dumb charger at 5A and let the battery charge up for a few days checking intermittently.

Next I setup my recondition charger and let it do it’s thing for a week and what do you know the recondition charger reported great values.

However the battery was still thirsty so I switched back to the 5A dumb charger and let it run for another week..

Fast forward about 3 weeks of low current and recondition charging and the battery seems to be doing fine

Holding a rock solid 12.6V and running my LED lights.

So my conclusion is that it is possible to desulfate and recondition a 100A lead acid battery that has never been used. The initial welder zapping was only the start I needed at least 3 weeks after that to “recondition” the battery to a useable state and I still don’t know the long term potential issues.

It really was just a patience game and also don’t do anything like messing around with the acid weights.

I would still like to figure out how to balance acid and water plus all the battery chemistry stuff but for now this welder trick is good enough.

UPDATE:

About a week later the battery began acting up again seems the internal resistance is high and there is a constant draw bringing the battery voltage down.

Overall I can say that this was a temporary solution and at the moment I don’t have all the fancy battery tools or chemistry knowledge to experiment further.

Also though the battery has issues it can still be somewhat used for low voltage applications now. So I guess I’ll view this as a feature instead of a bug 🙂 cheers

Electronics, Experimental

COMMON RF MODULES IN SOUTH AFRICA

Leave a comment

#109 Types of 433Mhz RF modules in ZA

FS1000A module at 5v no attenuator just using antenna.

Recently I have been using wireless technologies for a few projects.

While looking for a balance between price, functionality and disposability I decided to focus on the 433Mhz RF modules.

These use a free spectrum and have been around for a long time. There’s is a few different types and kinds, with LORA being kind of new and better in almost every way but this comes at a high price compared with the standard 433 RF modules.

So I purchased a few receivers and transmitters from electronics suppliers located in South Africa.

All my tests consisted of running the 4 receivers at 5v and a single 17.3cm straight LAN cable strand as an antenna. The signal sent was a 23bit ASK signal with a pulse length of 1200ms.

All 3 transmitters were tested at 3.3v with a single 17.3cm straight LAN cable strand as an antenna.

The transmitters testes were the FS1000A, CYT1 and the WL102-341.

The crude module actually has more power and range at 5V but I am using them at 3.3v for super low power applications so In this case the module loses.

The Tests were done on farm land.

All transmitters could trigger the receivers at 400m line of sight but only a few could penetrate foliage and a galvanised steel shed.

I only needed MAX 400m which is why I stopped there but some sources claim up to 600m – 800m + for these superheterodyne modules. Not as good as LoRa but for the price what reason do I need not to use them?

*Sidenote Using RF or LoRa in conjunction with a 2.4G Wifi module like the ESP32 or even 3G/4G modules can create multi dimensional divers systems. where we are leveraging the long range and penetration + power output of 433Mhz and 868Mhz but also allowing packets of data to connect over the internet to be stored on a server for data analysis and the creation of graphs to make the data more visually appealing.

Currently I do have some pilot devices and hope to one day make some good quality sensors in 3 different tiers:

  1. Cheap and disposable sensors
  2. Affordable long term sensors
  3. High end sensors

These will be focused on use within rural outdoor areas and I will have a version with Gerber files and schematics etc. available for anyone to download and make for themselves. However the more refined version with a nice enclosure and style will be sold commercially since I do want to be paid for my work.

Back to the modules..

The transmitters that support 5v could penetrate a little better sometimes.

The position of the transmitter/receiver could also greatly affect the received signal especially at range.

Also during summer and during rain the signal was worse with the foliage and water most likely absorbing and/or reflecting the signal

All receivers were superheterodyne with a crystal and I did not use any counterpoise though it would help in some circumstances it makes the receiver unpractical and large.

From worst to best

Some people may wonder why I am using these modules instead of the fashionable LoRa modules. This is simply due to cost and availability.

Designing a good circuit cost time and money. Inserting said circuit into an extremely hostile environment like for example.. rural South Africa is an even more costly exercise…

I have had devices damaged by the sun, damaged by water, damaged by ants, damaged by cows, damaged by some kind of rabid animal (assuming jackal) The list goes on.

AND I have not even mentioned the human element… devices damaged by criminals some even STOLEN… for what? You telling me that criminal is sitting in the bush conspiring to reverse engineer my simple circuit and RF protocol and some how will be able to defeat Microchips code protection? I highly doubt it but it is possible…

So now I hope you can understand why these cheap modules do work and are very useful + inexpensive for my purposes.

I also have LoRa versions but for now I only use those when distance and extreme sensitivity is needed.

Electronics, Experimental

IP5306 MH-CD42 HEARTBEAT

Leave a comment

#108 Low current standby fix for IP5306 MH-CD42

BC547B NPN Transistor
IP5306 Module

Over the past few years I have been using the IP5306 chip and specifically the module shown in the image above.

The module is a great all in one solution for LiPo battery powered projects: charge, discharge, protection, 5v step up etc.

That being said there is 1 massively annoying caveat:

If the load current drops below 45mA during 32 seconds, the IP5306 will go into standby mode…

For low power battery operations this is simply unacceptable.. and I will not simply increase the current draw to keep it on.

There is an I2C version which allows us to change a few settings like standby mode in the IP5306 but for this fix I will focus on the “dumb version”.

Solution

An easy solution is to create a simple heartbeat circuit.

Since there is a button which will prevent the IC from going into standby mode, if pressed it will reset the *32 seconds 45mA* timer.

The module I have also has a solder pad where I can easily solder a wire to control this button via an MCU.

Using a *BC457 NPN* transistor we can create a simple switch to “press the button” at least once within the 32 seconds within a loop.

In this way we can constantly keep the module powered.

Parts

– NPN transistor (I used the BC547B)

– resistor (1k is fine)

– hookup wires

Connections

The Base connects to the resistor and then your MCU pin of choice.

Emitter gets connected to GND.

Collector gets solddered to the button pad.

Code

Once everything is soldered and double checked you can then add the code for the heartbeat.

In this case I use the millis() function and a simple repeating timer all written in a sketch .ino

Heartbeat sketch 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
/*
* IP5306 Heartbeat sketch
*
* Arduino ATtiny412 IP5306 Heartbeat
*
* @category   Heartbeat sketch examples
* @package    Power Sketch
* @author     C.A Torino
* @version    V1.2.0
* @since      26nd March 2020
* @hardware   ATTINY412 Modified
* @notes      -
*
*/
 
#define IP5306_HEARTBEAT_PIN PIN3_bm//PA3 PIN3_bm PIN_PA3
 
unsigned long Delay_IP5306_Heartbeat;
unsigned long Delay_IP5306_Heartbeat_Led;
 
const unsigned long IP5306_HEARTBEAT_TIMEOUT = 15000;//loop every 15s
 
const unsigned long HOLD_TIME = 150;//time to hold button
 
bool ButtonD = false;
 
void setup()
{
  PORTA.DIRSET = IP5306_HEARTBEAT_PIN;//set output
  PORTA.PIN3CTRL = PORT_PULLUPEN_bm;//initiate learn pin pullup PIN3CTRL = PIN3_bm
  Delay_IP5306_Heartbeat_Led = Delay_IP5306_Heartbeat = millis();//set to current millis at start
  PORTA.OUTCLR = IP5306_HEARTBEAT_PIN;//write low, do this after setting output and pullup
}
 
void IP5306_Heartbeat()
{
  /*
  # If button is pushed longer than 30ms but shorter than 2s, IP5306 will identify the action as short push. Short push will open SOC indicator LEDs and step-up converter
  # If button is pushed longer than 2s, IP5306 will identify the action as long push. Long push will close step-up convertor, SOC indicator LED and flashlight LED.
  # If button is pushed shorter than 30ms, IP5306 will ignore the action.
  # If two short push is detected within 1s, IP5306 will open or close flashlight LED
  */
    if (!ButtonD && (millis() - Delay_IP5306_Heartbeat) >= IP5306_HEARTBEAT_TIMEOUT)
    {
      ButtonD=true;//set bool in order to go to next else if
      Delay_IP5306_Heartbeat_Led = IP5306_HEARTBEAT_TIMEOUT + HOLD_TIME; //add holdtime to heartbeat
      PORTA.OUTSET = IP5306_HEARTBEAT_PIN;//write high, NPN is ON here
    }
    else if (ButtonD && (millis() - Delay_IP5306_Heartbeat) >= (Delay_IP5306_Heartbeat_Led))
    {
      ButtonD=false;//set !bool once holdtime ends
      Delay_IP5306_Heartbeat += IP5306_HEARTBEAT_TIMEOUT; //prevents drift
      PORTA.OUTCLR = IP5306_HEARTBEAT_PIN;//write low, NPN is OFF here
    }
}
 
void loop()
{
  IP5306_Heartbeat();//keep in loop for accurate results
}
Github Document
Electronics, ESP8266, Experimental

ULTRASONIC WATER LEVEL SENSOR

Leave a comment

#106 AJ-SR04M ultrasonic distance sensor for water

looks like a STM8S003F3 MCU, unmarked crystal and unmarked TTL IC
Underside has a 2 pin socket and is quite dirty…

Recently I have had an old mildly annoying problem snowball into a new serious problem…

Every few months the clean water supply from uThukela Water (Pty) Ltd has been switched off for multiple reasons… striking, damaged electric motors due to Eskom, sabotage and other issues to name a few very serious reasons.

So two large 2500L water tanks were installed in series as a backup which worked well for small water issues that would last maybe a week or two.

However recently There has been no water from uThukela for over a month, and this is very serious.

This event triggered me to investigate water related problems and solutions specifically for my use case.

Order of importance:

  1. I need readily available clean drinking water
  2. Store this water for longer (get extra tanks)
  3. Keep water safely in the tank (no contaminates)
  4. Add sensors to monitor (water level sensor in this case)

For this article will be focusing on the 4th order of importance since this is a tutorial website mainly about electronics.

Therefore I will start by saying I searched for a suitable water level sensor and came across the JSN-SR04T and clones.

This sensor looks very promising and easy to use with 6 available sensor modes (adding increased diversity).

N.B the copy does not have 6 extra modes which was disappointing considering their price point…

2.2m wire with the sensor at the end.

The copy has 3 modes and is similar to the JSN-SR04T-2.0

Now my goal is to use the JSN-SR04T with an ESP8266 connected via WiFi to send readings to my server every 30s, this unit will be completely powered by solar.

The ESP8266 will also have a LAN dashboard to view the readings in real time connected to WiFi but with a connection to the internet not needed, just in case the internet goes down I can still read the water level values.

unfortunately finding a commonly available original JSN-SR04T Ultrasonic Distance Sensor has been quite difficult in South Africa.

I have only been able to find the AJ-SR04M (functions like the JSN-SR04T-2.0) which is a clone but works just like the original, however I see the price is equivalent and sometimes even more than the original which is quite strange. An of course the extra modes are missing…

The waterproof sensor
The sensor is epoxied and completely sealed looks easy enough to install

Mode 1: R27 = is open.

The sensor returns an analogue signal. The formula to calculate the distance from the data is:

Test distance = (high time * speed of sound (340M / s)) / 2;

Mode 2: R27 = A 47K resistor is soldered.

Every 100ms serial data will be sent in mm.

Serial baud rate: 9600, n, 8,1.

The frame format is: 0XFF + H_DATA + L_DATA + SUM
1.0XFF: for a frame to start the data, used to judge;
2.H_DATA: the upper 8 bits of the distance data;
3.L_DATA: the lower 8 bits of the distance data;
4.SUM: data and, for the effect of its 0XFF + H_DATA + L_DATA = SUM (only low 8)

Mode 3: R27 = A 120K resistor is soldered.

Good for low power applications.

After the module is powered on, the module enters standby mode.

If the module receives 0X55 it will send data over serial.

Serial baud rate: 9600, n, 8,1.

Datasheet for the stm8s003f3

Electronics, Experimental, Programming

ROBOGUARD INTEGRATION

2 Comments

#105 Custom integration sensors with custom receiver

V1.0 breadboard prototype with DIY EEPROM module
V1.0 stripboard soldered prototype with USB and Lipo battery
Testing 2x custom sensors (1x ATTINY85 and 1x ATTINY412) with 433 RF modules

Recently I wanted to integrate the RoboGuard system with some custom sensors on my farming property.

This motivated me to study the hardware and RF protocols used by the RoboGuard

I would like to also account for multiple RoboGuard transmitters scattered over the property each RoboGuard device has 2x pir sensors and sends an alarm signal once both are triggered.

They also send a heartbeat ping every 15min.

They have a range of roughly 400m from transmitter RoboGuard to receiver HQ.

Testing EEPROM data storage.

Now the RoboGuard system uses 433.92Mhz to send signals to the HQ however the HQ can only add up to 8 paired RoboGuards.

Once you reach this limit you will need to purchase more RoboGuard units.

For example if you had 12 RoboGuards, 2 HQ units would be required but if you wanted an HQ that can store more than 8 you would be out of luck.

luckily I had made my own custom RoboGuard receiver and was able to add my own DIY sensors to the RoboGuard device ecosystem

The protocol used is 433.92 ASK and each RoboGuard has 3 signals

  • alarm
  • tamper/learn
  • heartbeat ping
Testing penetration behind galvanised shed (using CY33 module)

Now my receiver needs to store the received device learn UID and this is done via EEPROM on my board

Now my custom device receives all signals just like the RoboGuard HQ.

Next is communicating with the TAK Server.

I could swap the 328P for an ESP8266 which allows WiFi connectivity to the internet

This then allows the device to connect wirelessly.

It still receives RF data from the RoboGuards and just ports these signals over the internet

In future I will make a device with an integrated WiFi connection but In this case all I wanted was more zones and an affordable extra device to keep in my laboratory permanently with the capability to receive 433mhz signals walking around the premises. If need be

Overall my unit contains

A speaker
6 push buttons
2000mAH Lipo battery
built in charger
ability to add clients 12 RoboGuards (more depending on EEPROM size)
433 MHz superheterodyne receiver only
logic to handle all these features

Front of the 433 Transmitter
Back of the 433 Transmitter

More info + datasheets and schematics etc. on my GitHub here