But wouldn’t it be much more practical to do away with physical keys altogether? Nowadays, there are numerous ways to open a lock: Fingerprint scanners, facial recognition, NFC, numeric codes, dials – or, of course, brute force methods such as explosives and brute force. But if you are looking for an inexpensive, non-violent and simple solution, the keypad lock comes into focus.

Surprisingly, there are hardly any really good DIY solutions for hobbyists on the Internet. So I tackle it myself – my first keypad lock, which I simply call “Version 1”.

This might also be interesting for you: Do it yourself powerbank with voltage regulator and voltmeter

Construction of the housing

The initial focus is on the housing and the keypad holder. The first question that always arises is: How big should it be? The answer depends on several factors:

• Which components are required? Each component takes up space and influences the design.
• How much space do the components take up? A compact design is advantageous, but must not restrict functionality.
• What are the haptics and operability like? The keypad should be comfortable to use without being too cramped or impractical.

These considerations form the basis for the housing design – because good planning saves time and nerves later on.

What will be inside the housing?

The central component is, of course, the membrane keypad (1.0.1). It has the following dimensions:

• Width: 69 mm
• Length: 76 mm
• Thickness: 0.6 mm (or 0.95 mm above the keys)

The keypad also has a ribbon cable with DuPont sockets for connection to a microcontroller. The cable itself is 85 mm long and 17.78 mm wide.

The control center of the lock is the Nano (1.0.2). To accommodate it neatly in the housing and to make the cable connections as convenient as possible, I opted for a Nano expansion board with screw terminals (1.0.4).

A hollow socket (5.5 x 2.1 mm, 1.0.4) is used for the emergency power supply so that the lock continues to function even in the event of a power failure.

The pin and socket connectors (1.1.1) serve as the central power distribution and are later soldered to the breadboard (1.1.2). Jumper cables (1.1.3) are used to ensure that all components are reliably connected. Depending on the position of the components, different lengths are required – in this case 10 cm and 20 cm.

For the status display of the keypad lock, I use Neo Pixel addressable LEDs of type WS2812b (1.2.1). These can be used to control different colors and effects to visually display the current status of the lock.

I will go into the positioning of the screws in more detail later.

Now that the components have been determined, I can think about the size of the housing. This is not only determined by the installed elements, but above all by the usability and feel.

We encounter keypads every day – on ATMs, telephones, door lock systems and, of course, smartphones. The decision for the depth of the housing is based on a positive memory of my penultimate workplace: the keypad lock at the entrance was raised and easily accessible from both sides. You could operate it comfortably with your right or left thumb, and the rounded corners provided a pleasant feel when you put your hand on it.

Keypad lock Housing design

This results in a depth of 45 mm (2.0.3). For better ergonomics, the corners have a radius of 15 mm (R15) and the surrounding upper edges have a radius of 10 mm (R10). I am aware that these roundings slightly reduce the interior space, but the comfort and appearance outweigh this disadvantage.

The width and height of the housing are determined by the components to be installed. The space for the cabling must also be taken into account. Particularly important: When installed, the Nano should still be accessible with a standard USB mini cable, for example to be able to install new programs.

Mounting and fastening

• Four M3 threads (2.0.1) on the inside allow the support plate to be screwed on.
• In addition, there are four mounting points with Ø4.2 mm holes for attaching the housing to a door, cover or wall.
• The housing has a window (2.0.2) measuring 60 × 67 mm, which is intended for the keypad. This is later filled with the carrier plate.
• Retaining columns with M2 threads and the opening for the hollow socket (1.0.4) are marked with orange ellipses (2.0.1, 2.0.3).
• The next picture (2.0.4) shows the external dimensions: 110 mm wide and 117 mm high.
• In addition, an aperture or slot 50 mm long is required for the LED cover (2.0.5).

For the wall thickness of the housing, I have provided 2 mm throughout – stable enough for the intended purpose.

With the housing construction completed, we can now continue with the other components.

The support plate – the central mounting element

The next important component is the carrier plate. The name is self-explanatory: With the exception of the hollow bushing, all components are attached here. This system offers several advantages over direct mounting in the housing:

Easy mounting outside the housing – More space and better handling when wiring.
Modularity – different carrier plates with different components are possible.
Simple enclosure design – The enclosure design remains simpler and more flexible.
Easy replacement – Components can be replaced or extended more easily.

But there is another decisive advantage for the keypad lock in particular:

The keypad is glued directly into a designated recess in the carrier plate (2.1.1). The carrier plate and keypad are then inserted into the housing from behind and fixed in place with M3 screws. The frame of the window in the housing completely covers the edge and the cables.

Safety aspect: The window is dimensioned in such a way that the edge and the cables remain concealed, but the buttons are fully visible and operable. This means that the keypad cannot be removed without destroying it – an important protective mechanism against tampering.

Fastening the components to the carrier plate

There are various mounting options for the electronics on the back (2.1.2) of the carrier plate:

M3 thread for the nano adapter (2.1.3) – As nano adapters on the Internet often have different hole spacings, there is an additional fastening thread on the right-hand side (2.1.2) for flexible adjustment. If the holes still do not fit exactly, they can be carefully widened – but without damaging the adapter’s conductor tracks.

M2 thread for the Nano R3 ATMEGA168P (2.1.4) – An alternative, cost-effective solution instead of a Nano R3 with adapter.

M2 thread for the breadboard (20×80 mm, 1.1.2, 2.1.5) – This is used for power distribution and connects all power supply lines neatly at a central point.

The LED cover and its attachment

The LED cover (2.2.1) has been designed so that it is clicked into the slot (2.0.5) of the housing from the rear. The radius on the outside of the LED cover corresponds to the housing radius, creating a smooth transition and allowing the cover to blend in seamlessly.

I don’t need to redesign the mounting bridge (front 2.2.2, back 2.2.3) as I have already used it successfully in other projects.

Mounting the LEDs

Now it remains to mount the three WS2812b LEDs (1.2.1). I will explain why exactly three LEDs are needed later in the programming section of this article.

The development of the LED holder (SMD50, 2.2.4) was more complex than expected. Of course, you could simply glue, clamp or hot glue the LED strips – but that seemed too unprofessional to me.

I therefore invested a lot of time and effort in designing a perfect holder. The result can be seen in picture 2.2.5.

Further information:

For details on the construction, there is a separate article on NerdCorner.

3D printing of the components

Once the design has been completed, the parts must now be printed.

Material selection for the individual components:

• Housing (3.0.1): Printed with ABS filament, consisting of front and back.
• Carrier plate (3.0.2): made from PLA filament.
• LED cover (3.0.3): produced upright in the printer, printed with PLA+ in the color “natural”.
• LED terminals (3.0.4): also made of PLA+, manufactured in the same process as the LED cover.
• Bridge for the hollow socket: printed from PLA filament, analogous to the carrier plate.

With these materials, the mechanical and thermal properties of the components are optimally matched to their respective applications.

Post-processing of the components

After printing, both the printed parts and some purchased parts need to be processed.

1⃣ Cleaning the 3D printed parts

• Removal of support material and protruding print residues.

2⃣ Cutting the thread
Housing (4.0.1):

• Four M3 threads (Attention: blind holes! Proceed carefully when cutting so as not to push the base outwards).
• Two M2 threads (4.0.2).
• Support plate (4.0.3):
  • The M2 threads marked in blue must be cut in any case.
  • When using a nano adapter with screw terminals (2.1.4), the M2 threads marked in red must also be cut.

3⃣ Shortening the perforated grid plate

• The perforated grid plate (4.0.4) must be shortened to 8 to a maximum of 10 perforated grids.
  Important: The mounting holes should be retained (see 4.0.5).

4⃣ Shortening the pin header

• Shorten the pin header to eight pins using a side cutter (4.0.6).

Soldering the components

Now it’s time to solder the parts. First we concentrate on the power supply board:

1⃣ Soldering the power supply board

• Perforated grid plate (4.0.5): Soldering the base strip (1.1.1) and the pin strip (4.0.6).
• Pin strip (4.1.2): A two-row pin and skirting board is soldered on. We connect the two rows on the back with solder.
• The rows differ in male and female as well as in the colors: red for plus and black for minus. This makes it easier to connect the power supply.

2⃣ Soldering the WS2812B LEDs

• Soldering the connections of the WS2812B LED strip (4.1.3).

3⃣ Soldering the hollow socket

• Finally, the hollow socket (1.0.4) is soldered (4.1.4).
• Detailed instructions on soldering the hollow socket can be found in a separate article. It is important to know the exact procedure in order to avoid mistakes.

Assembling the keypad lock

1⃣ Installing the LED cover

