Saturday, December 5, 2020

Address of Electronic Components Datasheet Download

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

Address of Electronic Components Datasheet Download


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.

Symbol fuse polyfuse circuit breaker

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.

atmega328 reset button schematic
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
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

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 Tutorial, STM32 EEPROM Emulation Arduino, How to Access Read Write STM32 EEPROM Blue Pill Using Arduino IDE
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

STM32FTDI
 A9RX
 A10TX

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:
STM32 Tutorial, STM32 EEPROM Emulation Arduino
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




Komponen Fritzing atau Fritzing Part

Saturday, June 27, 2020

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. 
STM32 EEPROM Emulation Arduino Library
Save Float to EEPROM STM32


This Article has moved here.

Wednesday, June 24, 2020

STM32 RTC Internal How to Use It Using Arduino

Cara Akses STM32 Blue Pill Internal RTC

Blue Pill STM32 RTC, Display to Arduino Serial Monitor


 This article has moved here.