Posts with «arduino» label

A Colorful Way To Play Chess On An ATmega328

We’ve all seen those chess computers that consist out of a physical playing field, and a built-in computer that would indicate where you should put its pieces while inputting the position of your pieces in some way. These systems are usually found in a dusty cardboard box in a back room’s closet, as playing like this is fairly cumbersome, and a lot depends on the built-in chess computer.

This take by [andrei.erdei] on this decades-old concept involves an ATmega328p-based Arduino Pro Mini board, a nice wooden frame, and 4 WS2812-based 65×65 mm RGB 8×8 LED matrices, as well as some TTP223 touch sensors that allow one to control the on-board cursor. This is the sole form of input: using the UP and RIGHT buttons to select the piece to move, confirm with OK, then move to the new position. The chess program will then calculate its next position and indicate it on the LED matrix.

Using physical chess pieces isn’t required either: each 4×4 grid uses a special pattern that indicates the piece that occupies it.  This makes it highly portable, but perhaps not as fun as using physical pieces. It also kills the sheer joy of building up that collection of enemy pieces when you’ve hit that winning streak. You can look at the embedded gameplay video after the break and judge for yourself.

At the core of the chess program is [H.G. Muller]’s micro-Max project. Originally ported to the Arduino Uno, this program outputs the game to the serial port. After tweaking it to use the LED matrix instead, [andrei.erdei] was then faced with the lack of memory on the board for the most common LED libraries. In the end, the FAB_LED library managed to perform the task with less memory, allowing it and the rest of the program to fit comfortably into the glorious 2 kB of SRAM that the ATmega328p provides.

Classic 8-bit chess engines are marvels of software engineering. Ever wonder how they stack up against modern chess software? Check out this article!

Feeding Chickens, With Style

Ah, the joys of domestic animals. Often adorable, occasionally useful, they’re universally unable to care for themselves in the slightest. That’s part of the bargain though; we take over responsibility for their upkeep and they repay us with whatever it is they do best. Unless the animal in question is a cat, of course – they have their own terms and conditions.

Chickens, though, are very useful indeed. Give them food and water and they give you delicious, nutritious, high-quality protein. Feeding them every day can be a chore, though, unless you automate the task. This Twitch-enabled robotic chicken feeder may be overkill for that simple use case, but as [Sean Hodgins] tell it, there’s a method to all the hardware he threw at this build. That would include a custom-welded steel frame holding a solar panel and batteries, a huge LED matrix display, a Raspberry Pi and camera, and of course, food dispensers. Those are of the kind once used to dispense candy or gum for a coin or two in the grocery; retooled with 3D-printed parts, the dispensers now eject a small scoop of feed whenever someone watching a Twitch stream decides to donate to the farm that’s hosting the system. You can see the build below in detail, or just pop over to Sweet Farm to check out the live feed and gawk at some chickens.

It’s an impressive bit of work on [Sean]’s part for sure, and we did notice how he used his HCC rapid prototyping module to speed up development. Still, we’re not convinced there will be many donations at $10 a pop. Then again, dropping donations to the micropayment level may lead to overfed chickens, and that’s not a good thing.

Hack a Day 23 Aug 21:00

TinyGo on Arduino

A few weeks ago, we announced that Arduino now works with TinyGo, the popular compiler that brings the Go programming language to microcontrollers. We had the opportunity to sit down with Ron Evans, Technologist for Hire, and learn more about the Arduino and TinyGo integration.

Some of our audience knows about Go (we ourselves use it to develop many of our tools). In a few words: what is TinyGo and how does it stand compared to Go itself?

TinyGo is a Go compiler for small places like microcontrollers. TinyGo is written in Go like the standard Go compiler, but TinyGo then uses the LLVM toolchain to compile Go programs to a fraction of their normal size. TinyGo also employs a different runtime implementation in order to target constrained environments.

Why choosing TinyGo over other languages?