• First click the LED cover (2.2.1) into the housing.
• Glue the LED cover in the intended places as shown in pictures 5.0.1 and 5.0.2.

2⃣ Plug in the Nano R3

• Insert the Nano R3 (1.0.2) into the Nano adapter (5.0.3) of your choice.

3⃣ Installing the Nano adapter

• Screw the Nano adapter (1.0.3) with the inserted Nano R3 (1.0.2) to the back of the carrier plate (4.0.3).
• Use the M3 threads on the carrier plate and the screws (1.2.2), as shown in pictures 5.0.4 and 5.0.5.

4⃣ Attaching the power supply

• Attach the power supply (4.1.2) to the back of the carrier plate (4.0.3) using the screws (1.2.4).
• See figure 5.0.6.

Mounting the keypad on the support plate

1⃣ Selecting the screw length

• Make sure to select the correct screw length as shown in Figure 5.1.1.
• Screws must not be too long, otherwise they will protrude from the adhesive surface when the keypad is attached and the keypad cannot be glued on cleanly.

2⃣ Preparing the keypad

• Remove the protective film from the keypad (1.0.1).
• To remove the film, use a carpet knife to carefully get between the adhesive layer and the protective film at one corner (see 5.1.2).
• Once you have reached the corner, peel off the entire protective film (see 5.1.3).

3⃣ Stick on the keypad

• Insert the keypad (1.0.1) into the recess on the front of the carrier plate (2.1.1) and press it firmly into place.
• The keypad must be completely recessed and must not protrude over the edge (see 5.1.4).
• Make sure that the cables are also in the recess (see 5.1.5).

Wiring the keypad to the Arduino Nano R3

1⃣ Using jumper cables

• Jumper cables (10 cm long, male-male) are used to connect the keypad to the Arduino Nano R3 (see 5.2.1).

2⃣ Connecting the cables

• Make sure that you do not twist the cables, but only bend them.
• The left cable is connected to D2 of the Arduino and the right cable to D8.
• There are seven cables in total, which occupy the connections D2 to D8 (see 5.2.3).

3⃣ Use pin headers

• As the pitch of the Arduino adapter and the keypad do not match, you can use pin strips to make the connection.

4⃣ Fastening the LED terminals

• The clips (3.0.4) for the WS2812B LEDs are clicked onto the LEDs.
• It is best to do this on a flat surface (see 5.2.4).

5⃣ Attaching the LED strip

• The WS2812B strip is now pushed onto the center of the top of the carrier plate (see 5.2.5 Front and 5.2.6 Rear).

Assembling the carrier plate and housing

1⃣ Screwing the support plate to the housing (5.3.1)

• Make sure that you use M3 screws that are not too long. Otherwise, they could push a bump into the front of the housing when tightened.
• The alignment of the carrier plate in the housing is important: the LED strip should be on the same side as the LED cover.
• After screwing, the keypad should be lightly pressed against the inner frame of the housing (see 5.3.2 and 5.3.3).

2⃣ Pre-assembly of the hollow socket for the emergency power supply

• For the emergency power supply, you must pre-assemble the hollow socket and screw it to the housing.
• The hollow socket with bridge and nut is shown in Figure 5.3.4.
• Insert the hollow bush into the round recess of the bridge.
• Lock the hollow bushing with the nut on the other side of the bridge.

3⃣ Fastening the hollow bush in the housing

• The hollow bush with the bridge is then screwed to the retaining pillars provided in the housing using M2 screws (see 5.3.5 and 5.3.6).

Connecting the cables and completing the power supply

1⃣ Connecting the control cable for the servo motor

• The control cable for the servo motor is connected to pin D9 of the Nano R3 (5.4.1).

2⃣ Connecting the power supply for the Nano R3

• The power supply for the Nano R3 is connected to the GND pin and the VIN pin of the Nano R3 (5.4.2).

3⃣ Connecting the control cable for the WS2812B

• The control cable for the WS2812B LED strip is connected to pin D10 of the Nano R3 (5.4.3).

4⃣ Wiring of the power distributor

• All remaining cables must be connected to the power distributor:
  • Servo motor connection
  • Arduino Nano R3
  • WS2812B LED strip
  • Hollow socket All connections are made with plus and minus (see 5.4.4 and 5.4.5).

5⃣ Using different colors and connection types for the wiring

• It helps to use different cable colors:
  • Red for plus
  • Black for minus
• The power distributor has different connection types:
  • Male for plus
  • Female for minus

6⃣ Note on the hollow socket

• There is a separate article on wiring and connecting the hollow socket, which you should definitely read

7⃣ Attaching the connector housings for the servo motor and power supply

• A three-pin plug is required for the servo motor connection.
• A two-pin plug is required for the external power supply.

Further details on the construction process and the download links for connector housings can be found here.

Figure 5.5.1 shows the entire cabling again.

Arduino code

After the intensive work with the hardware and the 3D printer, we now turn our attention to the strategy and programming of the keypad lock. Why is a strategy important for a keypad lock? A well thought-out sequence of actions – i.e. the order in which the keypad lock is operated, which events result from certain actions and which goal is being pursued – forms the basis for functional control. This guideline is therefore also crucial for programming the keypad lock: it determines what should happen when and which hardware is used. The aim is to create a logical and comprehensible sequence of events, which in this case can also be understood visually.

Example 1:
The keypad lock should display how many digits have already been entered. (See Figures 7.0.1 to 7.0.4)

Example 2:
The keypad lock should indicate whether the password entered is correct after pressing a specific key. (See figure 7.0.5)

Example 3:
The keypad lock should indicate if something has been entered incorrectly, such as an incorrect password or too many keystrokes. (See figure 7.0.8)

Example 4:
The keypad lock should display the current status. (See Figures 7.0.5 to 7.0.7)

Now let’s move on to programming the keypad lock, which differs from conventional programs on the Internet in a few respects. To begin with, the three necessary libraries are included: <Keypad.h> for the keypad, <Adafruit_NeoPixel.h> for the WS2812B LEDs and <Servo.h> for the servo motor (Figure 6.0.1). In the following section, the pin assignment for the LEDs is defined, whereby pin D10 is used and the number of LEDs and the color scheme are determined. The brightness of the LEDs is also defined – this value can be adjusted depending on the location, with higher values providing more brightness (values from 0 to 255). (See figure 6.0.2) The third section is dedicated to the description of the keypad used, including the number of rows and columns and the assignment of the buttons. (See figure 6.0.3).

In the fourth section, the servomotor is configured by defining the degree range it can cover and the speed at which it should move (see Figure 6.1.1). This is followed by the section for entering the password. Here you have the option of changing the default password 1516 to set a new four-digit password. The program will only work correctly if a four-digit code is entered. In this section, the control pin for the servo motor is also set to D9 (see Figure 6.1.2). The following section is dedicated to defining the colors for the various events.

The last two sections explain the behavior of the keypad lock during certain actions. This description is of course only a rough overview of the program. In a future article for keypad lock version 2, we will explain the program in more detail and more comprehensively.

//==========================================Librarys==============================================================
#include <Keypad.h>
#include <Adafruit_NeoPixel.h>
#include <Servo.h>
//========================================Neo-Pixel==============================================================
#define LED_PIN 10
#define LED_COUNT 3
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
int led_strength = 75; //controlls Brighttness (0 - 255)
//========================================Keypad=================================================================
const byte rows = 4;
const byte cols = 3;
char keys[rows][cols] = {
 {'1', '2', '3'},
 {'4', '5', '6'},
 {'7', '8', '9'},
 {'*', '0', '#'}
};
byte rowPins[rows] = {8, 7, 6, 5};
byte colPins[cols] = {4, 3, 2};
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, rows, cols );
//=========================================Servo============================================================
Servo lock;
int pos = 0;
int servo_angle = 180;
int servo_speed = 15;
//======================================Password===============================================================
String input;
const String password = "1516"; //Set Password
int n = 1;

 

void setup() {
 input.reserve(password.length() +2);
 strip.begin();
 strip.show();
 lock.attach(9); //motor pin
}

