Different between fuse and circuit breaker with symbols

Different Between Fuse and Circuit Breaker

What is the difference between a fuse and a circuit breaker? In electrical circuits, we identify two types of circuit safety, namely Fuse and Circuit Breaker.

These two components are designed as highly current sensitive devices and are placed in the current path.

If the current through this component is below the maximum current limit of this component, then this component functions as a closed switch that can deliver current.

When the current exceeds the maximum limit of the fuse and circuit breaker, both of them will function as open switches, so that the current does not flow into the circuit.

There are three basic differences between Fuse and Circuit Breaker:

1. Fuse if the current through it equals or exceeds the maximum current of fuse, then the fuse will break and must be replaced.
   
   While the circuit breaker if the current through it is the same or exceeds the maximum current from the circuit breaker, the circuit breaker contacts will open so that it is like an open switch position.
   
   However, circuit breakers can be manually reset to change positions such as closed switches or can be used repeatedly without having to be replaced.
2. Fuse is generally used for small currents, while circuit breakers are used for high currents.
3. Most of the physical size of the Fuse is smaller than the Circuit Breaker.

Examples of using Fuse are in audio systems such as amplifiers both on active speakers to car amplifiers, voltage stabilizers, car electrical systems, television, radio and many more.

However, as technology advances, now Fuse has a feature that can disconnect and connect the circuit automatically, known as the PolyFuse fuse.

PolyFuse

PolyFuse is a type of fuse used in electronic circuits that can break off and reconnect the current automatically.

Apart from Polyfuse, the names that are often used are polymeric PTC (positive temperature coefficient), multiFuse, or polySwitch.

The way polyfuse works is if the polyfuse have a maximum current limit of 2A, and the current through it is equal to 2A or more, then the fuse is automatically cut off. And when the current from 2A decreases, then PolyFuse will automatically reconnect.

With this advantage, polyFuse has been widely used in electronic to automotive devices as a very important component for circuit security.

Good use with low to high currents to prevent overcurrent. An example of the most common use of polyFuse is on the Arduino board.

What is Arduino? You can read the explanation in the article "What is Arduino".

If you are someone who likes Arduino or is working on a project with it, when you connect or accidentally connect Power VCC to GND, the Arduino board will turn off automatically and when the connection is disconnected, Arduino will be active again.

If this polyfuse is not used, then when you connect the VCC and GND, the microcontroller and other components may be damaged and burnt.

Thus a brief explanation of Fuse and Circuit Breaker, hopefully the article "Difference between Fuse and Circuit Breaker" can add to your insight in the field of electronics and electricity.

Thank you for visiting the Chip Piko Eu website and hope it is useful.

3 Ways To Reset Arduino With Schematic And Program Code

3 Ways to Arduino Reset

3 ways to reset Arduino with schematic and program code - In some cases arduino project, we will need arduino restart or a reset mode of microcontroller to position the program at 0x00000000, which will impact the reading of the program from the beginning.

There are 3 methods to reset the Arduino and this can also be applied to other AVR variant microcontrollers (reset arduino uno, reset arduino nano and other), "Hard Reset ","Soft Reset", and "Combination" 

Hard Reset means that Arduino will reset when a trigger button is pressed, like we press the reset button microcontroller directly on the physical microcontroller (hardware).

Soft Reset means resetting the microcontroller via Program Codes (arduino reset command)

Combination means We will use the program code to trigger the reset pin so that arduino will read the program from the beginning.

A. Arduino Hard Reset

In the Arduino hardware reset method, we will need a button that is directly connected to the default arduino reset button pin.

Attention! in this hard reset method we don't say arduino boards like arduino uno, nano, micro and so on but we say atmega328, raight?.

In addition to the hard reset method, we give an example using the Arduino board.

For example ATmega328. The reset pin is on the PC6 pin. This microcontroller will reset if pin PC6 is in the LOW position.

So, if the reset button is pressed, PC6 will be connected to ground and a reset will occur.

To keep PC6 going HIGH as long as the button is not pressed, we need to use a Pull-up resistor to hang up at the HIGH voltage.