If software is eating the world, then Go is eating the world of software. The popularity of Go is still rapidly expanding, and TinyGo helps bring the new “enterprise standard” language down to the smallest of processors. Also as a compiled language, TinyGo can offer substantially better performance and size efficiency than that of interpreted languages like JavaScript and Python.

How does TinyGo compare to embedded python and JavaScript implementations?

One good reason to use Go is the clear and maintainable code that Go insists that you create. Generally speaking, the normal Go tooling that is included with the language itself is what you use when writing TinyGo code. For example, the standard built-in code formatting. TinyGo includes implementations of the Go “net” package targeting the Arduino Nano33 IoT, so you can more easily reuse existing Go code for TCP/UDP or higher level protocols such as MQTT. This really makes it a lot easier to build commercial or industrial IoT solutions.

Another reason to use TinyGo is the ability to utilize Go’s concurrency. TinyGo implements “goroutines” which can greatly simplify your code to take the greatest performance advantage offered by modern 32-bit microcontrollers.

With security in IoT being one of today’s hottest topics, which tools does TinyGo offer that enable the development of secure projects?

There are a number of things that can make development, deployment, and operations using TinyGo good for edge computing applications that require greater security. Since the code is compiled to binary, it is possible to use code signing and other well known approaches for secure computing.

Another is that any device data must be encrypted while in transit from from the device to any cloud storage or analytics. TinyGo on the Arduino Nano33 IoT can use standard APIs for SSL communication to cloud services, such as using the Eclipse Foundation’s Paho MQTT client for Go. This makes it a lot easier for developers to do the right thing the first time when creating applications.

How can TinyGo improve the Arduino ecosystem? How will our existing audience benefit from using it? Will they be able to use the Arduino libraries already existing?

There is a very active community in the Arduino world, with lots of existing useful libraries. We are planning much deeper integration for TinyGo powered by Arduino, more on this in the near future…

Many people love TinyGo because it’s simple yet powerful. Do you see any similarity with the Arduino mission of ‘making technology simple for everybody?'”

Arduino has really pioneered the open hardware movement, and defining clear APIs to devices has been a huge contribution. TinyGo very much tries to embody this same spirit, while at the same time provide an idiomatic Go language programming experience. Combine the sensibilities that have made TinyGo so popular and that are fueling our continuing growth, alongside the amazing capabilities powered by Arduino, and there are no limits to what we can do!

If you want to learn more about TinyGo, click here and here. During Gophercon, Ron Evans ran a hacking session dedicated to the Arduino Nano 33 IoT and TinyGo — you can discover more on this dedicated page on GitHub

Arduino Blog 23 Aug 13:41

Vintage LED display prototype revived with Arduino

Patrick Hickey has been collecting retro LED indicators and displays for decades, and his rarest item is an HP 5082-7002—a 5×7 dot matrix LED display in a beautiful gold and (possibly) sapphire enclosure. This device is so rare, in fact, that he believes it to be a prototype, somehow relegated to eBay for gold salvage.

Hickey wasn’t able to find any reference to the unit—much less a datasheet—even after extensive research. Instead, he went to work reverse engineering the HP 5082-7002 following the tracks of the PCB to work out how the rows and columns are connected. 

He then designed a test shield for an Arduino Uno with sockets on which the mystery device could sit. With this piece of hardware built, he can now create simple pictures and animated sprites on it using pulsed Arduino outputs.

I followed the tracks to work out which pins are connected rows and columns, and set out to build a test shield for an Arduino Uno.  I decided to drive them as “rows” of 5. The max output of Arduino I/O pins is rated at 40mA, so in theory, I could simultaneously power up to 5 LEDs in parallel at 8mA using 1 pin. In practice, using strobe/multiplexing, the duty cycle is much less: 1/7 or 1/5 depending if you drive by rows (7) or columns (5) respectively. The 5 current limiting series resistors are 470 Ohms (¼ Watt). My preference is to use carbon composition resistors (e.g. Allen Bradley). I love the “retro look” of them and I think they compliment the vintage LEDs.  