void loop() {
//-------------------colours------------------------------------------------------------------- 
 uint32_t blue = strip.Color(0, 0, led_strength);
 uint32_t green = strip.Color(0, led_strength, 0);
 uint32_t red = strip.Color(led_strength, 0, 0);
 uint32_t orange = strip.Color(led_strength, led_strength/2, 0);

 char key = keypad.getKey();

if (key != NO_KEY) {
//-------------------------End conditions------------------------------------------------------
 if (key == '#') {
 if (input == password) {
 //unlock
 strip.clear();
 strip.fill(green, 0, LED_COUNT);
 strip.show();
 for (pos = 0; pos <= servo_angle; pos += 1) {
 lock.write(pos);
 delay(servo_speed );
 }
 while (1 == 1)
 { char key = keypad.getKey();
 strip.clear();
 strip.fill(orange, 0, LED_COUNT);
 strip.show();
 if (key == '*')
 {
 strip.clear();
 strip.fill(green, 0, LED_COUNT);
 strip.show();
 break;
 }
 }

 for (pos = servo_angle; pos >= 0; pos -= 1) {
 lock.write(pos);
 delay(servo_speed );
 }
 n = 1;
 input = "";
 delay (1000);
 strip.clear();
 strip.show();
 } else {
 //wrong password
 strip.clear();
 strip.fill(red, 0, LED_COUNT);
 strip.show();
 n = 1;
 input = "";
 delay (1000);
 strip.clear();
 strip.show();
 }
 }
 else if (n == password.length() + 1) {
 //Input too long
 strip.clear();
 strip.fill(red, 0, LED_COUNT);
 strip.show();
 n = 1;
 input = "";
 delay (1000);
 strip.clear();
 strip.show();
 }
//----------------------------------Buttons------------------------------------------
 else {
 input += key;
 if (n == password.length() ) {
 strip.clear();
 strip.fill(blue, 0, LED_COUNT); 
 strip.show();
 n++;
 }
 else {

 strip.clear();
 strip.setPixelColor(n-1, blue);
 strip.show();
 n++;
 }
 }
 }

}

Function

Operating the keypad lock is very intuitive. As soon as the first button is pressed, the right-hand LED lights up blue (7.0.1). When the second button is pressed, the middle LED turns blue (7.0.2). After the third button is pressed, the left-hand LED lights up blue (7.0.3). Finally, with the fourth button, all three LEDs light up blue (7.0.4). When these three LEDs light up blue, the user knows that the # button must be pressed.

If the # button is pressed, the password is checked. If the password is correct, all three LEDs light up green at the same time and the servomotor is activated (7.0.5). The green light remains on as long as the servomotor has not yet reached its end position (open). As soon as the servomotor reaches the end position (open), the LEDs change from green to orange (7.0.6). The orange color remains until the user presses the * button.

After pressing the * button, the LEDs change back to green (7.0.7) and remain in this color until the servomotor has reached the end position (closed). If this is the case, the LEDs go out and the keypad lock is ready for new entries.

However, if the password is incorrect after pressing the # button in step 7.0.4, all three LEDs light up red (7.0.8). The red light is also displayed if more than four buttons, apart from the # button, are pressed.

Door mounting

Of course, this variant is not intended for use on an ordinary door, where you simply walk through and the door closes by itself. The reason for this is that the lock remains open until the * button is pressed. But how can you press the * button when you are on the other side of the keypad lock, behind the wall? A delay in the program could help, but who knows how long it takes to pass through the door and close it behind you? A much more sensible solution would be to implement an additional switch that is placed on the other side of the door. When pressed, this switch would lead directly to point 7.0.6 and open the lock so that the door can be opened from the inside without having to enter a password.

But that’s for the future. Now we come to mounting the keypad lock on a door. I have provided four holes on the back of the housing for this purpose. These holes have a recess on the inside for conventional hexagon nuts M4 DIN 934. The corresponding holes can be seen in Figure 8.0.1 (rear view) and Figure 8.0.2 (front view), whereby the housing is shown slightly transparent for better visualization. Installing the nuts is very simple: After ensuring that all support material has been removed, the nut is pressed into the recess provided from behind. Press-in nuts should not be used as they are unnecessarily expensive.

I have developed a drilling template for fixing to the wall or door (Fig. 8.0.3). This template contains a hole with a diameter of 4 mm at each of the four corners. The distance between the holes corresponds to the distance between the holes on the housing. The template can be easily fixed to the surface of the door, for example with adhesive tape (Fig. 8.0.4). This saves you the tedious task of marking out the drill holes and avoids errors.

Figure 8.1.1 shows the drilled mounting holes from the front, marked by magenta-colored circles. Thanks to the drilling template, these holes are the correct distance apart. If the position slips slightly during drilling or is not exactly correct, this is not a problem. In this case, you can simply drill the mounting holes slightly larger to align the keypad lock precisely when screwing it on. In addition, two holes can be seen in yellow circles in this picture, which are unfortunately slightly broken out at the edge. These holes are intended for the servo cable and the power supply. Once the holes had been drilled, I fitted the keypad lock and fed the cables through the holes provided on the back of the door (Fig. 8.1.2).

The entire assembly of the keypad lock is shown on the front side of the door in Image 8.2.1. If you are not satisfied with this mounting solution, don’t worry: As a final step, I have designed a back cover that allows the keypad lock to be mounted on a wall or frame (Image 8.2.2). To do this, simply place the housing of the keypad lock onto the back cover and secure it from behind using M4 countersunk screws (marked by magenta circles in Image 8.2.2). After that, the entire construction is mounted on the wall, for which two tabs with two holes each are available (yellow circles in Image 8.2.2).

It is also important to remember to add one or more openings in the housing for the servo and power supply cables. Additionally, the security risk should be considered, as an unauthorized person could potentially unscrew the keypad lock using the accessible screws.

Locking Mechanism

If you’re still missing a real locking mechanism that goes beyond just a servo connection, you can look forward to the “Locking Unit,” which is already in development and will be featured in future versions of the keypad lock.

The development of the keypad lock was an exciting yet challenging task. Some key features of VERSION 1 of the keypad lock are particularly noteworthy:

• Compatibility with various Arduino Nano models and adapters – Ensures flexibility in hardware selection.
• Visual feedback – Users are directly informed about number input and the status of the keypad lock.
• Emergency power supply via barrel jack – Guarantees reliable operation in case of power failures.
• Stable software – Developed to ensure reliable functionality.
• Optimized ergonomics for both left- and right-handed users – Designed for comfortable use by all users.

Files for Download

• Keypad lock housing

The post DIY keypad lock – 3D printing and code appeared first on Nerd Corner.

I often see blog articles where the HTML code is embedded in the Arduino file. You can do this for a mini demonstration, but it’s complete rubbish for everyday use. It is far too confusing and as soon as the project grows it is no longer usable.

The proper alternative is to set up a folder called “data” and store the web pages in this folder as html files. In addition, the styling is saved as a CSS file and functions can even be executed via a JavaScript file. So everything is 1:1 like on a normal web server!

This might also be interesting for you: WeMos D1 R2 first steps and Wifi integration

List of components

• Arduino IDE (development environment)
• WeMos D1 R2

The setup of the file system (officially SPIFFS) needs to be done once and is very easy:

(First you should have completed the basic setup from the first part!)

1. Download a copy of the file “ESP8266FS-0.2.0.zip” from GitHub and unzip it
2. Place the file esp8266fs.jar in the Arduino tool directory. The path looks like this: [home_dir]\Arduino\tools\ESP8266FS\tool\esp8266fs.jar (See picture) I had to create the path part tools\ESP8266FS\tool\ in the Arduino folder myself.
3. Restart the Arduino IDE.

That’s it already! You can now see the new item “ESP8266 Sketch Data Upload” in the Arduino IDE under Tools.

How can I use the new file system now?

1. Create an additional folder with the name “data” in your current WeMos project folder. As shown in the following image

2. Place the files you want to upload in the ‘data’ directory
3. In the Arduino IDE, select the WeMos in the ‘Tools’ menu and select a size for ‘Flash Size’
4. Close the dialogue box for the serial monitor!
5. Select the ‘ESP8266 Sketch Data Upload’ option from the ‘Tools’ menu.

As soon as the upload is complete, the message window of the Arduino IDE shows 100% upload.

WeMos example programme for switching the OnBoard LED on and off

Similar to the first part, the web server will control the OnBoard LED. The code from the first part also serves as the basis. The revised code looks like this:

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

ESP8266WebServer server(80);

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");


  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

  if (MDNS.begin("nerd-corner")) {
    Serial.println("DNS started, available with: ");
    Serial.println("http://nerd-corner.local/");
  }

  server.serveStatic("/", SPIFFS, "/", "max-age=86400");
  SPIFFS.begin();

  server.onNotFound([](){ 
    server.send(404, "text/plain", "Landing page not found! Don't forget to name your landing page 'index.html'!");  
  });
 
  server.on("/led", HTTP_POST, []() {    
     
    const String ledState = server.arg("ledstate");
    if(ledState=="on"){
      switchLedOn();
    }
    else if(ledState=="off"){
      switchLedOff();
    }
    server.send(200, "text/json", "{\"result\":\"ok\"}");
  });

  server.begin();
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  server.handleClient();
  MDNS.update();

}

void switchLedOff(){ 
  digitalWrite(LED_BUILTIN, HIGH);   // turn the D1 LED off 
}

