Address of Electronic Components Datasheet Download - There are many websites that provide a place to download datasheets, but it doesn't hurt that you try the link I shared below
CHIP PIKO EU
Learn Arduino, AVR, and STM32, Sensors with free schematics and code.
Saturday, December 5, 2020
Monday, October 12, 2020
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:
- 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. - Fuse is generally used for small currents, while circuit breakers are used for high currents.
- 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
Monday, June 29, 2020
STM32 Tutorial - STM32 EEPROM Emulation Arduino
STM32 EEPROM Blue Pill
A. STM32 EEPROM Emulation
![]() |
STM32 EEPROM Arduino |
B. Library for STM32 Emulation Arduino
C. Schematic For Testing
STM32 | FTDI |
A9 | RX |
A10 | TX |
D. Progam Code STM32 EEPROM Emulation
#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; }
Result from STM32 EEPROM |
Download Page
Halaman Download Library, Hardware, Sketsa dan Lainnya
STM32 Arduino
Komponen Fritzing atau Fritzing Part
Saturday, June 27, 2020
How to Save Float To STM32 EEPROM Arduino
Save Float Value To STM32 EEPROM
![]() |
Save Float to EEPROM STM32 |