I had already written Arduino code for testing some TIL-305 matrix displays, so it was relatively simple to transpose the pins in my sketch for this configuration. The test code permits animations of up to 150 different alphanumeric characters/symbols, and (of course) some animated sprites inspired by retro video games.

1980s plotting device turned into a handheld whiteboard tool

Writing on a whiteboard isn’t an easy task for many people, including instructor ‘Kenyer,’ whose lettering can be on display for a semester or more. Rather than accept his imperfect penmanship, he modified a 1980s-era Rotring NC-Scriber—originally meant for mechanical drawing use—to do this for him.

His project runs on an Arduino Uno and motor shield, along with custom mount for erasable markers. Phrases are programmed via the setup section of the sketch, but he hopes to implement the device’s keyboard for control with the help of a different motor driver in the future. 

You can see it plotting away in the video below, while code and additional info can be found in Kenyer’s write-up.  

Arduino Blog 21 Aug 19:26

Simulating a flip clock on an Arduino-driven LCD screen

Although flip clocks may be extremely interesting electromechanical devices, with rolling flaps to show what time it is, they’re also fairly complicated if you want to build one yourself. Mark Wilson, however, took a different approach with his project, simulating the output on a 320×240 LCD display.

The clock is powered by an Arduino Uno and a DS3231 RTC module, allowing it to show the time, date, a blinking colon, and even the days until the trash/recycling needs to be put out. Alternate screens are available as well, including a Pong clock, triangle clock, and cube clock, which can be individually selected or set to randomly cycle if you so desire. 

For its housing, Wilson chose a minimal acrylic/standoff design that seems to suit it well, and you can see it in action in the short demo clip below.

This thermochromic 7-segment display colorfully shows the temp and humidity

Instead of controlling his temperature and humidity display directly, maker Zaphunk did things a bit differently, driving the temperature of each segment with a Peltier element, or thermo-electric cooler (TEC), to change its color. 

Each segment is made out of a thermochromic material, cycling from a black off state to a greenish hue when on, for a device that can—somewhat ironically—show the temperature by changing its temperature.

Ambient conditions are read via a DHT22 sensor, and everything is controlled by a half-dozen Arduino Nanos. This number boards were needed in order to power the nine dual motor drivers that handle the Peltier elements, each of which require two PWM outputs, along with 5 IO pins. 

The display looks great in the video below and Arduino code is found on GitHub.

Horizontal laser harp is like none you’ve ever seen before

Apparently not content with a traditional laser harp, Jonathan Bumstead set out to take things in a different direction. What he came up with is a device whose laser strings are arranged horizontally, and loop though its boxy structure for an amazing audiovisual effect. 

The aptly named Upright Laser Harp is divided up into six rows, which each contain two laser/photoresistor pairs for an instrument total of 12 notes. Each laser is reflected once before hitting its photoresistor to wrap the entire structure in light, and values are sensed by an Arduino Mega as note inputs. Sounds are then generated by an Adafruit Music Maker Shield, and different MIDI instruments are selected with a rotary switch and a stepper-based electromechanical display system. 

Laser harps are musical devices with laser beam “strings.” When the beam is blocked, a note is played by the instrument. Usually laser harps have the beams travel vertically in the shape of a fan or vertical lines. 

In this project, I built a laser harp with stacked laser beams that propagate horizontally. The beams reflect off mirrors to form square shaped beam paths. Instead of a MIDI output like my previous laser harp, this device has built-in MIDI player so the output is an audio signal. This means the device does not have to be connected to a computer or MIDI player (e.g. keyboard) to play sound. Both built-in speakers and audio output jack are available for playing music.

Be sure to check out the mini-concert and build details in the video below!

LED matrix made touch sensitive with infrared control

If you’d like to integrate touch functionality to your LED matrix project, then tuenhidiy may have just the thing for you