void switchLedOn(){ 
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED on 
}

I would like to point out a few special features. For example, we have added the following:

server.serveStatic("/", SPIFFS, "/", "max-age=86400"); 
SPIFFS.begin();

Without these two lines, access to the files in the “data” folder would not be possible. Please note that the name “index.html” is set as the default for the landing page. However, you can change this if you really want to.

server.on("/led", HTTP_POST, []() {    
     
    const String ledState = server.arg("ledstate");
    if(ledState=="on"){
      switchLedOn();
    }
    else if(ledState=="off"){
      switchLedOff();
      }
      server.send(200, "text/json", "{\"result\":\"ok\"}");
  });

The “/led” endpoint receives the commands from the web server. If the command is “on”, the LED is switched on and if “off”, the LED is switched off.

Wemos website for switching the WeMos OnBoard LED on and off

The example website has a very simple structure. It primarily consists of 2 buttons for switching the LED on and off.

The folder structure of the website is very clearly organised. There is a main page with the name “index.html”. This name is common worldwide for the main pages and is also automatically recognised by WeMos. There is also a “CSS” folder for styling and a “JS” folder for functions.

We link the styles in the header area of the website. There is a standard bootstrap, which automatically makes everything a bit nicer, and a custom styles file with my own customisations. The functions of the website are also linked in the header area. I use the jQuery standard to send requests from the website to the WeMos. My own custom functions are in the “index.js”.

Please note that the jQuery file must be included BEFORE your own file, otherwise no jQuery commands can be used in your own code! The custom functions are then used by the buttons. The HTML code of the page looks as follows:

<!DOCTYPE html>
<html lang="en"></html>
<html>
  <head>
    <meta charset="utf-8" />
    <meta
      name="viewport"
      content="width=device-width, initial-scale=1, shrink-to-fit=no"
    />
    <script type="text/javascript" src="js/jquery-3.5.1.min.js"></script>
    <script type="text/javascript" src="./js/index.js"></script>
    <link rel="stylesheet" href="css/bootstrap.min.css" />
    <link rel="stylesheet" href="css/custom-style.css" />
    <title>D1 Webserver</title>
  </head>
  <body>
    <h1>D1 Webserver with filesystem</h1>
    <p>
      This is an example for a WeMos Webserver with a filesystem. You can easily
      create webpages with html, css and js!
    </p>

    <h3>Example to turn on and off the built in LED</h3>
    <button class="button-style" onclick="changeLEDState('on')">Turn on</button>
    <button class="button-style" onclick="changeLEDState('off')">
      Turn off
    </button>

    <h3>Example to demo a JS function</h3>
    <button class="button-style" onclick="showAlert()">Show alert</button>
  </body>
</html>

Special attention is paid to the JavaScript function “changeLEDState(value)”

function changeLEDState(value) {
  $.post("/led", { ledstate: value });
}

Because jQuery is used for communication with the WeMos, a simple dollar sign with the corresponding request command is sufficient. A value is also sent with this POST request, which is either “on” or “off” to switch the LED on and off.

The web page can be downloaded as a zip file below.

Files to download

• Wemos example webserver to control OnBoard LED

The post WeMos D1 R2 – Host entire website with html, css & js appeared first on Nerd Corner.

This might also be interesting for you: How to control a fan with an Arduino!

List of components

• Arduino IDE (development environment)
• WeMos D1 R2

Differences between the WeMos D1 R2 and the Arduino UNO R3

An Arduino UNO R3 looks very similar to the WeMos D1. The main difference is that the D1 has an ESP2866 WIFI module integrated on its board. This gives you the possibility to connect the D1 to the internet. Roughly speaking, the D1 is a wifi-enabled Arduino!

However, you should note that the clock frequencies of the two processors are different. The Arduino has an 8 bit Atmel processor and the D1 a Wi-Fi capable ESP8266 processor with 32 bit clock frequency. The pins of the D1 are arranged similarly to an Arduino UNO, but differ in the operating voltage. On an Arduino UNO the voltage of the pins is 5V and on the D1 it is 3.3V. However, there is also a 5V output on the D1. Because of the voltage differences on the pins you should not blindly plug an Arduino Shield on a D1. It is recommended to check the compatibility first!

In addition, it should be noted that the D1, unlike the Arduino, has only one analog pin and additionally the number of digital pins is different. The Arduino has 20 digital pins and the D1 only 16 digital pins. However, the digital pins of the D1 have more useful additional functions.

Please note: The designation of the D1 digital pins is also different from those of the Arduino and therefore must be adjusted in software.

Last but not least, the USB connector is also different. In contrast to the Arduino, the D1 has the much more common Micro USB standard.

Setup of the D1

Open the Arduino IDE and connect the D1 to the computer. Select the appropriate COM port of the D1 under Tools > Port. If the D1 is not recognized here, this is probably due to a missing driver.

If you now select the appropriate COM port and upload an example sketch to the D1 you will probably get the following error message: “An error occurred while uploading the sketch avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x2e”. The reason for this error is that the wrong board was selected. The name of the selected board appears in the lower right corner of the IDE:

To be able to select the D1 the board manager for the ESP8266 must be added. Insert the following link in Preferences > Board Manager: http://arduino.esp8266.com/stable/package_esp8266com_index.json

Then search for ESP8266 in Tools > Board > Board Manager and install the latest version:

Now select in Tools > Board > ESP8266 Boards > LOLIN (WEMOS D1 R2 &mini):

Now you can select an example project under File > Examples > 01.Basics > Blink and with a click on Upload the whole thing works. The example project now lets the blue LED on the ESP8266 module blink.

Attention: This setup was unique for the first time usage and does not need to be repeated again!

Connecting WeMos D1 to the Internet

The program structure corresponds to that of a regular microcontroller as known from the Arduino. There is a setup() function, which is called only once directly at the start of the program and a loop() function, which runs in a continuous loop after the setup().

First the ESP WiFi library is needed. This is included with #include <ESP8266WiFi.h>. As soon as the ESP is powered, a Wi-Fi connection should be established. Therefore the code is written into the setup() function.

We need the serial monitor to display the current state of the connection. The baudrate can be set by the user. For the D1 I use 115200. The serial monitor can be found under Tools > Serial Monitor. In the window of the serial monitor you can set the baudrate. Please select 115200 as well. If you don’t choose the same baudrate as defined in setup(), you will only see unreadable special characters.

To connect to the Wi-Fi the simple command WiFi.beginn(“WlanName”, “WlanPasswort”) is sufficient. It can be very helpful to display the IP address of the D1. For this purpose use the command WiFi.localIP()

#include <ESP8266WiFi.h>

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

}

void loop() {
  // put your main code here, to run repeatedly:

}

The D1 as web server and DNS server

After the previous steps the D1 is connected to the WiFi, but not yet accessible via a browser. So that the D1 can be controlled comfortably over the Browser one needs the #include <ESP8266WebServer.h> library. Then create a web server object with the command ESP8266WebServer server(80) and set the port 80. The server can now be started with the command server.begin(). So that the D1 can check at any time whether requests are to be processed, the server.handleClient() is written into the loop() function.

If you now enter the IP address of the D1 in a browser, from a device that is in the same WiFi, the D1 is already accessible. It is just not specified yet what should happen when the D1 is called.

You can also display predefined functions here. Initially, for example, a sentence if the link has not been defined, or a text for a custom link. It is also possible to execute own functions for certain links.

server.onNotFound([](){ 
  server.send(404, "text/plain", "Link was not found!");  
});
 
server.on("/", []() {
  server.send(200, "text/plain", "Landing page!");
});
 
server.on("/custom", []() {
  server.send(200, "text/plain", "Just a custom route!");
  ownFunction();
});

The web server setup is now complete. Since it is usually very annoying to type the IP address of the D1 into the browser or it can change, it makes sense to assign a name to the DNS of the D1. For this again a library is used, which is included by #include <ESP8266mDNS.h>. The DNS is defined once and therefore written into the setup() function. To define the DNS name, use the method MDNS.begin(DNS Name), for example MDNS.begin(nerd-corner). Additionally MDNS.update() must be written into the loop function.

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

ESP8266WebServer server(80);

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

  if (MDNS.begin("nerd-corner")) {
    Serial.println("DNS started, available with: ");
    Serial.println("http://nerd-corner.local/");
  }

  server.onNotFound([](){ 
    server.send(404, "text/plain", "Link was not found!");  
  });
 
  server.on("/", []() {
    server.send(200, "text/plain", "Landing page!");
  });
 
  server.on("/custom", []() {
    server.send(200, "text/plain", "Just a custom route!");
    ownFunction();
  });

  server.begin();

}

