Tag Archives: ARDUINO

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

Arduino, Bluetooth, ESP32, Experimental

ESP32 DEVKIT V1

Leave a comment

#76 ESP32 that is Arduino & MicroPython Compatible

ESP-WROOM-32 32-bit 240 MHz microprocessor

The ESP32 has already integrated an antenna and RF balun, power amplifier, low-noise amplifiers, filters, and power management module. The entire solution takes up the least amount of printed circuit board area. This board is used with 2.4 GHz dual-mode Wi-Fi and Bluetooth chips by TSMC 40nm low power technology, power and RF properties best, which is safe, reliable, and scale-able to a variety of applications.

Arduino, Electronics

DIY ATTINY85 ALARM

Leave a comment

#62 SIMPLE DIY ATTINY85 ALARM

Working prototype PCB .

Upon experiencing a few break-ins on the farm I decided to look for a simple alarm system to monitor certain door. For such a simple project a full on alarm commercial alarm system would be overkill.. So I endeavored on the short and fruitful DIY journey.

My system is based on the simple circuit from Great Scott on YouTube. The brains of the circuit is the Arduino programmable Attiny85 MCU. A reset push button, notification LED, arm/disarm toggle switch, notification buzzer and magnetic read switch are the IN/OUT components used.

The project runs on 12 volts (12 volts for the siren) which is filtered down to 5 volts for the Attiny85. My plan is to use a 12 volts 7 ampere lead acid battery combined with a smart charge board to power the project effectively.

After soldering the components onto the board everything worked fine. However the siren was very soft and the 2N2222A transistor was getting extremely hot. This is because the transistor has to provide a ton of current to the siren in order to get it working at 100% capacity. A quick fix is to remove the 1k resistor between Attiny85 pin 1 and the transistors base.(replace it with normal wire) This allows the siren to be louder but the transistor is still hot. A possible permanent solution will be to just use a 5v relay or look for a transistor with a higher current tolerance.

In the end I decided to go with a 5v relay module since it’s a quick reliable solution but is more expensive than a transistor. In a future upgrade I will most likely use a BC517 darlington as referenced by this article. It will be cheaper than a relay and provides more than enough current for a 15W 1 tone siren (380ma).

DATASHEETS

DIY ATTINY85 ALARM MARKDOWN DOCUMENT
Attiny85_Firmware_v1.3.cpp
Arduino, Electronics

WEMOS D1 MINI

Leave a comment

#57 WEMOS D1 MINI WIFI DEV BOARD

Wemos D1 mini

The Wemos D1 mini is a small WiFi based development board. The board is based off of the ESP-8266EX MCU developed by Espressif . The dimensions are 34.2*25.6 mm which allows this small package to be used effortlessly in large scale applications. Shields are also widely available and add to the ease of use for this board.

Features

  • 11 digital IO, interrupt/pwm/I2C/one-wire supported(except D0)
  • 1 analog input(3.2V max input)
  • a Micro USB connection
  • Compatible with MicroPython, Arduino, nodemcu

Technical specs

  • Operating Voltage 3.3V
  • Digital I/O Pins 11
  • Analog Input Pins 1(3.2V Max)
  • Clock Speed 80/160MHz
  • Flash 4M Bytes
  • Size 34.2*25.6mm
  • Weight 3g

My specific board comes from a company called Farylink. It looks like they make small boards with wifi capabilitys.

According to there website:

Shenzhen Huayulian technology co., LTD is an IOT company that integrates rd, production and sales and is technology-oriented and service-oriented. With a rich background in the IOT industry, it focuses on the research, development and production of IOT communications.

[datasheet]
Size fingers for scale.
Looks like someone rubbed of the programming IC’s serial markings. Or perhaps it was manufactured without any markings? Either way the fact remains its 100% a Chinese copy.

The link to the CH340 driver (which is required to program the Wemos D1 mini over USB) can be found here.

Arduino, Electronics

DIY VOLTAGE DIVIDER

Leave a comment

#56 DIY VOLTAGE DIVIDER

In order to measure the voltage of a DC battery we will need a voltage divider sensor. I built an easy DIY voltage divider which works quite well. All we need are two resistors to measure the voltage in a certain way so our Arduino doesn’t fry.

After working out my requirements for a 12v 7Ah battery I came to the conclusion that I needed a 30k and a 7.5k resistor. This will allow me to measure DC voltage from 0.025v to 25v.

I built 2 sensors
Top of the board

I only had to break the connection on the trace where the screw terminal was soldered to.

After creating a simple Arduino sketch I was able to output the data to the serial monitor. I had to add the correction factor of -0.150 to get an accurate reading after checking with two multimeters.

voltage read sketch
Serial monitor display

I used the Arduino pro mini as the MCU of this project.

voltage_read.inoDownload

Arduino, Electronics

MADUINO ZERO SIM808

Leave a comment

#48 MADUINO ZERO SIM808 GPS TRACKER

The Maduino Zero SIM808 GPS Tracker is an IOT (Internet of things) Solution based on the 32-bit Atmel’s SAMD21 MCU and GPRS/GSM GPS module SIM808. It intergrates a micro Controller ATSAMD21G18, GRRS/GSM module SIM808, which is the upgrade version of SIM900, power management and storage, to make the SIM808 GPS Tracker ready for IOT projects such as smart-home, outdoor monitoring, shared bicycle, etc. The Marduino Zero SIM808 GPS Tracker based on the Arduino, users can program it with Arduino IDE, which is very easy especially for the none-programmers.

This is the V3.4 version, Note that to ensure the module starts up right, a lipo battery is needed to power up the Maduino Zero SIM808 GPS tracker V3.4.