The setup uses 16 pairs of IR emitter and receivers arranged down the length of the bi-color 16×32 matrix to tell when one has inserted a finger or other object into an area. When sensed, it changes the corresponding column on the display from red to green or back again.

An Arduino Mega is used for overall control of the device, along with shift registers and multiplexers/demultiplexers to account for the massive amount of IO needed. 

Code for the build is available on GitHub, and you can see it demonstrated in the video below.

Tutorial – LED Real Time Clock Temperature Sensor Shield for Arduino

In this tutorial we look at how to use the neat LED Real Time Clock Temperature Sensor Shield for Arduino from PMD Way. That’s a bit of a mouthful, however the shield does offer the following:

  • four digit, seven-segment LED display
  • DS1307 real-time clock IC
  • three buttons
  • four LEDs
  • a active buzzer
  • a light-dependent resistor (LDR)
  • and a thermistor for measuring ambient temperature

The shield also arrives fully-assembled , so you can just plug it into your Arduino Uno or compatible board. Neat, beginners will love that. So let’s get started, by showing how each function can be used – then some example projects. In no particular order…

The buzzer

A high-pitched active buzzer is connected to digital pin D6 – which can be turned on and off with a simple digitalWrite() function. So let’s do that now, for example:

void setup() {
  // buzzer on digital pin 6
  pinMode(6, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(6, HIGH);   // turn the buzzer on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(6, LOW);    // turn the buzzer off by making the voltage LOW
  delay(1000);                       // wait for a second
}

If there is a white sticker over your buzzer, remove it before uploading the sketch. Now for a quick video demonstration. Turn down your volume before playback.

The LEDs

Our shield has four LEDs, as shown below:

They’re labelled D1 through to D4, with D1 on the right-hand side. They are wired to digital outputs D2, D3, D4 and D5 respectively. Again, they can be used with digitalWrite() – so let’s do that now with a quick demonstration of some blinky goodness. Our sketch turns the LEDs on and off in sequential order. You can change the delay by altering the variable x:

void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(2, OUTPUT); // LED 1
  pinMode(3, OUTPUT); // LED 2
  pinMode(4, OUTPUT); // LED 3
  pinMode(5, OUTPUT); // LED 4
}

int x = 200;

void loop() {
  digitalWrite(2, HIGH);    // turn on LED1
  delay(x);
  digitalWrite(2, LOW);    // turn off LED1. Process repeats for the other three LEDs
  digitalWrite(3, HIGH);
  delay(x);
  digitalWrite(3, LOW);
  digitalWrite(4, HIGH);
  delay(x);
  digitalWrite(4, LOW);
  digitalWrite(5, HIGH);
  delay(x);
  digitalWrite(5, LOW);
}

And in action:

The Buttons

It is now time to pay attention to the three large buttons on the bottom-left of the shield. They look imposing however are just normal buttons, and from right-to-left are connected to digital pins D9, D10 and D11:

They are, however, wired without external pull-up or pull-down resistors so when initialising them in your Arduino sketch you need to activate the digital input’s internal pull-up resistor inside the microcontroller using:

pinMode(pin, INPUT_PULLUP);

Due to this, buttons are by default HIGH when not pressed. So when you press a button, they return LOW. The following sketch demonstrates the use of the buttons by lighting LEDs when pressed:

void setup() {
  // initalise digital pins for LEDs as outputs
  pinMode(2, OUTPUT); // LED 1
  pinMode(3, OUTPUT); // LED 2
  pinMode(4, OUTPUT); // LED 3

  // initalise digital pins for buttons as inputs
  // and initialise internal pullups
  pinMode(9, INPUT_PULLUP); // button K1
  pinMode(10, INPUT_PULLUP); // button K2
  pinMode(11, INPUT_PULLUP); // button K3
}

void loop()
{
  if (digitalRead(9) == LOW)
  {
    digitalWrite(2, HIGH);
    delay(10);
    digitalWrite(2, LOW);
  }

  if (digitalRead(10) == LOW)
  {
    digitalWrite(3, HIGH);
    delay(10);
    digitalWrite(3, LOW);
  }

  if (digitalRead(11) == LOW)
  {
    digitalWrite(4, HIGH);
    delay(10);
    digitalWrite(4, LOW);
  }
}