void loop() {
  server.handleClient();
  MDNS.update();

}

void ownFunction(){ //go to "IP-Adress/custom" to call this function
  Serial.println("Own function was called");

}

Afterwards you can enter http://nerd-corner.local in the browser and you will reach the D1. Please note that the ending must always be “.local”! Some Android devices do not support mDNS, then the actual IP address must still be specified. Now you can use it for your own projects!

Example program to switch the OnBoard LED on and off

At the end of this blogpost we have a simple example program where we apply what we have learned so far. We write two additional functions. One to switch on the built-in LED and one to switch it off. A small hint, in contrast to the Arduino the LED is switched on with digitalWrite(LED_BUILTIN, LOW) instead of switched off, so exactly inverted!

The functions can be called via http://nerd-corner.local/on and http://nerd-corner.local/off. Here is the complete program code:

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

ESP8266WebServer server(80);

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

  if (MDNS.begin("nerd-corner")) {
    Serial.println("DNS started, available with: ");
    Serial.println("http://nerd-corner.local/");
  }

  server.onNotFound([](){ 
    server.send(404, "text/plain", "Link was not found!");  
  });
 
  server.on("/", []() {
    server.send(200, "text/plain", "Landing page!");
  });
 
  server.on("/on", []() {
    server.send(200, "text/plain", "Switching LED on!");
    switchLedOn();
  });

  server.on("/off", []() {
    server.send(200, "text/plain", "Switching LED off!");
    switchLedOff();
  });

  server.begin();


  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  server.handleClient();
  MDNS.update();

}

void switchLedOff(){ 
  digitalWrite(LED_BUILTIN, HIGH);   // turn the D1 LED off 
}

void switchLedOn(){ 
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED on 
}

The post WeMos D1 R2 setup and wifi integration appeared first on Nerd Corner.

This might also be interesting for you: Development of a step-down module

List of components:

• 1x Battery Shield V3
• 1x LiPo 18650

Analysis of the Battery Shield V3

After the Battery Shield V3 arrived, the first thing I had to do was examine its properties in detail.  I thought about the tests beforehand and they were primarily based on my use cases. Since I am of course not a research institute, I kept the tests as simple as possible.

First, I tested the main function, which is charging a LiPo battery. The charging process on the module is indicated by a LED. Red means that the battery is charging and green signifies that charging is complete. Unfortunately, the LEDs are located on the bottom of the module and are therefore not easily visible.

According to the information provided by the manufacturer or the online retailer, the charging voltage is 4.2 V and the charging current is 500 mA. To verify these values, I measured and noted the state of charge of the inserted battery. The state of charge was approximately at 1100 mAh. The total capacity of the battery is 3000 mAh. It appears that the difference between fully charged and partially charged is 1900 mAh. To get the expected charging time, this value is divided by the 500 mA specified by the manufacturer. The calculated charging time is therefore 4 h. A standard power supply with 5V and 1A charging current is used as the power supply. In reality, the duration of charging was 4 h and 15 min. This is close to the theoretical value and thus okay.

Please note: Never use a brand new LiPo battery for this test, instead use one that already has some charge cycles completed. Otherwise, the result is not very meaningful.

Voltage testing in the Review Baterry Shield V3

In the second test, the different voltages provided by the module were examined. I divided this test into two phases. In the first phase (picture test 2_1) the module is used without a LiPo battery. Afterwards in the second phase a LiPo battery is used.

Of course, it is important to choose the right components to make the test as realistic as possible. For the USB-A connection I selected a load resistor with 1 A as well as with 2 A. This ceramic load resistor is ideal because a USB interface is available and the LED lights up green when 5 watts are consumed. At 10 watts the LED lights red.

For the 3 x 5 V outputs, I soldered 5V LED strips to two outputs and the third 5V output has a step-down module LM2596S which I constructed and set to 2V to power a 10 mm RGB Led. 3 V LEDs were soldered to each of the 3 x 3 V outputs. For this test a 5 V (18 Watt) power supply was used.

The module operating without LiPo battery

After connecting the consumers and the power supply, not much happened. Only the module-internal LED lit up red. Only when I deactivated the ceramic load resistor one of the 5 V LED strips and the RGB diode connected to the step-down (marked yellow in picture Test2_1) lit up.

Subsequent measurement of the outputs revealed the following values: A voltage of 3.24 V was measured for the 5 V outputs and 2.28 V for the 3 V outputs. The total current supply of the module without the LiPo battery inserted is about 11 mA. This should be sufficient for a small LED.

The module with LiPo battery

For phase 2 all consumers were removed and a LiPo battery (SAMSUNG INR18650-35E SDI KL59) was inserted into the module. As shown in the pictures, connectors were attached. This is because this module does not have a switch for the LiPo battery, so the load is immediately applied to the LiPo battery. It is simply uncomfortable to insert or plug in a battery under load.

All loads are in full mode in phase 2 and work fine. In addition, even the LiPo battery is charged. Questionable are the 4A amperage specifications of the 5V outputs. Given the amp numbers of the LiPo battery, this is possible, but it seems very high for a USB Micro supply. My recommendation would be to use the module with less than 4 amps.

Deep discharge protection

The third and last test is rather trivial. To test the deep discharge protection, only the ceramic load resistor with 5 watts was activated and no power supply was connected. This discharged the LiPo battery and if the deep discharge protection of the module terminates the discharge process on its own, the test was successful. This was the case. There was enough remaining capacity. However, such stress situations for the LiPo battery should still be avoided.

Casing for the Battery Shield V3

Of course I couldn’t resist to build a case for the Battery Shield V3 module. Beside the normal 5V USB output, which can be switched on and off by an extra switch, I also constructed a constant 3V output with a 5,5 x 2,1 socket into the case.

The housing can be downloaded in STL format at the end of the blog post.

Minor disadvantages

The On/OFF switch only switches the USB port. The 3 x 3 V and 3 x 5 V solder pins cannot be switched on and off by this switch.

For my electronic projects this disadvantage is not really dramatic, because I use mostly the USB port. Besides, additional switches can be soldered to the soldering points.

Downloading files:

• Datenblatt Battery Shield V3 (von AZ Delivery)
• STL Files for the housing

The post Review Battery Shield V3 – DIY Powerbank with LiPo 18650 appeared first on Nerd Corner.

At first, I only want to transmit individual text messages in one direction. In a next step this can then be extended to transmit whole files bidirectionally. To receive the messages, I chose an Ardunio, because unlike the Raspberry Pi, it has analog inputs and can thus be easily connected to analog sensors. For sending, a Raspberry Pi is suitable, since only digital pins are needed here and a Pi can generally transmit data more efficiently and faster. This has already been tested in the previous posts about defining a clock frequency for the Arduino and the Raspberry Pi. All scripts to run the VLC communication can be downloaded at the end of the article. The following three blogposts are directly related to this project:

===> UPGRADE: SENDING ALL KINDS OF DATA WITH VISIBLE LIGHT COMMUNICATION

How to program the clock frequency of the Arduino: Use timer interrupts as clock frequency.

How to program the clock frequency of the Pi: Precise timer function in C for the Pi.

How to prevent errors in data transmission: Using CRC to detect corrupted packets.

List of components

• Arduino Uno
• Raspberry Pi
• 5V Solarcell
• 5V Laserdiode
• Jumper cables

Wiring for the visible light communication

The wiring is rather simple. The 5V solar cell is very well suited to detect light signals. Therefore the solar cell is connected to the receiver, which is the Arduino. The ground of the solar cell is connected to a ground of the Arduino. The positive line of the solar cell is connected to an analog pin of the Arduino. Here, for example, A0 is suitable.

From the Raspberry Pi the messages are transmitted to the Arduino via light signals of the laser. For this, the ground of a 5V laser diode is connected to a ground pin of the Pi (see graphic). Then the positive line of the laser diode is connected to one of the digital pins of the Raspberry Pi. Here I chose the GPIO17 pin, which corresponds to pin 0 in the “wiringPi” library (see graphic).

As an alternative to the laser and the solar cell combination, an LED and a photoresistor can also be used. However, a laser is better suited for faster and more precise data transmission. In addition, a solar cell offers a large area to detect the laser beams.

Modulationtechnique On-Off-Keying

The text messages are transmitted in binary code as “1” or “0”. There are different ways to modulate this data. One of the simplest possibilities is to set an identical clock frequency for the transmitter and receiver. Then either a “1” or a “0” is transmitted in each clock pulse.

The procedure is called aplitude shift keying. If the laser diode illuminates the solar plate particularly strongly, this is detected by the receiver as a binary “1”. If the laser diode shines only weakly, it will be detected as binary “0”.