Quick Spec

  • AT Input Voltage: 3.4-4.2V
  • Microcontroller: ATSAMD21G18, 32-Bit ARM Cortex M0+
  • Clock Speed: 48 MHz
  • Micro SIM connector
  • Integrated Power Control System
  • AT command interface with “auto baud” detection Quad-band: 850/900/1800/1900Mz
  • Send and receive GPRS data (TCP/IP, HTTP, etc.)
  • GPS L1 C/A code
  • 22 tracking /66 acquisition channels
  • Tracking: -165 dBm
  • Cold starts: -148 dBm
  • Time-To-First-Fix：Cold starts-32s (typ.), Hot starts-1s (typ.)，Warm starts-5s (typ.)
  • Accuracy: approx. 2.5 meters
  • Interface: I2C/SPI/UART/18*GPIO
  • Arduino compatible
  • Working Temperature: -40 – 85℃
  • Size: 40 x 55mm
  • Net Weight: 23g
Useful links can be found here

Useful links

  1. Microrobotics
  2. Maduino Zero SIM808 GPS tracker
  3. Maduino Zero SIM808 GPS tracker more
Arduino, Electronics

PRO MINI FARM ALARM V1.0

Leave a comment

#42 PRO MINI FARM ALARM V1.0 BREADBOARD

The Pro Mini V1.0 testing for the Farm Alarm

The Pro Mini has proven to be a suitable solution. The board is very small and has more than enough specs to control the GSM/GPRS module while also sending data to a remote server via TCP.

The Pro Mini requires an FTDI programmer since there is no USB port on the board.

FTDI programmers pin out relative to the Pro Mini
Pro Mini ( ATMEL MEGA328P MU1039 )

Arduino, Electronics

FAILED ATTINY85 EXAMPLE

Leave a comment

#41 A FAILED ATTINY85 EXAMPLE (GSM/GPRS)

A quick solder up to test the circuit (had issues with power sharing between GSM module and ATTINY85)

My first attempt to build a small circuit which controls a relay to an alarm speaker was a failure. Contrary to popular belief failure in electronics projects is quite common and I would argue that it is of paramount need if you want to learn anything.

Surprisingly my failure was in using the ATTINY85 instead a Pro Mini, Uno or Mega. Some problems I had were:

  • Not enough RAM to hold all my variables (I had to scrounge 😢)
  • Very limited FLASH memory.
  • GSM module interferes with the ATTINY’s 5v power source when connected using the same source with no filtering.

In a later project I created a reliably working solution with the Pro Mini as the brains.

My goal was to create a small circuit which uses the ATTINY85 as the brains. It uses the A6-GSM-Module to receive SMS’s, phone calls and sends TCP data. Finally it has a 5v relay which will switch on/off an alarm speaker. The theory is that when I’m on the farm in the fields and not near the house, I have the option of remotely starting an audio alarm at will. This should be a deterrent to potential criminals.

I made an easier to debug testing circuit with exposed copper traces (Same issues)

After making an easier to debug circuit I tried to get the ATTINY85 to work happily with the GSM module. This was going to be a bit complicated and I suspect I would have to isolate power between the ATTINY85 and the GSM module. This would require more components and the board is already looking cramped. A much easier solution is to use the Pro Mini instead of the ATTINY85.

The Pro Mini is most certainly a beauty.

Arduino, Electronics

DIGISPARK REV3 ATTINY85

Leave a comment

#39 DIGISPARK REV3 ATTINY85 DEV BOARD

The Digispark rev3 USB board is an ATtiny85 based microcontroller development board. It comes with a USB interface. Coding is similar to Arduino, and it makes use of the familiar Arduino IDE for development.

BOARD SPECS

  • Support Arduino IDE 1.0+ (OSX/Win/Linux)
  • Can be powered by USB or 5v or 7-15v (automatic matching) extra power supply
  • There is a 500ma 5V regulator on the motherboard.
  • USB embedding (serial debugging)
  • 6 I/O Pins (2 for USB support)
  • 8k Flash Memory (about 6k after bootloader)
  • I2C and SPI (vis USI)
  • PWM on 3 pins (more possible with Software PWM)
  • ADC on 4 pins
  • Power LED and Test/Status LED (in Pin0)

The smallest USB Arduino

PDF Manual

Arduino, Electronics

UNO ATTINY85 PROGRAMMER

Leave a comment

#38 DIY ARDUINO UNO ATTINY85 PROGRAMMER

Sometimes an Arduino pro mini is just not small enough for an electronics project. Enter the Arduino ATTINY85, this MCU comes in an extremely small package. It has only 8 pins and works with 5v.

Below are the specs of this microcontroller:

  • AVR MCU, 8K FLASH, 512B RAM, SPI
  • Controller Family/Series:AVR Tiny
  • Core Size:8bit
  • No. of I/O’s:6
  • Program Memory Size:8KB
  • EEPROM Memory Size:512Byte
  • RAM Memory Size:512Byte
  • CPU Speed: 8/16 MHz internal clock, up to 20MHz external clock
  • No. of Timers:2
  • Peripherals:ADC, Comparator
  • No. of PWM Channels:4
  • Digital IC Case Style:DIP
  • Supply Voltage Range:2.7V to 5.5V
  • Operating Temperature Range:-40°C to +85°C
  • No. of Pins:8

This is great and all but its a hassle to program the board unless you buy a dedicated programmer (expensive in SA) or if you’re happy to use a messy breadboard every time you want to program. So I decided to make a very crude but effective programming shield for my Arduino UNO.