You can see these in action via the following video:

The Numerical LED Display

Our shield has a nice red four-digit, seven-segment LED clock display. We call it a clock display as there are colon LEDs between the second and third digit, just as a digital clock would usually have:

The display is controlled by a special IC, the Titan Micro TM1636:

The TM1636 itself is an interesting part, so we’ll explain that in a separate tutorial in the near future. For now, back to the shield.

To control the LED display we need to install an Arduino library. In fact the shield needs four, so you can install them all at once now. Download the .zip file from here. Then expand that into your local download directory – it contains four library folders. You can then install them one at a time using the Arduino IDE’s Sketch > Include library > Add .zip library… command:

The supplied library offers five functions used to control the display.

.num(x);

…this displays a positive integer (whole number) between 0 and 9999.

.display(p,d);

… this shows a digit d in location p (locations from left to right are 3, 2, 1, 0)

.time(h,m)

… this is used to display time data (hours, minutes) easily. h is hours, m is minutes

.pointOn();
.pointOff();

… these turn the colon on … and off. And finally:

.clear();

… which clears the display to all off. At the start of the sketch, we need to use the library and initiate the instance of the display by inserting the following lines:

#include <TTSDisplay.h>
TTSDisplay rtcshield;

Don’t panic – the following sketch demonstrates the five functions described above:

#include <TTSDisplay.h>
TTSDisplay rtcshield;

int a = 0;
int b = 0;

void setup() {}

void loop()
{
  // display some numbers
  for (a = 4921; a < 5101; a++)
  {
    rtcshield.num(a);
    delay(10);
  }

  // clear display
  rtcshield.clear();

  // display individual digits
  for (a = 3; a >= 0; --a)
  {
    rtcshield.display(a, a);
    delay(1000);
    rtcshield.clear();
  }
  for (a = 3; a >= 0; --a)
  {
    rtcshield.display(a, a);
    delay(1000);
    rtcshield.clear();
  }

  // turn the colon and off
  for (a = 0; a < 5; a++)
  {
    rtcshield.pointOn();
    delay(500);
    rtcshield.pointOff();
    delay(500);
  }

  // demo the time display function
  rtcshield.pointOn();
  rtcshield.time(11, 57);
  delay(1000);
  rtcshield.time(11, 58);
  delay(1000);
  rtcshield.time(11, 59);
  delay(1000);
  rtcshield.time(12, 00);
  delay(1000);
}

And you can see it in action through the video below:

The LDR (Light Dependent Resistor)

LDRs are useful for giving basic light level measurements, and our shield has one connected to analog input pin A1. It’s the two-legged item with the squiggle on top as shown below:

The resistance of LDRs change with light levels – the greater the light, the less the resistance. Thus by measuring the voltage of a current through the LDR with an analog input pin – you can get a numerical value proportional to the ambient light level. And that’s just what the following sketch does:

#include <TTSDisplay.h>
TTSDisplay rtcshield;

int a = 0;

void setup() {}
void loop()
{
  // read value of analog input
  a = analogRead(A1);
  // show value on display
  rtcshield.num(a);
  delay(100);
}

The Thermistor

A thermistor is a resistor whose resistance is relative to the ambient temperature. As the temperature increases, their resistance decreases. It’s the black part to the left of the LDR in the image below:

We can use this relationship between temperature and resistance to determine the ambient temperature. To keep things simple we won’t go into the theory – instead, just show you how to get a reading.

The thermistor circuit on our shield has the output connected to analog input zero, and we can use the library installed earlier to take care of the mathematics. Which just leaves us with the functions.

At the start of the sketch, we need to use the library and initiate the instance of the thermistor by inserting the following lines:

#include <TTSTemp.h>
TTSTemp temp;