Common values of resistor pull-up is 10K. for the schematic you can see in the following image.

Arduino Reset Button

B. Arduino Software Reset

In the second program this is a simpler way to reset your Arduino. we using resetFunc to declare reset to address 0. 

This method does not need a schematic.

For program code arduino software reset, please upload the following arduino reset code program to your Arduino, then open Serial Monitor.

void (* resetFunc) (void) = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("Reset Succes");
  delay(5000);
}

void loop() {
  Serial.println("Go to Reset!");
  for (int cnt = 0; cnt < 20; cnt++) {
    Serial.print(".");
    delay(50);
  }

  Serial.println("");
  delay(3000);
  resetFunc();
  
  Serial.println("Reset Failed");
}

C. Arduino Auto Reset (Combination of Software and Hardware)

This method combine hardware and software.  Pin reset arduino will triggered by other digital pin.

Let's say we using pin digital pin 2 in this tutorial. you can use other digital pins, according to your needs. Look at this image.

Arduino Reset Software

connect digital pin 2 to the reset pin. Upload the following program to your Arduino board, then click Serial Monitor. You can see whether your Arduino board has successfully reset or not.

#define pinReset 2

void setup() {
  digitalWrite(pinReset, HIGH);
  Serial.begin(9600);
  Serial.println("Reset Succes");
  pinMode(pinReset, OUTPUT);
  delay(3000);
}

void loop() {
  Serial.println("Go to Reset!");

  for (int cnt = 0; cnt < 20; cnt++) {
    Serial.print(".");
    delay(50);
  }

  Serial.println("");
  delay(3000);
  digitalWrite(pinReset, LOW);

  Serial.println("Reset Failed");
}

How this method work?

We first define the reset pin used, which is digital pin 2. Then for the setup () function, at the beginning of the program we immediately apply digital pin 2 to output High logic (1).

This results in the microcontroller never being "reset", because the microcontroller will reset when given Low (0) logic.

We initialize serial to be able to display data to Serial Monito with the command Serial.begin (9600).

Then in this part of the setup () function we give the command to the Serial Monitor that the Reset was successful. Why? Because when the reset occurs, it will definitely read the setup () function first and will tell us via the serial monitor that the microcontroller has been reset.

In the loop () function, the main command that does the reset is digitalWrite (pinReset, LOW);

When the reset pin receives logic Low (0) from digital pin 2, the microcontroller will reset quickly, and will read back the setup program () then loop ();

However, when the reset does not occur, the serial monitor will provide information. Reset failed, because we have made the command Serial.println ("Reset Failed");

#tags: reset pin arduino, arduino nano reset pin, reset arduino code, software reset arduino, reset button in arduino

STM32 Tutorial - STM32 EEPROM Emulation Arduino

STM32 EEPROM Blue Pill

STM32 EEPROM Emulation - EEPROM is an extension of Electrically Erasable Programmable Read-Only Memory, a memory chip that can store data even if power or resources are disconnected.

Generally every microcontroller already has an Internal EEPROM, this makes the circuit simpler without having to add an external chip.

Unlike Arduino which has an internal non-volatile storage chip, some Blue Pill devices do not have it. For this reason, if we want to save data to Blue Pill, we need a method that can allocate program flash memory as EEPROM.

In the official language of the ST datasheet, this memory allocation is called STM32 EEPROM Emulation. I have never used this on Arduino, so from that I shared a little program in this Article.

A. STM32 EEPROM Emulation

This emulation is done by considering the limitation of Flash memory and some requirements. This approach requires at least two pages of flash memory of the same size allocated for non-volatile data. For a more complete explanation of this EEPROM Emulation, please read the official ST document.

STM32 EEPROM Arduino

Officially, to program this chip using software from the ST itself named STM32CubeIDE. But because I'm not familiar with it, I just use Arduino IDE because there are already many libraries available.

Well, because the Arduino IDE is basically an IDE for programming AVR, someone developed a library board for this chip to be used in the Arduino IDE. This is very useful.

B. Library for STM32 Emulation Arduino