In fact it makes sense not to let the laser diode shine at all for a binary “0”. This is called On-Off keying. This is a simplification of amplitude shift keying. The following graphic illustrates the difference between amplitude shift keying and on-off keying.

That means, whenever the solar cell detects light, a corresponding voltage value is passed to the analog pin of the Arduino. If this voltage value exceeds a predefined value, the Arduino registers it as a binary “1”, otherwise as a binary “0”. It makes sense to adjust the predefined value to the daylight. Possibly with the help of an additional light sensor.

Arduino code to receive messages

//This is the "real" loop function
  switch (state)
  {
    case 0:
      //looking for synchronization sequence
      synchro_Done=false;
      lookForSynchro(data);

      if (synchro_Done== true)
      {
        state=1;
      }
      break;
    case 1:
      //receive Data
      receiveData_Done =false;
      receiveData(data);

      if (receiveData_Done==true)
      {
        state=0; 
      }
      break;
  }

The software of the Arduino is basically built as a state machine. There are two states. One state for synchronization and one for reading the text message. In the state synchronization the receiver waits for a fixed bit sequence (preamble) for example “101010101111111111”. This sequence means that the receiver must listen now because a text message follows. The complete Arduino code can be downloaded at the end of the article. The following graphic shows the exact structure of the data packets.

As soon as the preamble is recognized, the receiver automatically switches to the second state and receives the actual message. However, the first 16 bits of the text message correspond to a decimal number, which tells the receiver how many characters the incoming text message contains. When this number is reached, the text is printed in the Serial Monitor of the Arduino and the state changes back again. Now the synchronization sequence is awaited again. The complete software code can be downloaded at the end of the blog article. To improve the transmission quality, a cyclic redundancy check (CRC) can be performed as shown in the following graphic.

Raspberry Pi code to send messages

//Read message
        char msg[3000]; 
        int len, k, length;
       
        printf("n Enter the Message: ");
        scanf("%[^'n']",msg);
        
        len=strlen(msg);
        
        
        int2bin(len*8, 16); //len*8, because 8 bits are one byte
        
        for(k=0;k<len;k++)
        {
                chartobin(msg[k]);            
        }

The program code of the Raspberry Pi must be written in C. Python would be too slow and would not achieve a stable clock frequency for sending the data. The complete program code can be downloaded at the end of the article. In order for the Pi to control the laser diode the “wiringPi.h” library is needed. With “digitalWrite(0, HIGH)” the diode can be switched on and with “digitalWrite(0, LOW)” it can be switched off. Important: Please don’t forget the “wiringPi” library when compiling! The command is: “gcc -o simpleLaser simpleLaser.c -lwiringPi”.

At the beginning the program asks for a text message using the printf function. This is read in and stored by a scanf function. Then each letter is converted to binary code and stored in an array. The conversion is shown in the following graphic. At the end, the binary code is transmitted from the array in a fixed clock pulse. The laser diode is switched on for a binary “1” and off again for a binary “0”.

Conclusion on the Visible Light Communication for Arduino

The transmission of text messages by means of visual light communication works excellently. Thanks to the cyclic redundancy check, it is also absolutely error-free. However, the benefit of one-dimensional message communication is rather low. It would be better if any kind of files could be transmitted and that in both directions. An update will probably follow soon.

Download files

• Arduino Code VLC to receive text messages
• Raspberry Pi code to send text messages with VLC

The post Sending text messages with visible light communication or LiFi – Pi to Arduino appeared first on Nerd Corner.

This might also be interesting for you: How to control an Arduino via Bluetooth

List of components

• Arduino Uno
• LED
• 220 Ohm resistor
• Wires
• Breadboard

What is a timer actually?

A timer is basically nothing else than a certain register in the microcontroller, which is increased (or decreased) continuously by 1 under hardware control. Instead of coding instructions in the program that are executed regularly and increment a register by 1, the microcontroller does this all by itself!

This becomes useful, if an action is executed at certain counter values. One of these ‘certain counts’ is for example the overflow. The count register of a timer can not be incremented arbitrarily long. E.g. the highest count that an 8-bit-timer can reach is 2^8 – 1 = 255. The next incrementing step is not 256, instead an overflow occurs, which makes the timer become 0 again. This is the magic! We can configure the controller so that an interrupt is triggered when the timer overflow occurs. We can write code in the Arduino program what should happen in case of an interrupt. For example, we can make an LED light up or query a certain sensor value.

Arduino Uno Microcontroller ATMEGA328P

The ATMEGA328P microcontroller is the heart of the Arduino Uno board. (ATTENTION: The Arduino Mega e.g. has a different microcontroller!) The ATMEGA328P microcontroller has 3 timers (datasheet) which are partly used in Arduino functions and/or partly in libraries. Overwriting the timer registers can therefore lead to complications with existing timer functions like millis(), micros() or delay() and should be used with caution. The 3 timers are Timer0 (8Bit), Timer1 (16Bit) and Timer2 (8Bit).

• 8 Bit-Timer0: used for functions millis(), micros(), delay() and for PWM at pin D5 and D6
• 16 Bit Timer1: Use e.g. for the Servo, VirtualWire and TimerOne library and for PWM at pin D9 and D10
• 8 Bit Timer2: Used for function tone() and for PWM at pin D3 and D11

How to vary the clock speed?

The system clock of the Arduino Uno is 16 MHz (CPU frequency). This means Timer0, Timer1 and Timer2 increase 16 million times per second. For example, the 8 bit timers count from 0 to 255 each time. At 256 an overflow occurs and the timers start again from 0. This means 16000000/256 = 62500 overflows per second (62.5kHz clock rate). This is likely too fast for most timer applications!

Therefore there is a trick to slow down the clock rates. You use a so-called prescaler. A prescaler can be set to the values 1, 8, 64, 256 or 1024. It allows you to divide the system clock (16MHz) by the selected factor and set a lower clock rate for the timers. For example, a prescaler of 1024 would increase the timer registers by 1 only at the 1024th system clock pulse. This would be 16000000/1024=15625 increments per second and thus with an 8 bit timer 15625/256= 61.035 overflows per second (~61 Hz clock rate of the timer).

Practical example LED should light up with 50Hz

In the following, the triggering of Arduino Timer Interrupts is shown with the 16-bit timer1. With this a LED should light up in a 50 Hz cycle. Schematic, Arduino code and pictures are also included. (The procedure for the 8 bit timer0 and timer2 is analog.) For the time controlled pulse you need the so called “CTC Mode”.

In CTC mode (“Clear Timer on Compare Mode”) the counter is cleared when the value of the counter (TNCT1) matches either the value of the OCR1A register or the value of the ICR1 register (in our case OCR1A). So the OCR1A register determines the maximum value of the counter and thus its resolution.

The 16 Bit Timer1 needs the following registers

• Timer Counter Register 1: TCNT1
• Output Compare Register A: OCR1A
• Timer Counter Control Register A: TCCR1A
• Timer Counter Control Register B: TCCR1B
• Timer/Counter Interrupt Mask Register: TIMSK1
• (For Timer0 and Timer2 the corresponding registers would be TCNT0 and TCNT2, respectively)

Calculate the OCR1A register for Arduino Timer Interrupts

The value of the OCR1A register depends on the desired interrupt frequency and the selected prescaler. The following formula applies:

We put our specifications into the formula:

• CPU frequency Arduino Uno: 16.000.000 Hz
• Desired interrupt frequency: 50 Hz (= 20 ms period duration)
• Possible prescaler: 1, 8, 64, 256 or 1024

Calculation example with Prescaler 1024:
OCR1A= (16.000.000 / (1024 * 50)) – 1 = 311,5

Calculation example with Prescaler 8:
OCR1A= (16,000,000 / (8 * 50)) – 1 = 39,999

ATTENTION: The OCR1A value must be less than 65.536 (2^16 )!

Therefore a prescaler 8 can NOT reach 10Hz interrupt frequency:
OCR1A= (16.000.000 / (8 * 10)) – 1 = 199.999

The value 199.999 is larger than the register with 65.536, therefore another prescaler must be used to reach 10 Hz

Instead a prescaler 64 for 10 Hz interrupt frequency:
OCR1A= (16.000.000 / (64 * 10)) – 1 = 24.999

If a Timer1 interrupt is now triggered, the program flow jumps to an interrupt service routine to be created “ISR(TIMER1_COMPA_vect)”. (See Arduino Code)

Bit combination for the desired prescaler

Arduino Timer Interrupts code for 50 Hz frequency