… then use the following which returns a positive integer containing the temperature (so no freezing cold environments):

.get();

For our example, we’ll get the temperature and show it on the numerical display:

#include <TTSDisplay.h>
#include <TTSTemp.h>

TTSTemp temp;
TTSDisplay rtcshield;

int a = 0;

void setup() {}

void loop() {

  a = temp.get();
  rtcshield.num(a);
  delay(500);
}

And our thermometer in action. No video this time… a nice 24 degrees C in the office:

The Real-Time Clock 

Our shield is fitted with a DS1307 real-time clock IC circuit and backup battery holder. If you insert a CR1220 battery, the RTC will remember the settings even if you remove the shield from the Arduino or if there’s a power blackout, board reset etc:

The DS1307 is incredibly popular and used in many projects and found on many inexpensive breakout boards. We have a separate tutorial on how to use the DS1307, so instead of repeating ourselves – please visit our specific DS1307 Arduino tutorial, then return when finished.

Where to from here? 

We can image there are many practical uses for this shield, which will not only improve your Arduino coding skills but also have some useful applications. An example is given below, that you can use for learning or fun.

Temperature Alarm

This projects turns the shield into a temperature monitor – you can select a lower and upper temperature, and if the temperature goes outside that range the buzzer can sound until you press it.

Here’s the sketch:

#include <TTSDisplay.h>
#include <TTSTemp.h>

TTSTemp temp;
TTSDisplay rtcshield;

boolean alarmOnOff = false;
int highTemp = 40;
int lowTemp = 10;
int currentTemp;

void LEDsoff()
{
  // function to turn all alarm high/low LEDs off
  digitalWrite(2, LOW);
  digitalWrite(4, LOW);
}

void setup() {
  // initalise digital pins for LEDs and buzzer as outputs
  pinMode(2, OUTPUT); // LED 1
  pinMode(3, OUTPUT); // LED 2
  pinMode(4, OUTPUT); // LED 3
  pinMode(5, OUTPUT); // LED 4
  pinMode(6, OUTPUT); // buzzer

  // initalise digital pins for buttons as inputs
  // and initialise internal pullups
  pinMode(9, INPUT_PULLUP); // button K1
  pinMode(10, INPUT_PULLUP); // button K2
  pinMode(11, INPUT_PULLUP); // button K3
}