The library board to support this chip to be programmed using the Arduino IDE has several options. However, the library board that I use on this project is STM32 Arduino Core.

This Arduino Core STM32 tries to emulate this non-volatile storage access way as in Arduino. STM32 Arduino Core provides this library which I managed to try.

If we use arduino, to write data just use "EEPROM.write (address, data)" and read with "EEPROM.read (address)".

Whereas what I use to write is "EEPROMwrite (address, data)" and reads with "EEPROMread (address, data_data)".

The STM32 program is to use ST-LINK V2 Clone (China) and for serial monitor communication I connect FTDI on pins A9 and A10.

Below is the program code that I have tested and succeeded. Please upload the following STM32 EEPROM code to your STM32 and open Serial Monitor to see the stored data and the results of reading the data.

C. Schematic For Testing

To program this Blue Pill, I use ST Link V2. For serial communication, using FTDI, please follow the following table

STM32	FTDI
A9	RX
A10	TX

D. Progam Code STM32 EEPROM Emulation

Program:

#include <EEPROM.h>

const int addressEEPROM_min = 0;              // Specify the address restrictions you want to use.
const int addressEEPROM_max = 4095;           // For example, the maximum is 4095, which means we allocate 4KB of memory (4096 bytes) for the Virtual EEPROM.

float latitude =   4.158919;                  // This is an example of data that you want to save to EEPROM.
float longitude = 96.124843;                  // Coordinate data consisting of Latitude and Longitude.

int addressLat = 0;                           // The number of characters in the latitude value is 8, so the address starts from 0 to 8.
int addressLon = 9;                           // The number of characters in the longitude value is 9, so the address starts from 9 to 17.

void setup()
{
  Serial.begin(9600);
  delay(100);

  String lat = String (latitude, 6);         // Data to be saved to EEPROM is a String. This line is used for the conversion of float to String.
  String lon = String (longitude, 6);        // Value 6 shows how many digits behind the comma will be converted.

  // ------------------- Write Data Commands -------------------
  Serial.println(" -----------------------------------------");
  Serial.println("| Writing Latitude to EEPROM  | Saved |");
  EEPROMwrite(addressLat, lat);
  Serial.println("| Writing Longitude to EEPROM | Saved |");
  EEPROMwrite(addressLon, lon);
  Serial.println(" -----------------------------------------");
  Serial.println("\n");
  delay(1000);
  //----------------------------------------------------------

  // ------------------- Read Data Commands -------------------
  Serial.println("Baca data dari EEPROM.....");
  Serial.print("Latitude  : ");
  Serial.println(EEPROMread(addressLat, 8));  // Get data from address 0 with 8 characters.
  Serial.print("Longitude : ");
  Serial.println(EEPROMread(addressLon, 9));  // Get data from address 9 with a total of 9 characters.
  Serial.println("\n");
  delay(1000);
  //----------------------------------------------------------

  Serial.println("Now, please COMMENT *Write Data Commands* to deactivate data write commands to EEPROM.");
  delay(5000);
  Serial.println("Then, please press the reset button or remove STM32 from the computer to see whether the data from the EEPROM is still stored or not.");
} 

void loop()
{

}

String EEPROMread(int StartAddr, int StringLength)
{
  char buf[StringLength + 1];
  eeprom_read_string(StartAddr, buf, StringLength + 1);
  String dataStr = buf;
  return dataStr;
}

void EEPROMwrite(int StartAddr, String DataString)
{
  int val = DataString.length() + 1;
  char StringChar[val];
  char buff[val];

  DataString.toCharArray(StringChar, val);
  strcpy(buff, StringChar);
  eeprom_write_string(StartAddr, buff);
}

boolean eeprom_is_addr_ok(int addr)
{
  return ((addr >= addressEEPROM_min) && (addr <= addressEEPROM_max));
}

boolean eeprom_write_bytes(int startAddr, const byte* array, int numBytes)
{
  int i;

  if (!eeprom_is_addr_ok(startAddr) || !eeprom_is_addr_ok(startAddr + numBytes))
  {
    return false;
  }

  for (i = 0; i < numBytes; i++)
  {
    EEPROM.write(startAddr + i, array[i]);
  }
  return true;
}