void setup() {

  pinMode(11,OUTPUT);  //LED pin (to blink in 50Hz frequency)
  
//START TIMER SETUP
//TIMER SETUP for highly preceise timed measurements 

  cli();//stop all interrupts

  // turn on CTC mode
  TCCR1A = 0;// set entire TCCR1A register to 0
  TCCR1B = 0;// same for TCCR1B
  TCCR1B |= (1 << WGM12);

  // Set CS11 bit for prescaler 8
  TCCR1B |= (1 << CS11); 
  
  //initialize counter value to 0;
  TCNT1  = 0;
  
  // set timer count for 50Hz increments
  OCR1A = 39999;// = (16*10^6) / (50*8) - 1  
  
  // enable timer compare interrupt
  TIMSK1 |= (1 << OCIE1A);
  
  sei();//allow interrupts
  //END TIMER SETUP
}



ISR(TIMER1_COMPA_vect) {//Interrupt at frequency of 50 Hz
 //write your timer code here

 digitalWrite(11,HIGH);
 delay(15);
 digitalWrite(11,LOW);
}




void loop() {

//when the timer is over, your program will stop in the loop function and jump to the timer code. 
//After the timer code it will jump back to the point where it left the loop function
}

The post Arduino Timer Interrupts – How to program Arduino registers appeared first on Nerd Corner.

This might also be interesting for you: Simple guide on how to use a Hall Sensor with an Arduino

List of components

• Arduino Nano
• Nano Terminal Adapter
• 6 magnets
• Hall sensor KY024
• LED strip
• Jumper cables
• Screws 2x M2 and 1x M3 for the sensor
• Deep groove ball bearing 6807 2RS / 61807 2RS 35x47x7 mm
• 3D printing test setup (STL files in Download section)

Construction of test bench

First we glued the 6 magnets into the 3D printed wheel. Make sure that the magnets are aligned homogeneously. Then the deep groove ball bearing is inserted into the detection wheel. The wheel can now be connected to the 3D printed bracket. Next we attach the Hall sensor KY-024 to the bracket. The Arduino Nano is plugged onto the adapter terminal and also attached to the bracket. The LED strip does not have to be attached separately. So you can start with the wiring.

Wiring

The wiring is not very difficult. Proceed according to the fritzing sketch. Connect the 4 jumper cables to the pins of the Hall sensor KY-024 and connect them to the Arduino Terminal Adapter. The 5V output of the Arduino is shared with both the Hall Sensor and the LEDs. Since there are only a few LEDs, no external power supply is required. For the LED strip you may have to solder them. We recommend to use a 220 Ohm resistor for the digital input of the LED strip.

Arduino Code Simple (with digital input)

In this code example, the Hall sensor KY024 sends the digital value 1 (HIGH) if there is a magnet or 0 (LOW) if no magnet is nearby. As soon as a HIGH is detected, the LEDs start to light up. But if the a magnet stops in front of the Hall sensor, it will send a HIGH constantly and the LEDs won’t stop lightning.

#include <FastLED.h>
#define LED_PIN     7
#define NUM_LEDS    6

CRGB leds[NUM_LEDS];

int digitalPin = 9; // Hall magnetic sensor input 1 (high) or 0 (low)
int digitalInputValue ; // digital readings

void setup ()
{
  FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
  pinMode (digitalPin, INPUT); 
  
  Serial.begin(9600);
}

void loop ()
{
  
  digitalInputValue = digitalRead(digitalPin) ; 
  Serial.println(digitalInputValue); // print value
  if (digitalInputValue == HIGH) 
  {
    for (int i = 0; i <= 5; i++) 
    {
    leds[i] = CRGB ( 255, 0, 0);
    FastLED.show();
    delay(40);
    }
  }

  else if (digitalInputValue ==LOW)
  {
    for (int i = 0; i <= 5; i++) 
    {
      leds[i] = CRGB ( 0, 0, 0);
      FastLED.show();
      delay(30);
    }
  } 
}

Arduino code more advanced (with analog input)

This code is a bit more advanced. The goal for the Hall Sensor Movement Detection is to let the LEDs light up as soon as a rotary movement is detected. Even if a magnet stops directly in front of the KY024 Hall sensor, the LEDs must not light up, because there is no movement.

For this reason, the analog value of the Hall sensor is considered instead of the digital value. If the analog value changes, a rotary movement takes place. A small offset has been integrated to compensate minor fluctuations that occur even without a rotary movement. A counter was programmed as a double safeguard, which also counts how often the analog value changes. The double protection is intended to prevent the Hall sensor from detecting a magnetic field at a standstill.

#include <FastLED.h>
#define LED_PIN 7
#define NUM_LEDS 6
CRGB leds[NUM_LEDS];


int analogPin =A0;
int analogVal; // analog readings
int detector =0;
int firstVal=0;
int HIGHcount=0;


void setup() {
  FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);//pinMode (led, OUTPUT); 
  pinMode (analogPin, INPUT); 
  Serial.begin(9600);
  
}

void loop() {
  analogVal= analogRead(analogPin);
  detector = abs(firstVal-analogVal);  //if there is a difference >0 then the wheel might be spinning
  firstVal=analogVal;

  if (detector>4)   //offset = 4 can be adjusted
  {
    HIGHcount++;  //counting the high to eleminate false positives  
    }
  else if (detector<=10)
  {
    HIGHcount=0;
  }

  if (HIGHcount>1)
  {
    YellowToRed(0); 
    delay(1000);
    HIGHcount=0;
    }

  else
  {
     for (int i = 0; i <= 5; i++) 
  {
    leds[i] = CRGB ( 0, 0, 0);
    FastLED.show();
    delay(30);
  } 
    }

}


void YellowToRed(int colorStep)
{
  for( colorStep; colorStep<250; colorStep+=5 ) {

      int r = 255;  // Redness starts at zero and goes up to full
      int b = 0;  // Blue starts at full and goes down to zero
      int g = 255-colorStep;              // No green needed to go from blue to red

      // Now loop though each of the LEDs and set each one to the current color

      for(int x = 0; x < NUM_LEDS; x++){
          leds[x] = CRGB(r,g,b);
          leds[x].maximizeBrightness(255-colorStep);
      }

      // Display the colors we just set on the actual LEDs
      FastLED.show();

      delay(50); 
  }
}

Pictures of the Hall Sensor Movement Detection

Download files

• Magnet Wheel (STL)

The post Hall Sensor Movement Detection appeared first on Nerd Corner.

This might be interesting for you: We built a Hall sensor movement detection wheel

We have already started small Arduino projects. Next we want to build a prayer wheel that will light up when it is rotated. For this we will need a Hall sensor.
This post shows a simple example to explain how to connect a Hall sensor to an Arduino and program it so that an LED starts to light up as soon as the Hall sensor KY024 detects a magnetic field.

List of components

• Arudino Mega
• Jumper cable
• 220 Ohm resistor
• LED
• Magnets
• Hall sensor KY-024

How does a Hall sensor work or what is the Hall effect?

When a current-carrying electrical conductor is in a magnetic field, an electrical field builds up. This is perpendicular to the current direction and to the magnetic field and compensates for the Lorentz force which acts on the electrons.

A Hall sensor also provides a signal when the magnetic field in which it is located is constant. This is the advantage compared to a simple coil, which can only determine the derivation of the magnetic field over time.

The Hall sensor KY-024

The linear magnetic Hall sensor KY-024 can detect magnetic fields and therefore reacts as soon as you approach it with a magnet. It has a potentiometer with which the sensitivity of the sensor can be set. The KY-024 Hall sensor offers both an analog and a digital output.

The digital output acts as a switch that turns on and off when a magnet is nearby. The analog output, on the other hand, can measure the polarity and relative strength of the magnetic field.

KY-024 Arduino Wiring

It is a simple structure that only serves to illustrate the functioning of the KY-024 Hall sensor. Please pay attention to the forward direction of the LED, the kinked end is connected to an Arduino pin and the straight end to GND. Correctly the LED needs a 220 Ohm ballast resistor. However, this can also be neglected for the short duration of use.

Otherwise, connect the GND of the KY-024 to the GND of the Arduino analogous to the Fritzing sketch. Connect the analog output A0 of the KY-024 to A0 of the Arduino Mega. Connect the + of the KY-024 to 5V of the Arduino and connect the digital output D0 of the KY-024 to pin 9 of the Arduino. That was the complete wiring.

Hall sensor KY-024 Arduino Code

int LED = 53 ; // LED
int digitalPin = 9; // Hall magnetic sensor input 1 (high) or 0 (low)
int analogPin = A0; // analog Pin also available, but not necessary
int digitalInputValue ; // digital readings
int analogInputValue; // analog readings

void setup ()
{
  pinMode (LED, OUTPUT); 
  pinMode (digitalPin, INPUT); 
  pinMode(analogPin, INPUT); //not necessary, but it is interesting to see the analog values
  Serial.begin(9600);
}