void loop()
{
  // get current temperature
  currentTemp = temp.get();

  // if current temperature is within set limts
  // show temperature on display

  if (currentTemp >= lowTemp || currentTemp <= highTemp)
    // if ambient temperature is less than high boundary
    // OR if ambient temperature is grater than low boundary
    // all is well
  {
    LEDsoff(); // turn off LEDs
    rtcshield.num(currentTemp);
  }

  // if current temperature is above set high bounday, show red LED and
  // show temperature on display
  // turn on buzzer if alarm is set to on (button K3)

  if (currentTemp > highTemp)
  {
    LEDsoff(); // turn off LEDs
    digitalWrite(4, HIGH); // turn on red LED
    rtcshield.num(currentTemp);
    if (alarmOnOff == true) {
      digitalWrite(6, HIGH); // buzzer on }
    }
  }

  // if current temperature is below set lower boundary, show blue LED and
  // show temperature on display
  // turn on buzzer if alarm is set to on (button K3)

  if (currentTemp < lowTemp)
  {
    LEDsoff(); // turn off LEDs
    digitalWrite(2, HIGH); // turn on blue LED
    rtcshield.num(currentTemp);
    if (alarmOnOff == true)
    {
      digitalWrite(6, HIGH); // buzzer on }
    }
  }
  // --------turn alarm on or off-----------------------------------------------------
  if (digitalRead(11) == LOW) // turn alarm on or off
  {
    alarmOnOff = !alarmOnOff;
    if (alarmOnOff == 0) {
      digitalWrite(6, LOW); // turn off buzzer
      digitalWrite(5, LOW); // turn off alarm on LED
    }
    // if alarm is set to on, turn LED on to indicate this
    if (alarmOnOff == 1)
    {
      digitalWrite(5, HIGH);
    }
    delay(300); // software debounce
  }
  // --------set low temperature------------------------------------------------------
  if (digitalRead(10) == LOW) // set low temperature. If temp falls below this value, activate alarm
  {
    // clear display and turn on blue LED to indicate user is setting lower boundary
    rtcshield.clear();
    digitalWrite(2, HIGH); // turn on blue LED
    rtcshield.num(lowTemp);

    // user can press buttons K2 and K1 to decrease/increase lower boundary.
    // once user presses button K3, lower boundary is locked in and unit goes
    // back to normal state

    while (digitalRead(11) != LOW)
      // repeat the following code until the user presses button K3
    {
      if (digitalRead(10) == LOW) // if button K2 pressed
      {
        --lowTemp; // subtract one from lower boundary
        // display new value. If this falls below zero, won't display. You can add checks for this yourself :)
        rtcshield.num(lowTemp);
      }
      if (digitalRead(9) == LOW) // if button K3 pressed
      {
        lowTemp++; // add one to lower boundary
        // display new value. If this exceeds 9999, won't display. You can add checks for this yourself :)
        rtcshield.num(lowTemp);
      }
      delay(300); // for switch debounce
    }
    digitalWrite(2, LOW); // turn off blue LED
  }
  // --------set high temperature-----------------------------------------------------
  if (digitalRead(9) == LOW) // set high temperature. If temp exceeds this value, activate alarm
  {

    // clear display and turn on red LED to indicate user is setting lower boundary
    rtcshield.clear();
    digitalWrite(4, HIGH); // turn on red LED
    rtcshield.num(highTemp);

    // user can press buttons K2 and K1 to decrease/increase upper boundary.
    // once user presses button K3, upper boundary is locked in and unit goes
    // back to normal state

    while (digitalRead(11) != LOW)
      // repeat the following code until the user presses button K3
    {
      if (digitalRead(10) == LOW) // if button K2 pressed
      {
        --highTemp; // subtract one from upper boundary
        // display new value. If this falls below zero, won't display. You can add checks for this yourself :)
        rtcshield.num(highTemp);
      }
      if (digitalRead(9) == LOW) // if button K3 pressed
      {
        highTemp++; // add one to upper boundary
        // display new value. If this exceeds 9999, won't display. You can add checks for this yourself :)
        rtcshield.num(highTemp);
      }
      delay(300); // for switch debounce
    }
    digitalWrite(4, LOW); // turn off red LED
  }
}

Operating instructions:

  • To set lower temperature, – press button K2. Blue LED turns on. Use buttons K2 and K1 to select temperature, then press K3 to lock it in. Blue LED turns off.
  • To set upper temperature – press button K1. Red LED turns on. Use buttons K2 and K1 to select temperature, then press K3 to lock it in. Red LED turns off.
  • If temperature drops below lower or exceeds upper temperature, the blue or red LED will come on.
  • You can have the buzzer sound when the alarm activates – to do this, press K3. When the buzzer mode is on, LED D4 will be on. You can turn buzzer off after it activates by pressing K3.
  • Display will show ambient temperature during normal operation.

You can see this in action via the video below:

Conclusion

This is a fun and useful shield – especially for beginners. It offers a lot of fun and options without any difficult coding or soldering – it’s easy to find success with the shield and increase your motivation to learn more and make more.

You can be serious with a clock, or annoy people with the buzzer. And at the time of writing you can have one for US$14.95, delivered. So go forth and create something.

A little research has shown that this shield was based from a product by Seeed, who discontinued it from sale. I’d like to thank them for the library.

This post brought to you by pmdway.com – everything for makers and electronics enthusiasts, with free delivery worldwide.

To keep up to date with new posts at tronixstuff.com, please subscribe to the mailing list in the box on the right, or follow us on twitter @tronixstuff.