boolean eeprom_write_string(int addr, const char* string)
{
  int numBytes;                                                    // number of actual bytes to be written

  numBytes = strlen(string) + 1;                                   // Write string content plus byte terminator string (0x00)
  return eeprom_write_bytes(addr, (const byte*)string, numBytes);
}

boolean eeprom_read_string(int addr, char* buffer, int bufSize)
{
  byte ch;                                                         // read bytes from eeprom
  int bytesRead;                                                   // number of bytes read so far

  if (!eeprom_is_addr_ok(addr))                                    // check the starting address
  {
    return false;
  }

  if (bufSize == 0)                                                // how can we store bytes in an empty buffer?
  {
    return false;
  }

  if (bufSize == 1)                                                
  {
    buffer[0] = 0;
    return true;
  }

  bytesRead = 0;                                                   // initialize a byte counter
  ch = EEPROM.read(addr + bytesRead);                              // read the next byte from eeprom
  buffer[bytesRead] = ch;                                          // save it in the user's buffer
  bytesRead++;

  // if no stop conditions are met, read the next byte from the eeprom
  while ( (ch != 0x00) && (bytesRead < bufSize) && ((addr + bytesRead) <= addressEEPROM_max) )
  {
    ch = EEPROM.read(addr + bytesRead);
    buffer[bytesRead] = ch;                                        // save it in the user's buffer
    bytesRead++;
  }

  if ((ch != 0x00) && (bytesRead >= 1))                            // make sure the user buffer has the string terminator, (0x00) as the last byte
  {
    buffer[bytesRead - 1] = 0;
  }
  return true;
}

Results:

Result from STM32 EEPROM

May be useful.

Download Page

Halaman Download Library, Hardware, Sketsa dan Lainnya

Di sini berisi file yang dapat didownload dari projek yang ada di website ini.

STM32 Arduino

Download File Board STM32 Arduino Core

Download File generic_boot20_pc13.bin

Download File Gambar Pin Mapping STM32F103 Arduino

Download Library RTClock STM32

Komponen Fritzing atau Fritzing Part

Download File BluePill STM32 Fritzing

Download File Bluetooth HC-06 Fritzing

LED MATRIX MAX72xx

Download Library MD_Parola

Download Library MD_MAX72XX

How to Save Float To STM32 EEPROM Arduino

Save Float Value To STM32 EEPROM

STM32 EEPROM is one of the important things that must be learned. STM32 does not have EEPROM by default, so we can use flash memory for EEPROM allocation. 

Save Float to EEPROM STM32

This Article has moved here.

STM32 RTC Internal How to Use It Using Arduino

Blue Pill STM32 RTC, Display to Arduino Serial Monitor

 This article has moved here.

libusb couldn't open USB device /dev/bus/usb/001/006: Permission denied.

Image From Pixabay

How to Fix Arch Linux Permission Denied Arduino IDE STM32 Microcontroller

This is a problem that I got from my project of programming STM32 using Arduino IDE on Arch Linux.

All the equipment I have installed, starting from the STM32 Core library board, Libusb library, ST Link, accepts when I check in the terminal using the "lsusb" command. I am confused as to what causes this.

Permission Denied?

I just remembered when using ubuntu. You can read install Arduino Ubuntu Permission denied on this page.

I tried it on Arch Linux, but there is no dialout in arch linux. Finally I got it on Arch Linux we used "uucp" and it worked.

libusb couldn't open USB device /dev/bus/usb/001/006: Permission denied.

libusb requires write access to USB device nodes.

How to fix Permission Denied Arch Linux?

Are as follows:

There are two steps you must take. Open your Terminal.

1. Modify user accounts.

sudo usermod -a -G uucp <username>

For example your computer username is Asus, then you write:

sudo usermod -a -G uucp asus

2. Give the port permission to read and write using the terminal with two commands:

sudo chmod a + rw/dev/bus/usb/..../....

For example, the detected port name is 001/006, then the command is:

sudo chmod a + rw /dev/bus/usb/001/006

3. Done.