void loop ()
{
  
  digitalInputValue = digitalRead(digitalPin) ; 
  if (digitalInputValue == HIGH) // When magnet is present, digitalInputValue gets 1 (HIGH) and turns LED on
  {
    digitalWrite (LED, HIGH);
    
  }
  else
  {
    
    digitalWrite (LED, LOW);
  }
  
  //Here you can see the analog values of the sensor
  analogInputValue = analogRead(analogPin);
  Serial.println(analogInputValue); // print analog value

  delay(100);
}

We first define the assignment of the LED (here pin 53), the digital (pin 9) and the analog pin (pin A0) and two variables to read the digital and analog sensor data. The digital pin is sufficient for our purpose of lighting the LED.

The analog pin can actually be neglected. However, since it is useful for this tutorial to show the analog values, the analog pin was nevertheless taken into account in the code.
The respective pin mode is defined in the setup and the digital sensor value of the KY 024 is read in the loop function and, depending on the value, the LED receives the command to light or not. The digital sensor value is either 0 or 1. If you want to, you can use the penultimate 2 lines to display the associated analog values.

Download file

• Hall sensor KY-024 Arduino code

The post How to use the hallsensor KY-024 with Arduino Code and Wiring appeared first on Nerd Corner.

List of components

• Arudino Mega
• Breadboard
• 12V power supply
• 12V fan
• jumper cable
• 220 Ohm resistor
• NPN Transistor number: BC546B D6
• Bluetooth module HC-05 or HC-06

Wiring

For the wiring, we proceed analogously to our “fan control” post. The 12V power supply must be connected to the breadboard. We connect this – of the breadboard with GND of the Arduino (the short blue cable connection in the picture). Then we connect the + of the breadboard to Vin of the Arduino Mega (red cable between Arduino and breadboard).

If we would plug the 12V power supply into the socket now. Then our Arduino would already be powered. There is no additional power supply like USB required. The Vin pin of the Arduino automatically regulates the 12V of the power supply to 5V for the Arduino.

Now we plug the NPN transistor into the breadboard. We connect the base (B) to the 220 Ohm resistor and then to pin 13 (yellow connection in the picture). We connect the collector (C) of the transistor directly to the negative connection of the fan (black fan cable). The positive fan connector is connected to the + of the breadboard. We connect the emitter (E) of the transistor to the – of the breadboard.

In addition to these already known steps, we take the Bluetooth module and connect the ground of the module to the ground of the Arduino (black cable). VCC of the module must be connected to 3.3V of the Arduino (red connection). If there is no 3.3V connection, the 5V connection can also be used. TX of the Bluetooth module has to be connected to RX of the Arduino (orange cable). RX of the module has to be connected to TX of the Arduino (purple cable). This means TX to RX and RX to TX. Always the equivalent!

Important: While the Arduino code is being flashed on the Arduino, you have to unplug RX and TX. Otherwise the flash process won’t work!

Programming the Android Bluetooth classic app for Arduino

We program a pure Android app with an HC-05 or alternatively HC-06 Bluetooth module. These two are Bluetooth Classic Modules. You can not connect to Bluetooth 4.0 also called Bluetooth Low Energy (BLE). The code for BLE is very different. Below is the programming guide for a Bluetooth Android app build with Xamarin Android. All important files are also uploaded!

As development environment we use Visual Studio (it is free) for the Xamarin.Android app. In AndroidStudio, the process is analogous, but the code will be in Java and not in C#.

Click on “Create new project” and select “Android app (Xamarin)”. At First we add the Bluetooth permissions to the “AndroidManifest.xml” file:

<uses-permission android: name = "android.permission.BLUETOOTH" />
<uses-permission android: name = "android.permission.BLUETOOTH_ADMIN" />

Then we design the layout of the app in the “activity_main.xml” file. We need 2 buttons for “Connect” and “Disconnect” and a slider for speed control. For the slider we set the maximum value to 127 (android: max = “127”).

In “MainActivity.cs” we add “using Android.Bluetooth”, create a “BluetoothConnection” class and set our “activity_main.xml” file as the start page. A Bluetooth socket is created for the connection to the Arduino. We recommend to look at the source code which is attached to this post.

Essentially, we always send a byte to the Arduino. That means we can send numbers between 0 and 255. For the fan control, we take the range from 0 to 127. The Arduino doubles this value and thus regulates the fan, which also runs in a range between 0 and 255. The rest of the range between 128 and 255 can be used for further functions. That’s it, just compile the app and go to the next step!

Incidentally, the code for the app is based on this project here: https://www.instructables.com/id/3-LED-Backlight-Xamarin-and-Arduino-With-HC05/

Arduino Code

#define motorPin 13
int received; //for the received Byte
int fanSpeed = 127; //initial speed - must be a number between 0 and 255
void setup() {
  Serial.begin(9600); //for communication with the app
  delay(3000); // small delay
  pinMode(motorPin, OUTPUT); //define motor pin as output
  analogWrite(motorPin,fanSpeed); //set the initial speed of the fan
}
void loop() {  
  while(Serial.available()) 
  {
     received = Serial.read(); //received Byte    
     Serial.println(received); //if the arduino is connected to the PC, than you can check the received Byte
     switch (received)  //you can easily add new cases to customize your arduino
     {
        case 200:
            Serial.println("RESTARTED");
            break;
        default:
            if(received >0 && received <=127)
            {
              fanSpeed = (received*2); //app sends value between 0 and 127 - so we need to double it for the fan range between 0 and 255
              delay(10);
            }
            break;
     }  
  }
  analogWrite(motorPin,fanSpeed); //set the speed of the fan
}

Please do not forget to disconnect the RX and TX wires before flashing the Arduino and afterwards connect it again correctly (RX to TX and TX to RX)!

Since we have connected the base of the transistor to pin 13, we define it as “motorPin”. The fan speed can be controlled via the “fanSpeed” variable. At the beginning, we set “fanSpeed” to half the speed, i.e. 127. (Depending on the fan model, a certain minimum speed is necessary for the fan to start.)

We define a variable “received” in which we store the byte sent from the app. In the setup function we start the communication with “Serial.begin” and set the baud rate to 9600. Then we program a while loop in the loop function. The while loop becomes active whenever a byte is received. If the value of the byte is between 0 and 127, we double it and define it as our new fan speed “fanSpeed”. As soon as the while loop has ended, the new speed for the fan is set with “analogWrite (motorPin, fanSpeed);”

Screenshots of the Android Bluetooth classic App for Arduino

Please note, you have to go to the settings and connect to the Bluetooth module at first. Otherwise you won’t be able to connect to the Arduino with the app!

Download files

• Source Code Android App "FanControllerBluetooth"
• Arduino Code for the "FanControllerBluetooth" app
• Only MainActivity.cs AndroidMainfest.xml and activity_main.xml of the "FanControllerBluetooth" app

The post Android Bluetooth classic App for Arduino fan control appeared first on Nerd Corner.

In this post we show you how to regulate the rotational speed of any fan. It doesn’t matter if your fan needs 12 Volt or 5 Volt. Also the number of wires is not important. You can use a 3, 4 or 2 wire fan! We only work with the + and – wire of your fan.

The Arduino supports 5 Volt directly. In our case we use an old PC fan with 12 Volt, so an external 12 Volt power supply is necessary.

List of components

• Arudino Mega
• Breadboard
• 12V power supply
• 12V fan
• Jumper cable
• 220 Ohm resistor
• NPN Transistor number: BC546B D6

Wiring

For the wiring we proceed according to the sketch . The 12V power supply is connected to the breadboard. We connect the – of the breadboard with GND of the Arduino (the short blue cable connection). Then the + of the breadboard to Vin of the Arduino Mega (red cable between Arduino and breadboard).

If we would plug the 12V power supply into the socket now. Then our Arduino would already be powered. There is no additional power supply like USB required. The Vin pin of the Arduino automatically regulates the 12V of the power supply to 5V for the Arduino.

Now we plug the NPN transistor into the breadboard. We connect the base (B) to the 220 Ohm resistor and then to pin 13 (yellow connection in the picture). We connect the collector (C) of the transistor directly to the negative connection of the fan (black fan cable). The positive fan connector is connected to the + of the breadboard. We connect the emitter (E) of the transistor to the – of the breadboard. That’s all for the wiring! Time for the Arduino code!

The code for the Arduino fan controller

The Arduino code is absolutely simple and can be easily integrated into any existing Arduino program. Since we have connected the base of the transistor to pin 13, we define it as “motorPin”. The speed of the fan can then be controlled via the “speed” variable. A value between 0 and 255 must be selected for the speed. Depending on the fan model, a minimum speed is necessary for the fan to start.

The post Arduino fan controller appeared first on Nerd Corner.