In the opening phase, each player develops and sets up their pieces. In the middlegame, they plan attacks, execute different tactics and strategies to gain an advantage and weaken their opponent. In the endgame, there are usually few pieces left on the board, and each player tries to win using certain techniques and piece coordination.

In this handbook, you'll learn about opening traps for the Italian Game, which is one of the most played openings in chess.

When learning about openings, you're usually taught some basic principles, like:

• Control and fight for the center.

• Develop pieces.

• Castle the king early.

• Connect the rooks.

• Don’t bring the queen out early.

• Avoid unnecessary pawn moves, and so on.

These principles are easier said than done. Many beginners focus too much on implementing them and fall for obvious traps. That’s what this handbook will help you with.

Learning about an opening is as important as learning the common mistakes associated with each opening. You can learn a chess opening to improve your tactics and strategy, understand how to develop your pieces, and understand how to spot certain mistakes early so you can avoid them or take advantage of them.

This handbook will focus on those opening mistakes and how to take advantage of them when playing as white.

You can watch the video version of this handbook here:

Table of Contents

• How to Use this Handbook

• What this Handbook Will Teach You

• What this Handbook Will Not Teach You

• Traps

• The Italian Game

• How to Create Traps in the Italian Game

• Game #1 - Giuoco Piano

• Game #2

• Game #3 - Legal's Mate

• Game #4

• Game #5 - The Fried Liver Attack

• Game #6 - Anti-Fried Liver Defence

• Conclusion

How to Use this Handbook

This handbook makes use of notations and images. If you understand chess notations, then you can follow along without relying on the images. If you're new to notations, I'd recommend reading the What are Notations in Chess? chapter of this handbook.

In order to follow along, you should have a board with you. You can use either a physical board or an online chessboard. You can use Lichess for your online chessboard. Under the Tools section, you should see a couple of board related tools that you can make use of.

I would not recommend reading through without practicing. The best way to understand certain concepts is to try them out yourself.

And remember, improving in chess takes time and effort, so don't feel bad if you don't automatically start seeing gains. Focus on understanding and practicing first, and if you're doing that the right way, you'll gradually start progressing.

What This Handbook Will Teach You

This handbook will teach you some opening traps when playing the Italian Game as white. The overall purpose is for you to see common opening mistakes and how to take advantage of them. Even though you'll play as white in this case, you'll also learn why your opponents fall for these tricks, and that should help you avoid them when playing as black.

So, this is not an Italian Game opening handbook where we'll analyze lengthy games from start to finish. This is solely for beginners who want to understand why certain traps occur occasionally and why they always fall for them. You can learn something useful with this handbook irrespective of the color you play as.

What This Handbook Will Not Teach You

This handbook will not teach you how to follow basic opening principles to a tee. Sometimes, in order to win early and gain an advantage early in the game, you have to play unconventionally. These unconventional moves may prevent you from following certain principles.

You’ll not learn deeply about piece placement or pawn structure. These concepts are part of this handbook but we won’t focus much on them.

This guide will also not make reference to popular or model games. That is, won’t not make use of or analyze games that have been played by masters in the past. So, I won’t be explaining key moments from specific games.

Traps

Chess isn't scripted, so if you rely on your opponent to fall for certain tricks because you played the "right" moves from a course, then you may lose a lot of games. The traps here should not be seen as a conventional way of playing openings. It's important that you understand the concept behind the moves, as this will help you adjust your gameplay against anyone who knows how not to fall for traps.

In summary, don't memorize lines to use against opponents. Understand the concept and strategies first. Doing that will help you improve your tactics/strategy, and make it easier to spot similar positions in different games.

Let's get started!

The Italian Game

The Italian Game is a very popular chess opening used by players across all levels of chess. The opening allows you to quickly develop your pieces and move them to active positions, and gain control of the center.

The Italian Game starts with these lines:

1. e4 e5

2. Nf3

Bringing the knight to f3 attacks the pawn on e5, which leads to black playing:

2. ... Nc6

This defends the e5 pawn.

3. Bc4

Finally, the bishop is moved the c4, and here's what the position looks like:

When you reach the position in the image above, you've entered the Italian Game opening. Let's analyze white's position.

White has developed two minor pieces and a pawn, and has made way for castling and protecting the king early in the game. White is not wining yet, but that could quickly change depending on what black plays.

3. ... Bc5

This position leads to a variation of the Italian Game known as Giuoco Piano, and it’s played very often. In fact, it’s the most played variation of the Italian Game. We’ll start with that variation in the next section.

How to Create Traps in the Italian Game

In this section, you'll learn some common traps for the Italian Game. We'll start with the Giuoco Piano variation.

Game #1 - Giuoco Piano

Here's the starting position of the Giuoco Piano variation:

4. c3

Moving the pawn to c3 provides support for the d-file pawn, which can threaten the bishop on c5 and gain control of the center.

4. ... Nf6

With that, the black knight threatens to capture the pawn on e4 and clears the way for castling.

Here's our current position:

What should you play here? Well, this section is about tricks. The safest move here would be d3 – this keeps things balanced, protects the e-pawn, and allows you to continue developing your pieces. But we're not going for a balanced or safe development.

5. d4

This move forces black to capture on d4. If black chooses to move the bishop to a different square like Bb6, then we'll have something like 6. dxe5 Ng4, 7. Bxf7+ Kxf7, 8. Ng5+ Ke8. Black can't castle at the moment, as white is trying to gain more control of the center and can easily start attacking from the kingside. So retreating with the bishop isn't a good move for black. Although black can move the bishop to other squares and have a different outcome, white still gains an advantage.

5. ... exd4

6. cxd4

That brings us to this position:

Again, retreating with the bishop puts black at a disadvantage. For example, 6. ...Bb6, 6. ...Bd6, or 6. ...Be7 will simply allow white to start attacking with the pawns in the center of the board. The worst move here would be 6. ...Bf8, which both blocks black from castling and allows white to start attacking from the center.

The best move for black would be to check the king:

6. ... Bb4+

This is a crucial point for the trap. The safest move here is 7. Nd2. This protects the king and keeps the game balanced. But again, we're not playing it safe this time.

7. Nc3

Let's look at the position visually:

This position gives black a slight advantage. In order to set the perfect trap for your opponent, you may have to sacrifice some of your pieces and give them some false advantage. This doesn't mean that every trap will work – so make sure to evaluate your position well before taking chances.

With Nc3, white gives up the e4 pawn. This position is known as the Greco's Gambit. The main purpose of the move is to lure your opponent into capturing the e4 pawn with its knight.

7. ... Nxe4

This is a common response. Without getting rid of that pawn, white can start attacking with the pawns and make black's opening a bit difficult. So how do you respond? Remember, we're playing a gambit, which involves sacrificing a piece, usually a pawn, in the beginning of the game in order to gain an advantage.

Since black has accepted the gambit by capturing that pawn, we can continue with the plan.

8. O-O

Now that the king has been safely castled, a couple of things have changed:

The knight on c3 is no longer pinned to the king, and if black castles, it'll lose the e4-knight. The best move here for black is to capture with the bishop. This is something you should always remember when playing as black in this position. White starts gaining some advantage if black captures with the knight, and that's what we'll use to learn about the trap here.

8. ... Nxc3

9. bxc3 Bxc3

We've managed to lure black into the trap by sacrificing more pieces. Black is threatening the a1-rook, but we're not going to try and save it. Since the purpose of a gambit is to gain advantage, we must capitalize on doing just that. If you try saving the a1-rook, then black will simply castle and you'd be in a slightly losing position.

10. Ba3

This prevents black from castling the king. Here's what the current position looks like:

White already has more advantage in this position and is giving up the a1-rook. If black decides to block the a3-bishop with 10. ...d6, then black would lose its bishop after 11. Rc1 Ba5 12. Qa4 Bd7 13. d5 Nd4 14. Qxa5. This is another variation you can learn, in case black doesn't capture the bishop. But don't rely on these to always work – you're better off understanding the strategy behind these attacks than trying to replicate them all the time.

10. ... Bxa1

This is the moment we've been waiting for all along.

11. Re1+

Black can only defend the king with the knight or the queen. Neither of those moves will make black's position any better. Naturally, defending with the knight would be the first option (although I would suggest resigning if you're playing as black in this position against a player who knows what they're doing).

11. ... Ne7

As white, you can either play 12. Bxe7 or 12. Rxe7. The former would lead to a black losing its queen after 12. ...Qxe7, 13. Rxe7+.

12. Rxe7

The best option for black would be to lose the queen by capturing the e7-rook. Not that it gives black any sort of advantage, but it's better than moving the king to f8. If your opponent plays 12. ...Qxe7, then you can capture the queen with Bxe7, forcing the king to capture back on e7. At that point, your trap would have served its purpose: you've taken your opponent's queen, delayed their opening development, and their king can no longer castle. For you, your king is safe and you have enough minor pieces and your queen to win the game.

12. ... Kf8

Here's our current position:

The light squared bishop has been sitting on c4 since the game started. It's finally time for it to join and support the attack.

13. Rf7+

White checks the black king, forcing it back to e8. The king cannot capture the rook because it’s protected by the bishop on c4. No matter what black plays at this point, the game will end in two moves. If black plays:

13. ... Kg8

Then the game ends with a double check:

14. Rf8#

If black plays this instead:

13. ... Ke8

Then white can respond with a check, forcing the game to end:

14. Qe1+ Qe7

15. Qxe7#

This game showed how placing your pieces on certain squares can help you gain an advantage later in the game. For example, white's light squared bishop seemed insignificant until it was needed to end the game. Placing the bishop on c4 is where the Italian Game starts and that bishop can become very troublesome for your opponents if they don't defend properly.

Here's a replay of the moves, along with the notations:

1. e4 e5

2. Nf3 Nc6

3. Bc4 Bc5

4. c3 Nf6

5. d4 exd4

6. cxd4 Bb4+

7. Nc3 Nxe4

8. O-O Nxc3

9. bxc3 Bxc3

10. Ba3 Bxa1

11. Re1+ Ne7

12. Rxe7+ Kf8

13. Rxf7+ Ke8

14. Qe1+ Qe7

15. Qxe7#

Game #2

Here's our starting position again:

1. e4 e5

2. Nf3 Nc6

3. Bc4 Bc5

4. Nc3 Nf6

5. d3 d6

6. Bg5

Nothing much has happened here. Both sides have focused on developing their pieces so far and the game is still balanced. Here's our current position:

The common move here for black is usually h6, and that is probably the best move. Most players don’t want to worry about the bishop pin when they want to move the queen or the f6-knight, so it's usually a good idea for them to start pushing the bishop away.

6. ... h6

7. Bf6

With this move, white forces the black queen to capture on f6:

7. ... Qxf6

Now white can start setting a trap. Here's the current position of the board:

8. Nd5

This forces the queen back to d8. If the queen moves to e6, it'll be forked with 9. Nc7+. If the queen moves to g6 in order to put pressure on the kingside, the knight can fork the king and rook on c7 as well. So the best move for white would be moving back to d8.

8. ... Qd8

9. c3

Now white is trying to take more control of the center.

9. ... Be6

Black attempts to add pressure in the center while developing a minor piece. But this move allows white to move on with some traps. It’s not very evident to see with the current position:

10. d4 exd4

11. cxd4

Black can play a couple of moves here, but none of them really leads to an advantage. If black plays 11. ...Bb4+, then you'd have something like 12. Nxb4 Bxc4 13. Nxc6 bxc6 14. Qc2 Be6 15. Qxc6+ Bd7 16. Qc3. White comes out of the situation with more control of the center and a pawn up. This is the safest route for black. The alternatives, as you'll see in the following moves, will lead to black losing at least one minor piece.

Here's our current position (we'll revert back to this position to see other variations for the traps later):

Variation #1

11. ... Bb6

The bishop retreats to avoid getting captured by the d4-pawn, but this is a blunder.

12. Nxb6

Now black is down a piece. If black plays Bxc4, then the b6-knight will simply capture on c4. So black is forced to take the b6-knight. The reality is that, no matter what black plays in this position, it's going to be down by at least one minor piece.

12. ... axb6

13. d5

Here's our current position:

If black chooses to move either the knight or bishop away from the pawn fork, then it'll lose the other. But the knight can attack on a5, right? Well, let's see how that pans out for black.

13. ... Na5

14. Bd3

Now, can black safely move the bishop away and save both pieces that were under threat? Unfortunately, the knight is now trapped. So, right from when the pawn fork happened, one piece was "destined" to leave the board.

14. ... Bg4

15. b4

Now, no matter what black plays next, the a5-knight will be captured. Here's the position:

That concludes things for this variation of the trap. Here's a replay of the first variation of the trap and the notations:

1. e4 e5

2. Nf3 Nc6

3. Bc4 Bc5

4. Nc3 Nf6

5. d3 d6

6. Bg5 h6

7. Bxf6 Qxf6

8. Nd5 Qd8

9. c3 Be6

10. d4 exd4

11. cxd4 Bb6

12. Nxb6 axb6

13. d5 Na5Bd3 Bg4

14. b4

Variation #2

Now, let's go back to the position that started the first variation:

If black decides to capture the d5-knight, here's what will happen:

11. ... Bxd5

12. exd5

Which brings us to this position:

Two of white's minor pieces are now under attack and one will eventually be captured. If black plays:

12. ... Bb4+

Then you'll have something like this:

13. Kf1 Ne7

14. Qa4+ Qd7

15. Qxb4

Black ends up losing the bishop. Here's a replay of the moves above, along with the notations:

1. e4 e5

2. Nf3 Nc6

3. Bc4 Bc5

4. Nc3 Nf6

5. d3 d6

6. Bg5 h6

7. Bxf6 Qxf6

8. Nd5 Qd8

9. c3 Be6

10. d4 exd4

11. cxd4 Bxd5

12. exd5 Bb4+

13. Kf1 Ne7

14. Qa4+ Qd7

15. Qxb4

Game #3 – Legal's Mate

The Legal Trap is one that allows you to capitalize on your opponent's mistakes in the opening phase of the game. With this trap, the game ends after eight moves.

Note that the trap may not work against intermediate players. Most of the moves that lead up to the mate are all bad moves and you won’t often see that many bad moves in row.

As usual, here's the starting position of the Italian Game:

1. e4 e5

2. Nf3 Nc6

3. Bc4

3. ... d6

This is black's first bad move. The d6-pawn now prevents the development of the dark squared bishop. Beginners often make this mistake because they want to strengthen the support on the e-pawn and use the light squared bishop to pin white's knight.

4. Nc3 Bg4

Here's the position so far:

Black pins the white knight and can decide to put more pressure by bringing the knight to d4 next.

5. h3

White attempts to push the bishop back. In this position, moving the bishop back to e6 would be best for black. But most beginners would want to maintain the pin on the knight.

5. ... Bh5

Black moves back but continues pinning the knight. This is where white attempts to end the game by giving up the queen.

6. Nxe5

Here's the current position:

6. ... Bxd1

Black goes for the queen without seeing white's plan.

7. Bxf7+ Ke7

8. Nd5#

The game ends in eight moves.

This is not a checkmate pattern you'll see often, but it's important to understand how it works. Positions like this can appear at any time, so you should focus more on understanding why the pieces were moved to certain squares instead of memorizing the lines.

I know I’ve mentioned this before, but it's crucial to repeat it here because if you try to use the Legal's Mate as your main strategy from the beginning of the game, then you'll most likely encounter difficulties.

Here’s a replay of the move, along with the notations:

1. e4 e5

2. Nf3 Nc6

3. Bc4 d6

4. Nc3 Bg4

5. h3 Bh5

6. Nxe5 Bxd1

7. Bxf7+ Ke7

8. Nd5#

Game #4

This particular trap is one that many beginners fall for. The aim is to allow your opponent to think they're getting a free pawn, but then they either lose the game or a minor piece.

1. e4 e5

2. Nf3 Nc6

3. Bc4 Bc5

4. c3 Nf6

5. d4 Bb6

In this case, black decides not to capture the d-pawn. That move gives white an advantage in the opening, because it can start attacking with the pawns in the center. Here's the current position:

6. dxe5

This move is where most beginner players mess up. They assume that the e4-pawn is up for grabs. The moment black captures that pawn, then the knight will be trapped. But it's not just that. Here:

6. ... Nxe4

7. Qd5

The queen move threatens a checkmate on f7 if black tries to saves the knight. There is really nowhere for that knight to go, so you're better off saving your king with 7. ...Qe7 if you're playing as black in this position.

Here's a replay of the moves, along with the notations:

1. e4 e5

2. Nf3 Nc6

3. Bc4 Bc5

4. c3 Nf6

5. d4 Bb6

6. dxe5 Nxe4

7. Qd5

Game #5 - The Fried Liver Attack

The Fried Liver Attack is one of the most common tricks played by beginners. Many amateur players fall for this trick because it creates tension at the beginning of the game.

Here's what the position of the Fried Liver Attack looks like:

1. e4 e5

2. Nf3 Nc6

3. Bc4 Nf6

4. Ng5

The most commonly played move here is d5. If you play anything else as black, then 5. Nxf7 will fork the queen and the rook.

4. … d5

And we have this position:

5. exd5 Nxd5

The 5. …Nxd5 play is one I wouldn’t recommend for most beginners playing as black. It can lead to some complicated situations.

6. Nxf7

Now black has no option other than to capture the f7-knight, which now prevents the king from castling later in the game. If black ignores the knight, then it’ll lose either its queen or rook.

6. … Kxf7

7. Qf3+

The problem now is that the king is being forced to move closer to the center of the board and protect the knight on d5. Remember, one of the opening principles in chess is to castle your king early, but black can no longer do that.

If black decides to move the king backwards, let’s say 7. …Kg8, then the game will end in three moves: Bxd5+ Qxd5 9. Qxd5+ Be6 10. Qxe6#. If black moves to e8 instead, then white can capture the knight on d5 and black still wouldn’t be able to castle.

7. … Ke6

This is not a completely losing position for black, but it’ll be easier for white to put more pressure on the king, and if black doesn’t play very well, the game could end. With the king in the center, white can add more pieces to the attack:

8. Nc3

The knight now threatens the black knight as well.

8. … Nb4

9. O-O c6

Here’s the current position:

As you can see, white has more advantage: the black king can no longer castle and is close to the center of the board. The white king has castled and is safe, and white can focus on developing its pieces while black has to find a way to prevent a checkmate or losing the knights.

It’s still possible for black to win in the situation, but this can become very complicated, especially for beginners.

Here’s a replay of the moves, along with the notations:

1. e4 e5

2. Nf3 Nc6

3. Bc4 Nf6

4. Ng5 d5

5. exd5 Nxd5

6. Nxf7 Kxf7

7. Qf3+ Ke6

8. Nc3 Nb4

9. O-O c6

Game #6 - Anti-Fried Liver Defence

From our last game, here’s the setup for the Fried Liver Attack:

1. e4 e5

2. Nf3 Nc6

3. Bc4 Nf6

4. Ng5

Since many beginners struggle with the tension created from the Fried Liver Attack, they try to avoid it completely from the beginning of the game. So, some might play h6 as their third move to prevent the white knight from moving to the g5 square. That is:

1. e4 e5

2. Nf3 Nc6

3. Bc4 h6

Which leads to this position:

4. d4 exd4

5. Nxd4

This is where white sets the trap. Black should continue developing minor pieces and castle the king. A move like 5. ...Nf6 would work for black. But some people may want to double the attack on the d4-knight in order to push it back:

5. ... Bc5

6. Bxf7+ Kxf7

7. Qh5+ Kf8

8. Qxc5+

With these moves, black no longer has the option of castling and the kingside looks weaker.

Here's a replay and the notations:

1. e4 e5

2. Nf3 Nc6

3. Bc4 h6

4. d4 exd4

5. Nxd4 Bc5

6. Bxf7+ Kxf7

7. Qh5+ Kf8

8. Qxc5+

Conclusion

This handbook showed you some of the most common beginner traps for the Italian Game. Although we saw most of the traps from the perspective of white, it can also help you defend against them when playing as black.

Opening moves in chess can be quite tricky. You may decide to stick with opening principles by developing your pieces, trying to control the center, and castling early. But, along the way, you may miss obvious mistakes and fall for your opponent’s traps.

You shouldn’t learn chess openings in order to replicate everything you see in various courses. Instead, you should try and understand why certain moves were made and their outcome. That way, you can improve your tactics and strategy and be able to recognize similar positions in other games.

I hope this handbook has been helpful for you on your chess journey. You can find me on Lichess @ IHECHIKARA.

You can watch the video version of this handbook here.

You can learn about checkmate patterns in chess here.

In this handbook, we’ll focus on endgame fundamentals. You’ll learn about some common checkmate patterns for beginners and how you can recognize these patterns more easily to increase your chances of winning.

This handbook is not for absolute beginners. You should understand these concepts before proceeding:

• How to identify each chess piece.

• How to set up a chess board.

• How each piece moves.

• Some basic chess terms like "capture", "castling", "check", "checkmate", "piece promotion", "fork", "pin", and so on.

If you're new to chess, or you're not yet familiar with the prerequisites, then this free resource is a good place to start.

In the first chapter, you'll learn about algebraic chess notations. You’ll learn about files and ranks, how to identify and denote each square on a board, and how to record chess moves using algebraic chess notations.

In the second chapter, you’ll learn about some checkmate patterns like queen and king vs king, two rooks vs king, opera mate, Anastasia’s mate, and so on.

I've provided some exercises in different sections to help you practice. You can find the answers to each exercise at the end of the handbook.

I’ve also included some practice positions for each endgame pattern. To use them, click on the link provided for each exercise, then click on “CONTINUE FROM HERE” in the options at the bottom-right of the page. That is:

This will let you practice the positions against an engine. The engine has varying levels of strength, so you should try beating each level. You can find links for all the practice positions at the end of the article. You can also use the board editor from the links to set up your own positions.

You can watch the video version of this handbook here:

Table of Contents

1. How to Use this Handbook

2. Chapter 1: What are Notations in Chess? Algebraic Chess Notation Explained

   • What are Chess Notations?

   • What is Algebraic Chess Notation?

   • What are Chess Notations Used For?

   • How to Write Algebraic Chess Notations

   • How to Identify Squares on a Chess Board

3. Chapter 2: Checkmate Patterns for Beginners

   • What is a Check and Checkmate in Chess?

   • Checkmate Patterns

   • Checkmate Patterns II

4. Conclusion

5. Exercise Answers

6. Practice Position URLs

How to Use this Handbook

This handbook is not meant to be read and understood just once. If you're a beginner, then chances are high that you'll reference it multiple times in order to understand certain concepts.

In order to get the best out of this resource, you'll need a chess board. You can use either a physical board or an online chessboard. I recommend using Lichess if you're going to use the latter option.

You should try and replicate the moves as you read. Remember, you're not meant to understand everything the first time you read it, so it’s totally fine to go over one concept again and again.

Chess books can be boring, but don't let that hinder your progress. It gets interesting when you're able to understand, practice, and see improvements from what you've learned.

Let's get started!

Chapter 1: What are Notations in Chess? Algebraic Chess Notation Explained

You can use chess notations to record chess moves, and this handbook will rely heavily on them to teach you difference concepts about chess as a beginner. The first time you learn about writing or reading notations may seem overwhelming, but don't worry – with constant practice and studying, you'll get the hang of it.

What are Chess Notations?

To put it simply, chess notation is a method of recording moves in a chess game. In a physical chess game, it usually involves two players writing down moves as they’re played.

While there are other forms of chess notations like descriptive, coordinate, numeric, and so on, we'll focus primarily on algebraic chess notation.

What is Algebraic Chess Notation?

Algebraic chess notation is the standard way of recording chess. Each notation shows the move number, the piece moved, and the position of the board where the piece was moved to. In some cases, the notations also show an action being performed, like a check, a checkmate, castling, and so on.

For example:

1. e4 d5

2. d4 dxe4

3. Nc3 e6

These may look strange if it's your first time looking at notations. But don't worry, you'll understand how to write and read/interpret them as we progress.

In online games, they're recorded automatically:

The image above shows a chess game played on lichess.org. On the right side of the image, you can see the notations of the game as each move was played, along with numbers corresponding with the moves. We'll talk more about the numbers later.

Now that you know what notations are, let's talk about why they're needed.

What are Chess Notations Used For?

Here are some of the uses of chess notations:

Competitive/Professional Chess

Algebraic chess notation is the standard way of recording a chess game in tournaments. In over the board tournaments, each player is given a piece of paper with columns for writing each move played. Note that this involves recording their opponent's moves as well.

Studying and Teaching Chess

You can think of chess notations as the language of chess, and to learn about something, there has to be a way to pass and communicate information.

Communication

With chess notations, you can communicate moves and share games with players across the world without needing a physical board.

How to Write Algebraic Chess Notations

Algebraic chess notation makes use of the board coordinates and the pieces to denote moves.

Let's start with the coordinates:

The image above shows a chess board without the pieces. On the right edge of the board are numbers 1 to 8, and the bottom edge of the board has letters a to h. You can use these numbers and letters to refer to a particular position of the board.

Each vertical column (top to bottom) in a chess board is called a file, while each horizontal row (left to right) is called a rank. You can also associate them with the letters and numbers: the letters can be used to reference files, while the numbers can be used to reference ranks.

Files a to f

There are eight files in a chess board. Another way to say this is that, from top to bottom, there are eight vertical lines (stack of squares from top to bottom) in a chess board. Each vertical line is associated with a letter, which is usually written at the bottom edge of the board. That is:

To help you understand files, let's try and identify some of them separately. The image below shows the a-file:

We can tell that this is the a-file because the all the squares in that vertical column fall under the part of the board labelled "a". Remember that files go from top to bottom.

Here's another example:

This arrow runs from top to bottom, but on a different part of the board. To know what file this is, simply look the the letter associated with the vertical column. Using that, we can say that the arrow is on the the f-file.

Here's an exercise for you (you can find the answers to each exercise at the end of the handbook):

In the image above, using the letters on the board, what file is the arrow on?

Ranks 1 to 8

Just like files, we have eight ranks in a chess board. These are the eight horizontal lines (stack of squares from left to right) in a chess board. That is:

Let's identify some of the ranks separately.

Using the position of the arrow, you can tell the rank. The arrow run from left to right on the part of the board with the number 4, so we can say that it is on the fourth rank.

Here's another example:

You may confuse files and ranks here since you can see the letters at the bottom. Remember, we're dealing with ranks here, and they go from left to right, not top to bottom. From left to right, in the image above, we can see the letter 1. So the arrow is on the first rank.

Here's an exercise for you:

In the image above, using the numbers on the board, what rank is the arrow on?

How to Identify Squares on a Chess Board

Now that you know what files and ranks are in chess, let's see how you can use them to identify a square. Identifying a square is important when writing notations. Each notation is made up of the move number, the piece moved, and the coordinate. In the case, a coordinate is the combination of a file and a rank.

Let's start with this image:

In the image above, we have a circle on a random square. The goal here is to identify that square, that is, to refer to it as "something".

To identify the square, you have to trace its file and the rank. Let' start with the file.

Using the arrow, we can see that the circle falls under the e-file. Next, let's trace the rank.

Great! We can tell that the circle is on the fifth rank.

So we can say that we have a circle on the e-file and the fifth rank. Using notations, you can write it as e5.

In the next example, we'll identify the position of chess pieces. In order to do that, you need to know the letters that represent each piece on a board:

King = K

Queen = Q

Rook = R

Bishop = B

Knight = N

Pawn = no letter (denoted by the square they move to).

In our last example, we identified the square as e5. If you replace that square with a chess piece, then the the notation would start with the letter of that piece, followed by its position on the board. Here's an example:

Now we have the queen on the e5 square. The notation will look like this: Qe5. This way of writing the letter of the piece, followed by the coordinate of the square applies to other pieces, except the pawns. For pawns, you only write the coordinate.

If you had a rook on e5, the notation would be Re5, Ke5 for a king, Ne5 for a knight, Be5 for a bishop, and e5 for a pawn.

How to Write Algebraic Chess Notations

We stated earlier that algebraic chess notations show the move number, the piece moved, and the position of the board where the piece is moved to. In our examples, you've seen how to write the piece moved, and where it was moved to using coordinate (files and ranks). In the examples for this section, we'll add the move number to complete the algebraic chess notation.

By move number, we simply mean the turn count. Each move number is associated with one White and one Black move. For instance, the first move of the game will have a move number of 1. Let's look at some examples.

Each piece on the board is in its starting position. Let's make the first move for White:

White has moved a pawn to e4. To record this, you'd start with the move number, followed by the piece and coordinate. That is:

1. e4

Next, Black's move.

Black responded by moving a pawn to e4. Since this is Black's first move, it'll also be recorded under move number 1:

1. e4 e5

If you look at the algebraic notation above, you can see that both notations are written on the same line, and are both associated with move number 1. To interpret this, the first coordinate belongs to White, while the second belongs to Black.

To make this even clearer, let's continue the game. It's White's turn to play.

The white knight was moved to f3, which can be denoted by Nf3. Since this is White's second move, it'll be recorded under move number 2:

1. e4 e5

2. Nf3

Now Black has to respond with a second move.

Black played Nc6 (knight to c6). Remember that this is the second move for Black, so it has to be recorded in move number 2, right after the notation for White's second move. So we'll have this:

1. e4 e5

2. Nf3 Nc6

This system of recording chess moves is known as algebraic chess notation. Here's a summary of how it works:

• You write the move number.

• You write piece moved (omitted for pawns).

• You write the coordinate (file and rank) that the piece moved to.

With this information, you can easily read and write chess notations! But we're not done yet. How do you write checks, checkmates, castling, and pawn promotions?

How to Write a Check Notation in Algebraic Chess Notations

You can use the + symbol to denote a check. This comes after the move notation. That is, you write the notation as you would for any other move, and then add the + symbol at the end. Here's an example:

Here, the queen moves to e7 to check the king. So the notation would be Qe7+. The + at the end denotes the check by the queen. If you write it as Qe7, without the check symbol, then you'd have an inaccurate notation of the move.

How to Write a Checkmate Notation in Algebraic Chess Notations

A checkmate is denoted by the # symbol. It also comes after the move notation. That is, you write the notation as you would for any other move, and then add the # symbol at the end. Here's an example:

In the image above, the rook moved to g8 to win the game. The notation would be Rg8#. The # symbol denotes the checkmate.

How to Write a Castling Notation in Algebraic Chess Notations

In a chess game, castling can either be to the kingside or queenside. Kingside castling is denoted using O-O, while queenside castling is denoted using O-O-O. Note that the symbol is not a zero. Rather, it's an O, as in orange.

How to Write a Capture Move in Algebraic Chess Notations

Capture moves are denoted using the x symbol. Here are some different variations:

• Qxg6 means that the queen captured a piece on g6.

• Qxg6+ means that the queen captured a piece on g6 and checked the king.

• Qxg8# means that the queen captured a piece on g8 and checkmated the king.

• dxe4 mean that a pawn captured a piece on e4.

In a case where you have two pieces that can move to the same square, you have to include the file of the piece that was moved. Here's an example:

In the board above, we have two knights: one on the f-file and another on the h-file. Both knights can capture the rook on g8, and it may be confusing for someone reading your notations if you don't specify which knight was moved.

To denote this, you have to add the file from where the knight was moved in your notation. So, if you capture with the knight on the f-file, you'd have Nfxg8 (knight on f-file captured a piece on g8). On the other hand, capturing with the knight on the h-file will result to a notation like this: Khxg8.

This is not only specific to capturing pieces. If you have two knights that can move to the same square, then you'd have to include the previous file of whichever knight that is moved. So, assuming that we didn't have a rook to capture on g8, you'd have Nfg8 to denote that the knight on f-file moved to g8, and Nhg8 to denote that the knight on the h-file moved to g8.

How to Denote Piece Promotion in Algebraic Chess Notations

You can use the = symbol to denote the promotion of a pawn. That is:

• e8=Q means that pawn moved to e8 and got promoted to a queen.

• e8=Q+ means that pawn moved to e8, got promoted to queen, and checked the king.

• e8=Q# means that pawn moved to e8, got promoted to queen, and checkmated the king.

• e8=N means that pawn moved to e8 and got promoted to a knight.

Here are two exercises for you:

• How do you write the notation if a pawn moves to d1 and gets promoted to a rook?

• How do you write the notation if a pawn moves to b8 and gets promoted to a bishop?

And here's the main exercise for this chapter. Show the final board position using these notations:

1. e4 e5

2. Nf3 Nc6

3. Bb5 Nf6

4. O-O Nxe4

5. Re1 Nd6

6. Nxe5 Be7

7. Bf1 Nxe5

8. Rxe5 O-O

9. d4 Bf6

10. Re1 Re8

11. c3 Rxe1

12. Qxe1 Nf5

13. Bf4 d6

14. a4 Qe7

15. Na3 g5

16. Bd2 Qxe1

17. Rxe1 Bd7

18. a5 Kg7

Chapter 2: Checkmate Patterns for Beginners

Before we look at the common checkmate patterns, let's talk a bit about what a check means. We'll do this using the attack pattern or capture method of the pieces.

What is a Check and Checkmate in Chess?

The main goal of a standard chess match is to capture your opponent's king. You can do this in multiple ways, with different combinations of pieces.

A check is simply an attack on a king. When the king is in check, it must move to a safe square. A safe square for a king in chess is a square where the king is not under attack.

This is an example of a check:

The king in the image above is being threatened by the queen. You can deliver checks based on how a piece moves and captures other pieces. A rook can deliver a check like this:

A bishop can deliver a check like this:

Same applies to the knights and pawns – they can check the king based on their movement and mode of attack.

So what is a checkmate? Well, a checkmate happens when the opponent's king has no safe squares to move to after a check. This can be the result of the king being trapped by its own pieces, the king being unable to move to another square because its opponent has control of all the possible squares it can move to, or not having any piece to block the attack on the king.

In this sections that follow, you'll learn about different checkmate patterns using a combination of different pieces.

Checkmate Patterns

How to Play the Two Rooks vs King Checkmate Pattern

This endgame pattern usually involves two rooks against a king. It is one of the easiest checkmate patterns, but it's also easy to get carried away as a beginner. Here, you'll learn how to effectively mate and end a game with two rooks.

Consider this position:

White can end this game in six moves. Here are some things to keep in mind when you have a position like this:

• Restrict the opposing king's movement by cutting off squares where it can move to.

• Keep your rooks away from the opposing king or/and close to each other.

Let's see how each step works using the position above.

Restrict the King:

Looking at the initial position above, you can see that the king is on the f-file. Our goal here is to isolate the king and restrict its movement. One common move for beginners would be to check the king with Rf2+. But this allows the king to move closer to the rook on d4. That is:

While this is still a winning position, you'll spend more moves trying to restrict the king's movement. If you're playing a timed game, you may end up with a forced draw, losing a rook, or even losing the game, depending on the pieces on the board. This makes it important to know where and when to move your rooks.

So, back to the starting position:

1. Re2 Kf5.

Playing Re2 cuts off the e-file, meaning that the black king can no longer get on any square in that file. Since the king can not pass through or get on the e-file, it means that the a to e files have become inaccessible to it. It is now left with the f to h files.

The king responds with Kf5, an attempt to get closer and capture a rook. At this point, you'd want to stay away from the king.

Move Your Rooks Away From The King:

This is the current position:

Be careful not to play Re5+, confusing the d-rook for a supporting queen. This forces you into a one rook and king checkmate endgame (you'll learn about that in the next section) after Kxe5. This is a better move:

2. Rd8

Which brings us to this position:

This keeps your rooks far away from the black king. Since the king is limited to one square per move, it'll have a long way to go before getting close to either rook. And in the process of getting close, you can continue limiting which files it can get on.

The king has five possible moves here: Kf6, Kf4, Kg6, Kg5, Kg4. The only thing these moves have in common is that they lead to nowhere. But let's assume the black king has some sort of miracle to perform here.

2. ... Kg6

The king moving to g6 gives you the opportunity to occupy the f-file with:

3. Rf8

You have the f-file, but your rook is closer to the king:

3. ... Kg7

The king moves closer to challenge the rook. Unfortunately, a checkmate is still inevitable. At the point, you've not only restricted the files that the king can move to, you've also lured it all the way to the seventh rank.

Keep Your Rooks Closer to Each Other:

4. Rf1

With one rook on f1 and the other on e2, you're far away from the king and have both rooks closer to each other:

With this position, it will take the king at least four moves to get to your rooks.

4. ... Kg6

All that's left is to do now is keep pushing the king away from accessing other files:

5. Rg2+

Checking the king with the g-rook forces it to the h-file. Since you have a rook occupying the e-file, the king can’t go there.

5. ... Kh5

6. Rh1#

There are multiple ways to checkmate the king from the starting position, and in some cases, you may already have enough space to bring your rooks together and trap the king, instead of trying to restrict it to a part of the board first.

Consider this position:

The black king is already in a bad position. If you move the b-rook to b6, the game ends after Ra7+ and Rb8#. This did not require you to restrict the king.

Another thing to keep in mind is that your rooks must not always be close to each other to win games like this. Here's another position:

Here, the king is already limited to only the sixth and seventh rank, and you have enough squares/space between it and the rooks to win. There’s no need to avoid the king by moving one rook to a different part of the board.

Playing Rh7+ forces the king into the eighth rank and Ra8# checkmates the king.

You'll also notice that the white king did not participate in these moves. Its contribution was staying out of the way of the rooks. In some cases, the king can be helpful in delivering a checkmate. But if it'll block your rooks from restricting an enemy king, then you should keep your king away.

Here's a replay of the moves, along with the notations:

1. Re2 Kf5

2. Rd8 Kg6

3. Rf8 Kg7

4. Rf1 Kg6

5. Rg2+ Kh5

6. Rh1#

You can replicate them on your own if you weren't doing so already, and practice with the positions provided below.

Practice Position for Two Rooks vs King Endgame/Checkmate Pattern

You can practice what you've learned in the last section using this position:

I’ve set up the position for you here: https://lichess.org/editor/1r4k1/8/8/5r2/8/3K4/8/8_b_-_-_0_1?color=black. Click on the link, then click on “CONTINUE FROM HERE” to practice the position against an engine.

How to Play the King and Rook vs King Checkmate Pattern

Before we talk about how to win this game, you need to learn about the concept of "direct opposition". This happens when two kings are facing each other on the same file or rank, with exactly one square between them. That is:

The kings in the image above are facing each other, have one square between them, and are both on the d-file. Both kings are in direct opposition.

Here's another example:

The kings are still facing each other, they also have a square between them, but are now on the seventh rank. There are other forms of opposition like the diagonal and distant opposition, but we won't discuss them here.

So why does direct opposition matter in our current position? Well, let's look at how the king moves.

The black king, in the image above, can move to all the squares with a circle on them. Now, here's what happens when the king is in direct opposition with the other king.

Now the black king has lost the ability to move to three squares in the direction of the opposition. This also implies that the black king, using the position in the image above, no longer has access to the fourth rank. So playing Ra5+ forces the black king to move to the sixth rank, restricting it, and allowing the white king to come closer and set up another direct opposition.

This is one way of winning with a rook and a king. An alternative method is the box method, which we'll look at later in this section. Both techniques can be used together, but I think it would be helpful to learn them separately at first.

How to Use the Direct Opposition to Win with a Rook and a King

Here's our starting position:

1. Rb5+

Forcing the black king to the sixth rank.

1. ... Kd6

Now the king is trying to get closer and attack your rook, so you have to bring your own king closer for support.

2. Kd4 Ke6

Creating direct opposition. If the black king moves backwards (seventh rank), it loses the opportunity to pass through or be on the sixth rank. If it moves to c6, it'll have fewer squares to work with. So the best move for the black king would be Ke6.

Now we'll use something called the box method - a technique used when playing with a rook and a king to shrink the space where the opposing king can move in. This is the current position of the game:

3. Rd5

This move blocks the black king from moving to the d-file and forces it into a box that will gradually shrink if you make the right moves. Here:

The image above shows squares where the black king has been trapped in. The best move for the black king would be Kf6. Playing Ke7 or Kf7 would allow the white king to move closer. Remember, this is a lost position for black, but if you play against an opponent who wants to rely on luck to force a draw through a stalemate or timeout, then knowing exactly where to move your rook becomes very important.

Also, checks with the rook will do you no good in this position. If you check the king with Re5+, then the king will just escape to the d-file. So when you're this close to the opposing king:

3. ... Kf6

4. Re5 Kf7

5. Kd5 Kf6

The black king has gotten closer to your rook again. If you check it, it escapes through the fifth rank. When you have all three pieces in a similar position, move your king instead of a check. This forces the opposing king to remain boxed in.

6. Kd6 Kf7

7. Rf5+ Kg6

8. Ke6

Providing support to the rook and ensuring that the black king remains in a smaller space. This is what the box looks like now:

8. ... Kg7

9. Rg5+ Kh6

10. Kf6 Kh7

11. Rh5+ Kg8

12. Rh6 Kf8

13. Rh8#

Here are things to keep in mind when playing with a king and rook against a king:

• Cut off the enemy king with your rook.

• Bring your king closer to support the rook and push the enemy king.

• Shrink the box using the two points above.

• Force the king to the edge of the board (first rank, eight rank, a-file, h-file). Checkmate is only possible when the enemy king is at the edge of the board and in opposition with your king.

This can be overwhelming for beginners, so don't worry if you don't fully understand the process from start to finish. With constant practice, it should become easier and faster for you to recognize the patterns. I'll also provide some puzzles to help you practice.

Here's a replay of all the move and the notations:

1. Rb5+ Kd6

2. Kd4 Ke6

3. Rd5 Kf6

4. Re5 Kf7

5. Kd5 Kf6

6. Kd6 Kf7

7. Rf5+ Kg6

8. Ke6 Kg7

9. Rg5+ Kh6

10. Kf6 Kh7

11. Rh5+ Kg8

12. Rh6 Kf8

13. Rh8#

Practice Position for One Rook and King vs King Endgame/Checkmate Pattern

You can practice what you learned in the last section using this position:

I’ve set up the position for you here: https://lichess.org/editor/6k1/8/8/5r2/8/3K4/8/8_w_-_-_0_1?color=black. Click on the link, then click on “CONTINUE FROM HERE” to practice the position against an engine.

How to Play the Queen and King vs King Checkmate Pattern

We’ll start with this board:

There are a couple of ways to play endgame like the one in the image above. A lot of beginners struggle with this checkmate pattern because they often end in a stalemate or just chase the king around the board until they or their opponent runs out of time.

We can approach this endgame using the direct opposition and box method like we did in the previous section, but there's a more efficient and straightforward way of winning this position, with minimal effort from your king.

We'll use the knight move method. This implies that your queen should only move to squares that imitate a knight attack on the enemy king. Using this method, you can push the king towards the edge of the board.

Here are the possible squares where the queen can go to in order to imitate a knight attack:

Let's start with the closest square:

1. ... Qd6

This brings us to this position:

We've pushed the king into a box. Now, no matter what the king plays, try to follow up with moves that imitate a knight attack (the L), and do not play a move that allows the king leave the shrinking box.

2. Ke3 Qd5

The keeps the king in the box and brings the queen closer.

3. Ke2 Qd4

4. Kf3 Qe5

The box has gotten smaller:

No checks. No direct opposition. Just follow the king with the queen, as though you were playing as a knight.

5. Kf2 Qe4

6. Kg3 Qf5

7. Kg2 Qf4

8. Kg1 Qf3

9. Kh2 Qg4

10. Kh1

You've successfully pushed the king to the edge of the box. At this point, don't be in a hurry to play another knight attack move with the queen – this will lead to a stalemate.

The queen's job is almost done. The white king only has two squares to move to: h2 and h1. It time to push the black king forward to support the queen in a checkmate. Since you've trapped the white king, it will continue to move between the two possible squares until the black king arrives.

10. ... Ke7

11. Kh2 Kf6

12. Kh1 Kf5

13. Kh2 Kf4

14. Kh1 Kf3

15. Kh2 Qg2#

Here's a replay and all the notations:

1. ... Qd6

2. Ke3 Qd5

3. Ke2 Qd4

4. Kf3 Qe5

5. Kf2 Qe4

6. Kg3 Qf5

7. Kg2 Qf4

8. Kg1 Qf3

9. Kh2 Qg4

10. Kh1 Ke7

11. Kh2 Kf6

12. Kh1 Kf5

13. Kh2 Kf4

14. Kh1 Kf3

15. Kh2 Qg2#

Practice Position for Queen and King vs King Endgame/Checkmate Pattern

You can practice what you learned in the last section using this position:

I’ve set up the position for you here: https://lichess.org/editor/1r4k1/8/8/5r2/8/3K4/8/8_b_-_-_0_1?color=black. Click on the link, then click on “CONTINUE FROM HERE” to practice the position against an engine.

For this position, choose to play as black before starting the game:

Checkmate Patterns II

In this section, we’ll deal with checkmate patterns that can happen at any point. That is, you don't have to be in an endgame position/situation to play them.

In some cases, these positions can happen by chance, and in other cases, you have to plan and set them up yourself. The main objective here is to get used to recognizing patterns.

Opera Mate

An Opera Mate usually involves the following:

• A rook or queen delivering a check along a back rank or file.

• A bishop covering a diagonal escape square.

• A king trapped by its own pieces or the edge of the board.

Here's an example:

In the position above, black played Bg7, threatening the white rook. But if we look closely at the position, white can deliver a checkmate by moving to c8.

With Rc8#, the king can't capture the rook because the bishop is protecting it, the king can't move to d7 because the bishop is attacking that square, and unfortunately for the king, its own pawn is blocking it from escaping through e7.

Here's another position:

Let's assume that it's white's turn to play again. Would it still be checkmate if the rook moves to c8? Yes it would – the position hasn’t really changed: the bishop is still protecting the rook on c8 and attacking the d7 square, and the pawn on e7 is still blocking the king.

Let's look at an example from Lichess:

This game still looks alive, as though both players are still setting up their strategies. It's black's turn to play. At this point, we'll assume that black has discovered a possible opera mate.

The black bishop is attacking the d1 and e2 squares, while the queen can check the king on d1, with additional support from the rook on d8. But, a closer look will reveal something: white has a bishop protecting the d1 square.

So, do you go on to attack or play it safe and find a different strategy? Well, let's evaluate the position, keeping the d1 square in mind.

For black:

• Queen can attack d1.

• Rook can support and attack d1.

• Bishop can support d1.

For white:

• Bishop is protecting d1.

From this evaluation, you can see that black has a very good advantage. In order to win this game, you must sacrifice the queen. Beginners often avoid sacrifices because we learn chess with the idea that the most power pieces must stay on the board. In this case, it’s the only path to victory.

So:

1. ... Qd1+

That brings us to this position:

Black has two options here:

• Capture the queen with the bishop.

• Resign.

Let's go with capturing the queen.

2. Bxd1

And now, we have this position:

Remember the rook on d8?

2. ... Rxd1#

The rook captures the bishop and wins the game. The king can't capture the rook because it has support from the bishop on g4, it can't escape through e2 because the bishop is attacking that square, and the pawn on f2 is blocking the king.

This shows that you don't have to play until the endgame to win in chess. If you get better at recognizing patterns, you'd be shocked at how many chances you've missed to increase your advantage or win a game.

Anastasia's Mate

Anastasia's Mate is a checkmate pattern that involves a knight and a queen (or rook) working together to trap the opposing king. It involves the following:

• The rook or queen delivering a check.

• The knight blocking the king's escape squares (usually two escape squares).

• The opposing king trapped by its own pieces.

Consider this position:

From the look of things, white has a stronger position. That would be totally true if black didn't have a mate in two opportunity. When black plays Ne2+, it sets up the pattern for Anastasia's mate. That is:

The king has two possible squares to move to: h1 and h2.

1. ... Ne2+

2. Kh2

Is the king safe?

2. ... Rh5#

The game ends:

The e2 knight blocks the king from going to either g1 or g3, while the rook attacks the h-file. It's easy to miss this pattern for beginners, because we're often used to endgame patterns that involve more "offensive" attacks.

Here's another example from Lichess:

It's not very obvious that this position leads to an Anastasia's mate. You have a bishop attacking the queen, and the queen can capture it and gain more material advantage. But what happens when you sacrifice the queen by capturing the h7 square?

You've sacrificed the queen to force the king to the h7 square, setting it up for Rh5#.

So, even though you may recognize what the Anastasia's Mate looks like, you may have to intentionally lose some pieces to achieve it. This is also applicable to other aspects of chess. Sacrificing pieces can be a perfect way to force your opponent into dangerous situations.

Back Rank Mate

This is a checkmate pattern that you'll encounter a lot in your chess journey. It involves trapping the king behind the pieces in front of it. That is:

From the image above, you can see the white king trapped behind the three pawns in front of it. To avoid this, you should always remember to create space for your king at some point after castling.

Here's an example from Lichess:

It's white's turn to play, and the black king still has three pieces blocking it. The white queen and the rook are both attacking the e8 square, so you can force an exchange that ends the game:

1. Rxe8+ Rxe8

2. Qxe8#

After the trade, you'll have the queen on e8, forcing a checkmate because the king has nowhere to escape to.

Smothered Mate

The smothered mate is a checkmate pattern where a knight delivers mate to the enemy king, which is completely trapped/surrounded (or “smothered”) by its own pieces.

Here's what it looks like:

This is a checkmate pattern that shows how powerful the knight can be in endgames. With any other piece, it would be difficult for black to make any significant moves in this situation. But since the knight can jump over pieces when moving and attacking, it can be used in unpredictable ways.

Let's look at an example from Lichess:

Again, we'll be sacrificing a piece to gain an advantage. You can sacrifice the white queen with:

1. Qxh7+

This forces the black queen to capture:

1. ... Qxh7

The problem with this is that the king is now trapped:

As beginners, it's often easier to capture a powerful piece than to analyze a position for potential mate patterns. It wouldn’t be surprising to see someone new to chess capturing the queen with the knight.

The best move here is Nf7#:

The king is under check and can't escape because it has been trapped by its own pieces.

Conclusion

The handbook showed you some of the common checkmate patterns in chess. But these are not all of them, and not all checkmate patterns are easy to understand for beginners.

While you improve other aspects of your game like strategy and tactics, opening principles, solving puzzles, and so on, it becomes easier to understand certain concepts that seemed too hard at first.

One way to test your understanding of different concepts is by playing against other people or engines. A good place to do this is on Lichess. It’s free, has an active community, and a ton of tools to help you improve your game.

I hope this handbook has been helpful for you on your chess journey. You can find me on Lichess @ IHECHIKARA.

You can watch the video version of this handbook here.

Exercise Answers

Here are the answers to the exercises and practice positions:

Files a to f Exercise

The arrow is on the c-file. You can tell by looking at the alphabet that corresponds with the vertical line.

Ranks 1 to 8 Exercise

The arrow is on the eight rank. You can tell by looking at the number that corresponds with the horizontal line.

How to Denote Piece Promotion in Algebraic Chess Notation

• The notation for a pawn that moves to d1 and gets promoted to a rook is d1=R.

• The notation for a pawn that moves to b8 and gets promoted to a bishop d1=B.

• Here is the final board position for the given notations:

Practice Position URLs

Here are the links for all the practice positions:

• Two Rooks vs King Endgame/Checkmate Pattern URL: https://lichess.org/editor/1r4k1/8/8/5r2/8/3K4/8/8_b_-_-_0_1?color=black.

• One Rook and King vs King Endgame/Checkmate Pattern URL: https://lichess.org/editor/6k1/8/8/5r2/8/3K4/8/8_w_-_-_0_1?color=black.

• Queen and King vs King Endgame/Checkmate Pattern URL: https://lichess.org/editor/1r4k1/8/8/5r2/8/3K4/8/8_b_-_-_0_1?color=black (choose to play as black).

• Practice many checkmate patterns here: https://lichess.org/practice/checkmates/checkmate-patterns-i/fE4k21MW/9rd7XwOw. Click on “Practice list” to access more patterns.

In this article, you'll learn how to control LEDs using a switch case statement in Arduino. You can also find the switch case statement in other programming languages, so this can serve as a practical example of how they work.

Here’s a demo of what you’ll be building:

You can watch the video version of this article here:

Hardware Components

Here are the components you'll need to follow along:

• Arduino board (Uno).

• Potentiometer.

• Breadboard.

• Three LEDs.

• Resistors for the LEDs.

• Jumper wires.

How to Use a Switch Case Statement in Arduino

Here's the syntax/structure of a switch statement:

switch (variable) {
  case value1:
    // code to be executed if variable == value1
    break;
  case value2:
    // code to be executed if variable == value2
    break;
  default:
    // code to be executed if variable doesn't match any case
    break;
}

Let's break it down:

• variable: This denotes the variable being evaluated. The value of the variable determines how the code blocks will be executed.

• case: Each case represents a value that may match the variable being evaluated. If the variable and a case have the same value, the code for that case will be executed. You can have as many cases as you want.

• break: After a code block in a case has been executed, the break keyword terminates the code. That is, it stops the code from moving on to other cases because a match has already been found.

• default: In a situation where none of the cases match the variable, the code in the default block will be executed.

Next, let's use a switch statement to control LEDs.

Switch Case in Arduino Example

Circuit Diagram

Here’s how to connect your components:

The goal here is to decide which LED (or a combination of LEDs) comes on based on the value of a variable.

Potentiometer Connection

• Connect the left terminal of the potentiometer to 5V.

• Connect the right terminal to GND.

• Connect the middle terminal to A0.

LED Connection

• For each LED, connect the shorter leg to GND.

• Connect each longer leg to a digital pin. I recommend using pin 8 (for the green LED), 9 (for the yellow LED), and 10 (for the red LED) to match what we have in the circuit diagram. We'll also use these values in the code.

Here's the full project code:

int greenLED = 8;
int yellowLED = 9;
int redLED = 10;
int potPin = A0; 
int potValue;
int mappedPotValue;
​
void setup() {
  pinMode(greenLED, OUTPUT);
  pinMode(yellowLED, OUTPUT);
  pinMode(redLED, OUTPUT);
  Serial.begin(9600);
}
​
void loop() {
  potValue = analogRead(potPin);
  mappedPotValue = map(potValue, 0, 1023, 0, 5);
​
  switch (mappedPotValue) {
    case 0:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 1:
      digitalWrite(greenLED, HIGH);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 2:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, HIGH);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 3:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, HIGH);
      Serial.println(mappedPotValue);
      break;
    case 4:
      digitalWrite(greenLED, HIGH);
      digitalWrite(yellowLED, HIGH);
      digitalWrite(redLED, HIGH);
      Serial.println(mappedPotValue);
      delay(500);
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      delay(500);
      break;
  }
}

Let's break down the code.

Variable Initialization

int greenLED = 8;
int yellowLED = 9;
int redLED = 10;
int potPin = A0; 
int potValue;
int mappedPotValue;

We started by initializing variables to correspond with the hardware connections.

greenLED, yellowLED, and redLED have values of 8, 9, and 10, respectively. This matches the pins they were connected to on the Arduino board. Similarly, potPin, which is the variable for the potentiometer, has a value of A0.

You'll use the potValue variable to store the current value of the potentiometer. We also created a mappedPotValue variable to store the range of values needed for the LEDs in a minute.

pinMode and Serial Monitor

void setup() {
  pinMode(greenLED, OUTPUT);
  pinMode(yellowLED, OUTPUT);
  pinMode(redLED, OUTPUT);
  Serial.begin(9600);
}

In the setup() function, we set the LEDs as output pins and initialized the serial monitor.

Logic for switch case Statement

First, we read the value of the potentiometer using the analogRead() function and stored it in the potValue variable:

potValue = analogRead(potPin);

We then converted the values from the potentiometer to a range of 0 to 4 using the map function and stored them in the mappedPotValue variable:

mappedPotValue = map(potValue, 0, 1023, 0, 5);

Next, we created a switch statement—the value being evaluated is mappedPotValue. Recall that this is the variable where we stored the potentiometer values. So whenever you turn the potentiometer, the value changes and potentially matches a case:

  switch (mappedPotValue) {
    case 0:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 1:
      digitalWrite(greenLED, HIGH);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 2:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, HIGH);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 3:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, HIGH);
      Serial.println(mappedPotValue);
      break;
    case 4:
      digitalWrite(greenLED, HIGH);
      digitalWrite(yellowLED, HIGH);
      digitalWrite(redLED, HIGH);
      Serial.println(mappedPotValue);
      delay(500);
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      delay(500);
      break;
  }

We passed mappedPotValue as a parameter to switch since it's the variable being compared to different cases: switch (mappedPotValue).

• For case 0, all the LEDs will be off.

• For case 1, only the green LED comes on.

• For case 2, only the yellow LED comes on.

• For case 3, only the red LED comes on.

• For case 4, all three LEDs will blink continuously.

Using a switch statement, you've successfully controlled the behavior of LEDs based on the value of a potentiometer!

Conclusion

In this article, you learned how to use a switch case statement in Arduino using a practical example.

You learned how to control different LEDs based on the value of a potentiometer. You achieved this by using different cases in a switch statement to match the potentiometer's current value and execute the corresponding code.

switch statements can be used in different ways to make a project more dynamic. Some use cases in Arduino include:

• Managing and interpreting the different values, modes, and states of a component or sensor.

• Performing actions based on specific commands. For example, rotating a robotic arm to a specific angle/direction.

• Mapping button presses to user input, and so on.

You can watch the video version of this project here. The full project code is available on GitHub.

Check out my blog for articles about embedded systems, IoT, and web development.

Happy coding!

Here's what the mini project you'll build looks like:

In the image above, each button changes the background color of the page to a specific color.

You can get the starter files for the project here.

There are five buttons in the index.html file, and each of them changes the background color to a specific value:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="style.css">
    <title>Change BG Color With JS</title>
</head>
<body>
    <h1>Choose background color</h1>
    <button>Red</button>
    <button>Blue</button>
    <button>Green</button>
    <button>Yellow</button>
    <button>Reset</button>
​
    <script src="script.js"></script>
</body>
</html>
​

You won't be making any changes to the style.css file. Its purpose is to center the elements on the page and style the buttons to have the same size.

At the moment, nothing happens when you click on the buttons. Let's write the logic for that in the script.js file.

How to Change Background Color with JavaScript

To change the background color of an element with JavaScript, you can use the element's style property:

Here's how:

function setBgGreen() {
    document.body.style.backgroundColor = 'green';
}
​
function setBgRed() {
    document.body.style.backgroundColor = 'red';
}
​
function setBgBlue() {
    document.body.style.backgroundColor = 'blue';
}
​
function setBgYellow() {
    document.body.style.backgroundColor = 'yellow';
}
​
function defaultBgColor() {
    document.body.style.backgroundColor = 'white';
}

In the code above, we created five functions: setBgGreen(), setBgRed(), setBgBlue(), setBgYellow(), and defaultBgColor().

Each function has one thing in common: they all target the body. Through the body element (which represents the webpage), we accessed the style.backgroundColor property. The property returns or sets the background color of an element.

So:

• document.body.style.backgroundColor = 'green'; in the setBgGreen() function sets the background color of body to green.

• document.body.style.backgroundColor = 'red'; in the setBgRed() function sets the background color of body to red.

• document.body.style.backgroundColor = 'blue'; in the setBgBlue() function sets the background color of body to blue.

• document.body.style.backgroundColor = 'yellow'; in the setBgYellow() function sets the background color of body to yellow.

• document.body.style.backgroundColor = 'white'; in the defaultBgColor() function sets the background color of body to white.

Next, you'll assign each function to their respective button using the onclick attribute in your HTML file. This is what your index.html file should look like after that:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="style.css">
    <title>Change BG Color With JS</title>
</head>
<body>
    <h1>Choose background color</h1>
    <button onclick="setBgRed()">Red</button>
    <button onclick="setBgBlue()">Blue</button>
    <button onclick="setBgGreen()">Green</button>
    <button onclick="setBgYellow()">Yellow</button>
    <button onclick="defaultBgColor()">Reset</button>
​
    <script src="script.js"></script>
</body>
</html>

When you click the buttons, you should see the background color of the page change to the color assigned to the button.

Note that this is not only applicable to the body element. You can do this for specific parts of your page as well.

For a example, the background color of a div with an id of container can be changed using container.style.backgroundColor = "red" .

Conclusion

In this article, you learned how to change background color with JavaScript using an element's style property.

You can find the full project code here.

Happy coding!

Branches are used for different purposes like feature development, bug fixes, versioning, experimentation, contributing to open source projects, and so on.

In this article, you'll learn how to use different Git commands to interact with remote branches.

How to Fetch and List Remote Branches

I've created a repository (repo) for this article with three different branches: main, feat/create-hobbies-list, and feat/create-language-list. You can download the repo here, or clone it to your computer using this command:

git clone https://github.com/ihechikara/git-branches-article.git

The command above downloads the main branch of the repository to your computer.

Feel free to follow along with your own codebase/Git repo.

How to List Remote Branches

When you look at the repo you just cloned on GitHub, you'll notice that there are three branches.

But when you run the git branch command, you'll only get a list of branches in the local repo. In our case, that is the main branch. This happens for a couple of reasons:

• The git branch command only shows local branches.

• Cloning a branch doesn't automatically download all other branches in the remote repo.

So how do you list the remote branches? You can do that using the git branch -r command:

git branch -r

origin/HEAD -> origin/main
origin/feat/create-hobbies-list
origin/feat/create-language-list
origin/main

From the command output above, you can see all the branches in the remote repo. The main branch which also acts as the default branch (origin/HEAD), and two other branches: feat/create-hobbies-list and feat/create-language-list.

Now that you know how to list remote branches, let's see how to fetch and work on them locally.

How to Fetch Remote Branches

You can fetch remote branches for different reasons like code review, updating your local repo with changes made to the remote repo, experimentation, and so on.

How to Fetch Remote Branches Using git fetch

You can use the git fetch command to "fetch" recent changes made to the remote repo without merging them into your local repo.

For example, let's assume that new changes were pushed to the feat/create-language-list branch. When you run the git fetch command, Git retrieves the new changes in the remote repo but you won't see them in my local branch/repo.

You can then use commands like git diff and git log to compare the changes.

In a case where you're satisfied with the changes, you can use the git merge command to merge those changes into your local branch. At this point, the changes from the remote branch will be visible/seen locally.

That is:

git checkout feat/create-language-list

The command above switches to the feat/create-language-list branch.

git fetch

The command above retrieves current changes made to the remote branch that aren't in your local branch.

git diff feat/create-language-list origin/feat/create-language-list

The command above compares the changes you just fetched with your local branch. In the terminal, the red characters denote the state of your local branch while the green characters denote new changes from the remote branch. That is:

git merge

The command above merges the changes into your local branch. In this case, the languages.txt file will be updated with the new changes.

In summary, git fetch retrieves the changes while git merge merges the changes to your local branch.

How to Fetch Remote Branches Using git pull

The git pull command is similar to git fetch and git merge.

The difference is that git pull automatically merges new changes into your local branch. That is, you don't get to compare changes before merging (you won't get the chance to run git diff).

git pull executes both git fetch and git merge at the same time.

So once you run the git pull command, the remote changes will appear locally if there are no merge conflicts.

Conclusion

In this article, you learned how to list remote branches using the git branch -r command.

You also learned how to fetch remote branches. The git fetch command fetches changes from the remote branch while the git merge command merges the remote changes to your local branch. This process give you the opportunity to compare changes before merging them.

On the other hand, the git pull command automatically fetches and merges changes from a remote branch as long as there are no merge conflicts.

Happy coding!

Before we look at the conversions, let's talk about how bytes work in Python. You can skip to the next section if you already understand this, or you're just interested in the conversions.

How Bytes Work in Python

You can create byte literals by prefixing the b notation. This tells the Python interpreter that a set of characters should be treated as bytes. Here's an example:

byte_data = b'Hello'

In the code above, we prefixed b right before the string value: b'Hello'. If you print the characters in the string, you'll get a binary value for each. That is:

byte_data = b'Hello'
print(byte_data[0]) # 72

So instead of "H", 72 was returned. If you go on to print the value of each index in the sequence, you should get their binary values:

byte_data = b'Hello'
print(byte_data[0]) # 72 => H
print(byte_data[1]) # 101 => e
print(byte_data[2]) # 108 => l
print(byte_data[3]) # 108 => l
print(byte_data[4]) # 111 => 0

Now let's talk about how to convert a string to bytes, and how to convert bytes to a string.

How to Convert a Str to Bytes in Python

You can use the encode() method to convert a string to bytes in Python. The method simply encodes a string using a specific encoding like UTF-8, ASCII, and so on.

Here's an example:

string_data = "Hello"
print(string_data[0]) # H

In the code above, we created a string called string_data with a value of "Hello". We also printed the first character of the string, which is "H".

Now let's convert the string to bytes using the encode() method:

string_data = "Hello"
byte_data = string_data.encode('utf-8')
print(byte_data[0]) # 72

We converted the string_data variable to bytes using the encode() method which took "utf-8" as a parameter. We stored this conversion in the byte_data variable: byte_data = string_data.encode('utf-8').

Lastly, we printed the first character of the byte_data variable and got a binary value: print(byte_data[0]) # 72.

How to Convert Bytes to a Str to in Python

You can use the decode() method to convert bytes to a string in Python. It works just like the encode() variable: attach the variable to be converted using dot notation and specify the encoding type as the method's parameter.

Here's an example:

byte_data = b'Hello'
string_data = byte_data.decode('utf-8')
print(string_data[0]) # H

In the code above, we created a bytes object called byte_data.

Using the decode() method, we converted it to a string and stored it in a string_data variable: string_data = byte_data.decode('utf-8').

When you print the characters of the string_data variable, you should get string characters instead of binary values: print(string_data[0]) # H

Conclusion

In this article, you learned how to use bytes in Python. You also learned two conversion methods:

• How to convert a string to bytes using the encode() method.

• How to convert bytes to a string using the decode() method.

Happy coding!

Python provides some built-in control statements that let you change the behavior of a loop. Some of these control statements include continue, break, pass, and else.

In this article, you'll learn how to terminate the current loop or a switch statement using the break statement.

How to Use the break Statement in a Python for Loop

Consider the Python list below:

usernames = ["Jade", "John", "Jane", "Doe"]

You can use a for loop to iterate through and print the elements of the usernames list:

usernames = ["Jade", "John", "Jane", "Doe"]

for i in usernames:
    print(i)
# Jade
# John
# Jane
# Doe

But what if you want to stop the loop when a particular username is found? You can do this using the break statement.

Here's an example:

usernames = ["Jade", "John", "Jane", "Doe"]

for i in usernames:
    print(i)
    if i == "John":
        break
# Jade
# John

In the code above, we created an if statement that checks whether the current value of i is "John": if i == "John".

In the body of the if statement, we used the break statement. So the loop will stop when it finds an element in the list with the value of "John".

So instead of printing the whole list ("Jade", "John", "Jane", "Doe"), "Jade" and "John" were printed because the loop stopped immediately after it found "John".

How to Use the break Statement in a Python while Loop

You can terminate a while loop using the break statement:

usernames = ["Jade", "John", "Jane", "Doe"]

i = 0
while i < len(usernames):
    print(usernames[i])
    if usernames[i] == "John":
        break
    i += 1

Just like we did in the for loop example, we created a usernames list with four elements: ["Jade", "John", "Jane", "Doe"].

Using an if statement in the while loop, we checked when the current loop was at the index with a value "John". When that happens, the loop is terminated.

Once again, "Jade" and "John" were printed because the loop stops when "John" is found.

Conclusion

In this article, you learned to use the break statement in Python. You can use it to terminate the current loop when a condition is met.

From the above examples, you learned how to use the break statement to terminate for and while loops in Python.

Happy coding!

You've most likely used a potentiometer before with appliances like radios, microwaves, blenders, electric fans, game controllers, and others.

They are generally used to provide or control different ranges of variable resistance in electronic circuits.

In this article, you'll learn the following:

• How to connect a potentiometer to an Arduino board.
• How to get the values of a potentiometer.
• How to control the brightness of an LED using a potentiometer.

You can also watch the video version of this article here:

Hardware Components

Here are the hardware components you'll need to follow along:

• Arduino board.
• Potentiometer.
• Breadboard.
• LED.
• 1K Ohm resistor.
• Jumper wires.

How to Connect a Potentiometer to an Arduino Board

The potentiometer is made up of three terminals: two outer terminals and the middle terminal. Either of the outer terminals can be connected to either 5V or GND (ground). That is:

• If you connect the left outer terminal to 5V, you have to connect the right outer terminal to GND.
• If you connect the left outer terminal to GND, you have to connect the right outer terminal to 5V.

The middle terminal serves as the output terminal. We'll connect it to an analog pin. You can read the varying values of the potentiometer from the output terminal.

Here's the circuit diagram:

circuit diagram

Here's how the potentiometer was connected in the diagram above:

• The left outer terminal of the potentiometer was connected to GND.
• The right outer terminal was connected to 5V.
• The middle terminal (output terminal) was connected to analog pin A0 on the Uno board.

Here's how the LED was connected:

• The shorter leg of the LED was connected to GND.
• The longer leg was connected to digital pin 6 through a 1K Ohm resistor.

Make sure to connect the LED to a digital pin with the ~ symbol. Such pins support pulse width modulation, which lets you send analog signals to digital pins.

int potPin = A0;
int potValue = 0;
int brightness = 0;
int ledPin = 6;

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  potValue = analogRead(potPin);
  brightness = (255.0/1023.0)*potValue;
  analogWrite(ledPin, brightness);
}

Let's break down the code.

Initialize Variables

We started by initializing our variables:

int potPin = A0;
int potValue = 0;
int brightness = 0;
int ledPin = 6;

The potPin variable has a value of A0. This represents the A0 pin connected to the output pin of the potentiometer.

We then declared a potValue variable, which will be used to store the values from potPin.

The brightness variable will be used to control the brightness of the LED.

The LED pin was connected to digital pin 6 on the Uno board, so we initialized a ledPin variable with a value of 6: int ledPin = 6;.

Serial Monitor and pinMode

Next, in the loop() function, we initialized the serial monitor and set the LED pin to serve as an output pin:

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

Create Logic to Control LED Brightness

In the loop() function, we have three lines of code:

void loop() {
  potValue = analogRead(potPin);
  brightness = (255.0/1023.0)*potValue;
  analogWrite(ledPin, brightness);
}

In the first line, we used the analogRead() function to read the value of potPin. The read values were assigned to the potValue variable.

At this point, if you print potValue to the serial monitor using Serial.println(potValue);, you'll get a range of values from 0 to 1023 when you tune the knob of the potentiometer.

For the brightness variable, we converted the values from the potentiometer to fall with the range of 0 to 255: brightness = (255.0/1023.0)*potValue;. This is because the analogWrite() function only accepts values within that range, and not the default 0 to 1023 that the potentiometer produces.

Lastly, we used the analogWrite() function to send values to the LED: analogWrite(ledPin, brightness);.

The analogWrite() function's first parameter is the ledPin, which denotes the pin where the values should be sent. The second parameter is brightness, which denotes a range of values to be sent to the LED (ledPin).

When you upload the code to your board, the LED should have varying levels of brightness as you tune the potentiometer.

Conclusion

In this article, you learned how to control the brightness on an LED using a potentiometer. You also saw how to connect the components to digital and analog pins on an Arduino board.

Finally, you learned about how to make the components work together using code.

You can find the code for this project here. You can watch the video version here.

Check out my blog for articles about embedded systems, IoT, and web development.

Happy coding!

Google Analytics is an effective tool for tracking and analyzing traffic and events on your websites and mobile apps. In this article, you'll learn how to add Google Analytics to your Astro website.

To follow along, you'll need the following:

• A Google account.
• A deployed Astro project.

Let's get started!

How to Add Google Analytics to an Astro Website

Before adding Google analytics, make sure you've already deployed your project. Here's one that I've deployed using Netlify: https://astro-article.netlify.app/. This is an Astro blog template created with the npm create astro@latest -- --template blog command.

This section will be divided into two sub-sections. In the first sub-section, you'll learn how to create an Analytics account and how to set up your account for tracking and monitoring your website.

In the second sub-section, you'll learn how to configure your code to sync with Google Analytics.

How to Set Up Google Analytics

You can follow these steps to set up Google Analytics:

Step #1 – Account Creation Page

The first step is to create a Google Analytics account. You can do that by visiting the Google Analytics website.

When the page loads, you should see something similar to this:

Google Analytics home page

Click on the "Start measuring" button. This will take you to the account creation page where you'll fill in some info about your website/app. That is:

"Create an Account" page on Google Analytics

After inputting an account name, scroll down the page and click on the "Next" button.

Step #2 – Property Creation Page

On the property creation page, you can create a property name, time zone, and currency.

A property acts as a unique identifier for your websites and apps. So it is like a container for all the data related to a specified website or app.

"Create a Property" page on Google Analytics

Step #3 – Business Details Page

On the business details page, you can specify your industry category and the business size.

"Describe your business" page on Google Analytics

Step #4 – Business Objectives Page

The business objectives helps Analytics generate personalized reports for your business. You can select the options that are important to your website, app, or product category.

"Business objectives" page on Google Analytics

After selecting the options, click on the "Create" button.

Step #5 – Data Collection Page

On the data collection page, you can choose between different platforms to collect data from. Since we're working with a website, we'll go with the Web option.

"Start collecting data" page on Google Analytics

Next, you'll have to create a data stream by inputting your website URL and your stream name (this can be whatever you want, but I'll recommend using a name related to your website).

Page to setup a data stream on Google Analytics

In my data stream information, I used https://astro-article.netlify.app/ as the URL and "Astro Blog Template" as the stream name.

Make sure you remove the "https://" part of the link in the input box so you don't get the "Valid website URL is required" error.

So instead of https://astro-article.netlify.app/, it should be astro-article.netlify.app/.

This is what mine looks like:

Example of information entered properly in data stream setup page

Go ahead and click on the "Create stream" button.

On the next page/prompt, you'll see your stream name, URL, ID, and measurement ID values.

The measurement ID will be important in our code integration so you can copy and paste it somewhere.

Here's what the page looks like:

"Web stream details" page on Google Analytics

If you click on "View tag instructions", you'll see a code snippet for manual integration with code. Copy the code and paste somewhere because we'll make use of it soon.

Installation instructions

Here's the code snippet if you missed it:

<!-- Google tag (gtag.js) -->
<script async src="https://www.googletagmanager.com/gtag/js?id=MEASUREMENT_ID"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());

  gtag('config', 'MEASUREMENT_ID');
</script>

If you're copying the code above, make sure you replace the two MEASUREMENT_ID values with the actual value of your measurement ID.

How to Integrate Google Analytics and Astro

At this point, we've created a Google Analytics account and generated our project's measurement ID. The next thing to do is to sync our code to Google Analytics.

But first, we have to install a library called Partytown. When using third party integrations, you may run into performance issues because you're making use of third-party code.

Partytown allows these integrations to run as expected without reducing your site's performance. You can read more about that here.

Step #1 – Install Partytown

Head to your Astro project terminal and run this command to install Partytown:

npm install @astrojs/partytown

Step #2 – Configure Partytown

After the installation is complete, you'll need to add the integration to your astro.config.mjs file:

import { defineConfig } from 'astro/config';
import mdx from '@astrojs/mdx';
import partytown from '@astrojs/partytown'

import sitemap from '@astrojs/sitemap';

// https://astro.build/config
export default defineConfig({
    site: 'https://astro-article.netlify.app/',
    integrations: [
        mdx(), 
        sitemap(),
        partytown({
            config: {
              forward: ["dataLayer.push"],
            },
        }),
    ],
});

In the code above, we imported the Partytown library: import partytown from '@astrojs/partytown'.

We then added this piece of code to the integrations object:

partytown({
      config: {
        forward: ["dataLayer.push"],
      },
})

Everything else in the code came with the Astro project.

Step #3 – Add Google Tag to your Pages

Remember the code snippet from Google Analytics? This is where we'll use it.

<!-- Google tag (gtag.js) -->
<script type="text/partytown" async src="https://www.googletagmanager.com/gtag/js?id=MEASUREMENT_ID"></script>
<script type="text/partytown">
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());

  gtag('config', 'MEASUREMENT_ID');
</script>

Note that we added the type="text/partytown" attribute to both <script> tags.

Remember to change the MEASUREMENT_ID values to the value of your measurement ID. Mine looks like this:

<!-- Google tag (gtag.js) -->
<script type="text/partytown" async src="https://www.googletagmanager.com/gtag/js?id=G-KM36S70L8Y"></script>
<script type="text/partytown">
    window.dataLayer = window.dataLayer || [];
    function gtag(){dataLayer.push(arguments);}
    gtag('js', new Date());

    gtag('config', 'G-KM36S70L8Y');
</script>

Do not use the snippet above as it has my measurement ID so it's already associated with my website (not my actual website :)). Copy the first code snippet and change the MEASUREMENT_ID values to the value of your measurement ID.

To track and monitor a page, you need to paste the code snippet in that page. Copy the code and paste it in the <head> section of every page file (index.astro, BlogPost.astro, and so on) you want to track and analyze using Google Analytics.

Here's an example using the index.astro file in the pages directory:

---
import BaseHead from '../components/BaseHead.astro';
import Header from '../components/Header.astro';
import Footer from '../components/Footer.astro';
import { SITE_TITLE, SITE_DESCRIPTION } from '../consts';
---

<!doctype html>
<html lang="en">
    <head>
        <!-- Google tag (gtag.js) -->
        <script type="text/partytown" async src="https://www.googletagmanager.com/gtag/js?id=MEASUREMENT_ID"></script>
        <script type="text/partytown">
            window.dataLayer = window.dataLayer || [];
            function gtag(){dataLayer.push(arguments);}
            gtag('js', new Date());

            gtag('config', 'MEASUREMENT_ID');
        </script>
        <BaseHead title={SITE_TITLE} description={SITE_DESCRIPTION} />
    </head>
... <!-- The rest of the HTML code -->

In the code above, we put the code from Google Analytics in the <head> tag. You can do this for all the pages you want to track and monitor.

Remember to add the type="text/partytown" attribute to the <script> tags, and to change MEASUREMENT_ID (used in two places in the snippet) to the value of your measurement ID.

Step #4 – Build and Deploy your Project

Deploy your project using your preferred process.

In my case, I use npm run build to build into the dist folder, and then push the code to GitHub. This automatically triggers a Netlify deployment.

You don't have to use my method, but make sure your project builds before deployment.

Once your website has been deployed, you may have to wait up to 48 hours to start seeing your analytics in the Google Analytics dashboard.

Pending page

You'll see this page when you click on the "Continue to Home" button:

Analytics dashboard

This is your Analytics dashboard. You can view and analyze your data here when there's data available.

And there you have it! You've successfully integrated your project with Google Analytics.

Summary

In this article, we saw how to add Google Analytics to an Astro project. This can be used to track and analyze traffic and events on websites and apps.

We saw how to create and set up an Analytics account.

We then saw how to integrate Google Analytics to an Astro project using code.

Happy coding! You can read more Astro tutorials on my blog.

Arduino can be applied in a variety of projects like:

• Home automation.
• Internet of Things (IoT).
• Audio and music.
• Automated and remote controlled systems.
• Automation in agriculture.
• Electronic prototyping.
• Wearable devices, and so much more.

The hardware part of Arduino comprises Arduino boards, input and output devices (including digital and analog pins, and sensors and actuators), shields, breadboards, jumper wires, and so on. These components can be combined together to create dynamic and interactive projects.

The software is made up of the development tools used to write, debug, compile, and upload code to Arduino boards. Most 0f the software tools can be found in the Arduino IDE (Integrated Development Environment).

This handbook will help you understand how Arduino works. You'll learn about the Arduino boards, the components that make up a board, and how to connect devices to them.

We'll talk about input and output peripherals which help the microcontroller (the brain of the Arduino board) process information coming from the physical environment, and send output based on programmed logic.

You'll learn about the Arduino IDE, how to code using the Arduino programming language, and how to use sensors, actuators, and other components to build projects as you learn.

You'll also learn about serial communication, which helps Arduino boards communicate with other computers.

This handbook is written for makers (students, artists, hobbyists, programmers) who are beginners.

Prerequisites

Although it would be helpful, you don't need prior programming knowledge to use this handbook. You will learn the basics of Arduino programming from scratch. This can also serve as your introduction to programming.

To make it beginner friendly, we won't talk about some aspects of electronics like current and voltage, resistance, circuits (series and parallel), and most basic electronic/electrical laws and requirements for students in STEM (Science, Technology, Engineering, Mathematics) fields.

Whether you have knowledge of these concepts or not, you can learn about Arduino using this handbook.

If you know how to use a breadboard and a resistor, then that's all the knowledge on electronics you'll need to follow along.

In summary, this handbook is for everyone. You don't need an engineering degree to become an Arduino maker!

Table of Contents:

• Prerequisites
• Chapter 1: Getting Started with Arduino
• Chapter 2: Basics of Arduino Programming
• Chapter 3: How to use Digital Pins in Arduino
• Chapter 4: How to use Analog Pins in Arduino
• Chapter 5: How to use Sensors and Actuators in Arduino
• Chapter 6: How to use the Serial Monitor in Arduino
• Chapter 7: How to use Displays in Arduino

Chapter 1: Getting Started with Arduino

The Arduino development and design process comprises both hardware and software. So knowing how they work together is important for building the right foundation for your journey.

In this chapter, you’ll learn about the different components that make up the Arduino Uno board. You'll also learn how to install the Arduino IDE and set up your development environment.

At the time of writing, a new Uno board was released — the Arduino Uno R4. This handbook will make use of the Uno R3 board, but you can follow along with either of them. The R4 board comes in two variants — Arduino Uno R4 WiFi and Arduino Uno R4 Minima — with cool additional features that you can read about here.

Components of the Arduino Uno R3 Board

There are many types of Arduino boards like Arduino Nano, Arduino Uno, Arduino Mega, Arduino Leonardo, and so on.

These boards have some common features — they all have digital and output pins, they’re programmable, and they all have a microcontroller.

But there are also some differences. Each board varies in size and shape, and usually has more or fewer components when compared to other boards.

The common boards you’ll come across as a beginner are the Nano, Uno, and Mega boards. The most commonly used is the Uno board, which we’ll use for this handbook.

Here are some of the components you'll find on the Uno R3 board:

• A power port.
• USB connector.
• Microcontroller (ATmega328).
• Analog pins.
• Digital pins.
• Reset button.
• TX and RX indicators.

Arduino Uno R3 board (https://store.arduino.cc/products/arduino-uno-rev3)

You’ll make use of most of the components listed above as you progress through this handbook.

How to Install and Set Up the Arduino IDE

You can use the Arduino IDE to program Arduino boards. That is, you write the code in the IDE, then upload it to the board.

In this section, you’ll learn how to set up the IDE, and create your first Arduino program (also called an Arduino sketch).

You can download the latest version of the Arduino IDE on the Arduino software download page. You can download the IDE for different operating systems — Windows, MacOS, and Linux.

The installation process is similar for the operating systems listed above. Here’s how to install it on a Windows machine:

Step #1 – Download the Arduino IDE

The first step is to download the IDE from the Arduino software download page. You should see a section of the page similar to the image below:

On the right side of the image above are different download options for specific operating systems. Make sure you download the option that suits your operating system.

I'll use the ZIP file option for Windows. If you decide to download an installer instead, then you can follow the installation steps after clicking the installation file.

Step #2 – Unzip the Downloaded File

Go on and unzip the downloaded file. This gives you access to all the resources needed to run the Arduino IDE.

After unzipping the file, you should see files like these:

Image showing the files you should see

To launch the Arduino IDE, click on the file that says “Arduino IDE”.

Step #3 – Overview of the Arduino IDE

Now that you’ve downloaded and installed the Arduino IDE, the next part is to get familiar with the development environment. In the next section, you’ll learn how to upload code to an Arduino Uno board using the IDE.

Before that, let’s have a look at some options you’ll find in the Arduino IDE. At the top left corner of the IDE are five options — File, Edit, Sketch, Tools, Help:

Screenshot showing these options (File, Edit, Sketch, Tools, Help)

The “File” option lets you do different things like creating a new sketch (we’ll talk about sketches in the next section), opening an existing sketch, Arduino practice examples for beginners, keyboard shortcuts, save options, and so on.

The “Edit” option gives you access to text formatting options like copy, paste, cut, comment/uncomment code, font size options, text search options, and so on.

You can use the “Sketch” option to verify and compile code, upload code to Arduino boards, optimize code, and add libraries.

You can use the “Tools” option to manage libraries, format code, access the serial monitor and plotter, select an Arduino board and port to upload code to, choose a processor, and so on.

The “Help” option provides resources for troubleshooting, information on IDE updates, guides on “getting started”, and so on.

Next, let’s look at some other parts and functionalities in the IDE that you’ll find useful. The image below, from the Arduino documentation, highlights them perfectly:

https://docs.arduino.cc/software/ide-v2/tutorials/getting-started-ide-v2

• Verify/Upload: You can use these options to compile and upload code to Arduino boards. You’ll get error messages if the code doesn't compile as expected.
• Select Board & Port: You can use this option to select a port and port number to upload your code too. The current version of the Arduino IDE automatically detects both boards and ports.
• Sketchbook: This gives you access to all the sketches created in your computer. You can also access sketches saved on Arduino Cloud (mostly used for creating IoT projects).
• Boards Manager: The Arduino IDE comes with support for different boards. As you progress through your journey, you’ll make use of different boards and some of them may not be supported by the IDE. The board manager tab lets you install and manage packages required to use these boards.
• Library Manager: You can use libraries to extend certain functionalities in code. Through the library manager, you can install numerous libraries that’ll help simplify the development process for you.
• Debugger: This is used for real time testing and debugging of Arduino programs.
• Search: You can use the search tool to find specific keywords in your code.
• Open Serial Monitor: You can use the serial monitor to communicate with Arduino boards, debug and test code, visualize data from your boards, interact with user input, and so on. We’ll look at the serial monitor in depth in a different chapter.
• Open Serial Plotter: The serial plotter is mostly used for real-time visualization of numerical data.

What Is an Arduino Sketch?

We mentioned the term “sketch” a couple of times in the last section, but what is it? A sketch is a program written with the Arduino programming language. It’s another way of referring to a code file written for Arduino projects.

The Arduino programming language is built upon the C/C++ language so they both share similar syntax and structure. You may come across resources that refer to Arduino code as “embedded C” or “embedded C++”.

How to Upload Code to an Arduino Board

To upload code to an Arduino board, you'll need both hardware and software. The hardware is the board which is the Uno board in our case, and the software is the Arduino sketch in the IDE.

Here are the steps:

Step #1 – Connect the Arduino Board

Connect the Arduino board to your computer using the USB cable. Without this step, you can't go further.

Step #2 – Create a Sketch

Now it's time to launch the IDE and write some code.

Here's a code example that makes an LED blink:

int ledPin = 13;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

Don't worry if you don't understand the code — we'll cover everything as we go further.

Step #3 – Select the Board and Port

You can select the board to upload your code to from the IDE. Here's an image showing what that looks like:

Step #4 – Verify the Code

You can use the verify button to compile the code and check for errors. If errors exist, you'll get an error message to show you the possible cause.

Image showing the verify button

Step #5 – Upload the Code

You can upload the code using the upload button (the button after the verify button).

If there are no errors in your code, these steps will help upload code to your board. If you've uploaded the code above, you should have the built-in LED (it is connected to pin 13 by design) on the Uno board blinking.

In the next chapter, you'll learn the basics of the Arduino programming language.

Chapter 2: Basics of Arduino Programming

Before we dive into creating our own sketches and tinkering, you have to understand the logic that make these boards work as expected. To do that, you’ll have to know how to code using the Arduino programming language.

As discussed in the last chapter, the Arduino language is built upon C/C++. You’ll begin this chapter by learning the basics of programming. This will prepare you for every other chapter that involves writing code.

I’ve created this chapter with beginners in mind. If you’ve never written code before then this can serve as a starting point for you. This doesn’t mean you’ll learn how to code in C or C++. You’ll be learning how to write Arduino code which shares similar syntax with those languages.

At the end of this chapter, you should be able to understand and write Arduino code.

Variables and Data Types in Arduino

Variables and data types are used in most programming languages to store and manipulate data. You can think of variables as containers or storage units. Data types, like the name implies, are the type of data stored in variables.

In Arduino programming, you must specify the data type of a variable before using it. That is:

dataType variableName = variableValue

There are different types of data types in Arduino, and we’ll discuss each one along with code examples.

int Data Type in Arduino

The int data type is used to store integer values. The Uno board has a 16-bit integer capacity so it can store values that fall within the range of -32,768 to 32,767.

int redLED = 6;

In the code above, we created an integer variable called redLED with a value of 6.

The int data type can also store negative integers:

int redLED = -6;

long Data Type in Arduino

The long data type is similar to int but has a wider range of integer values. It has a 32-bit integer limit which falls within the range of -2,147,483,648 to 2,147,483,647.

long largeNumber = 6000;

float Data Type in Arduino

The float data type can be used to store numbers with decimals. Float variables can store values up to 3.4028235E+38 and values as low as -3.4028235E+38.

float num = 10.5;

Although the float data type is mainly used for decimal numbers, it can also accept whole numbers (integers without decimals). But it'll always return a float value. So if you store 10 in a float, it'll return 10.00.

String Data Type in Arduino

You can use the String data type to store and manipulate text. You'll work with strings occasionally to display information in the form of text when building projects.

Here's a code example:

String greeting = "Hello World!";

The value of strings are nested within double quotation marks as can be seen in the code above.

Note that when declaring a string, the "S" should always be in uppercase.

char Data Type in Arduino

The char data type stores single characters.

Here's an example:

char alphabet = 'A';

This is different from the String data type that can store multiple characters.

There are two main differences between char and String:

• char uses single quotes ('A') while string uses double quotes ("Arduino").
• char stores single characters while string stores multiple characters.

char can also accept integer values equivalent to the ASCII value of letters:

char charValue = 65;

In the code above, we initialized a char variable with the value of 65. When printed to the serial monitor (we'll talk about the serial monitor in Chapter 6: How to use the Serial Monitor in Arduino), A will be returned.

A is returned because 65 has an ASCII character of A.

bool and boolean Data Types in Arduino

You can use both bool and boolean to store/denote boolean values of either true or false.

bool roomIsCold = false;

Boolean values are mostly used with logical and comparison operators, and conditional statements (you'll learn about these later in this chapter) to manipulate and control different outcomes in an Arduino program.

byte Data Type in Arduino

The byte data type has an 8-bit unsigned integer limit that ranges from 0 to 255. Unsigned means that it can't store negative values.

byte sensorValue = 200;

The byte data type isn't the only data type that can be unsigned. You can also use the unsigned int, unsigned long, and unsigned char data types which all have their respective positive integer ranges.

Operators in Arduino

Operators are symbols or characters that can be used to perform certain operations on operands. An operand is simply any value(s) an operator acts on.

There are different categories of operators in Arduino like:

Arithmetic Operators

Arithmetic operators are used to perform mathematical operations like addition, subtraction, division, multiplication, and so on. Here are some arithmetic operators you should know:

Addition(+) Operator

The addition operator, denoted by the + symbol, adds two operands together:

int a = 5;
int b = 10;

// we use addition operator to add a and b below
int c = a + b;

Serial.print(c);
// 15

Subtraction(-) Operator

The subtraction operator subtracts the value of one operand from another operand. It is denoted by the - symbol:

int a = 5;
int b = 10;

// we use subtraction operator to subtract b from a below
int c = b - a;

Serial.print(c);
// 5

Multiplication (*) Operator

You can use the multiplication operator (*) to multiply two operands:

int a = 5;
int b = 10;

// we use multiplication operator to multiply a by b below
int c = a * b;

Serial.print(c);
// 50

Division(/) Operator

The division operator divides one operand by another:

int a = 5;
int b = 10;

// we use division operator to divide b by a below
int c = b / a;

Serial.print(c);
// 2

Modulus (%) Operator

The modulus operator returns the remainder of a division between two operands:

int a = 5;
int b = 10;

// we use division operator to divide b by a below
int c = b % a;

Serial.print(c);
// 0

Increment (++) Operator

The increment operator increases the value of a variable by 1:

int num = 5;
num++;

Serial.print(num);
// 6

Decrement (--) Operator

The decrement operator decreases the value of a variable by 1:

int num = 5;
num--;

Serial.print(num);
// 4

Assignment Operators

Assignment operators are mainly used to assign values to variables. You can also use them to update the value of variables.

The assignment (=) operator is used for assigning and updating variables. The = operator should not be confused for "equal to" — they aren't the same. We'll talk about the equal to (==) operator in the Comparison Operators section.

Here's an example that shows how to use the assignment operator:

int age = 1;

In the code above, we created a variable called age, and then assigned a value of 1 to it using the = operator.

But this isn't the only way to assign or update the value of variables when using the = operator. You can also use compound assignment operators.

Compound Assignment Operators

Compound assignment operators let you combine arithmetic operators and the = operator. This method provides a shorter way of writing code. Here is an example:

int x = 5;
x += 5;

Serial.print(x)
// 10

In the code above, we created an x variable and assigned a value of 5 to it. But on the second line, you'd see that we combined the arithmetic addition (+) operator and the = operator to assign a new value to x:

x += 5;

The line of code above is the same as this:

x = x + 5;

So compound operators combine two operators and let you do the same thing in a shorter way. There's nothing wrong with either method.

Here are other compound operator examples:

int a = 10;
a -= 5; // Equivalent to a = a - 5 (a becomes 5)

int b = 10;
b *= 5; // Equivalent to b = b * 5 (b becomes 50)

int c = 10;
c /= 5; // Equivalent to c = c / 5 (c becomes 2)

int d = 10;
d %= 5; // Equivalent to d = d % 3 (d becomes 0)

Comparison Operators

You can use comparison operators to compare two values/operands. Comparison operators return either true (1) or false (0) depending on the relationship between operands.

Comparison operators can help you make decisions based on their return values. You'll see them a lot when we start building projects.

Here are the comparison operators you'll come across occasionally:

Equal To (==) Operator

This operator compares the values of two variables. If the values are the same, it returns true. If the values are not the same, it returns false. Here's an example:

int x = 10;
int y = 5; 

Serial.print(x == y)
// returns 0

The return value of x == y in the code above is 0 (false) because the two variables are not the same. Remember that the == operator returns 1 (true) only when both variables have the same value.

Not Equal (!=) Operator

The not equal operator checks whether two values have different values. It's does the opposite of the == operator. That means it'll return 1 (true) if both values are not of the same value and 0 (false) if both values are the same.

Here's an example:

int x = 10;
int y = 5; 

Serial.print(x != y)
// returns 1

Greater Than (>) Operator

The greater than (>) operator checks if the operand on the left is greater than the operand on the right. If the left operand is greater, it returns 1. If the left operand is smaller, it returns 0.

int x = 10;
int y = 5; 

Serial.print(x > y)
// returns 1

Less Than (<) Operator

The less than (<) operator checks if the operand on the left is less than the operand on the left. If the left operand is smaller, it returns 1. If the left operand is greater, it returns 0.

int x = 10;
int y = 5; 

Serial.print(x < y)
// returns 0

Greater Than or Equal To (>=) Operator

Just like the name, the >= operator checks if the operand on the left is either greater than or equal to the operand on the right. It returns 1 if the left operand is greater than or equal to the right operand, and 0 if it isn't.

"Or" implies that either of the conditions can be used. If the left operand is not greater than the right operand but is equal to the right operand, you'll still get a value of 1.

int x = 10;
int y = 5; 

Serial.print(x >= y)
// returns 1

Less Than or Equal To (<=) Operator

The <= operator checks if the left operand is either less than or equal to the right operand. If the left operand is less than or equal to the right operand, it returns 1, and returns 0 if the left operand is neither less than nor equal to the right operand.

int x = 10;
int y = 5; 

Serial.print(x <= y)
// returns 0

Logical Operators

Logical operators are used in most programming languages to evaluate and determine the relationship between variables.

Here are the three logical operators you should know for Arduino programming:

Logical AND (&&) Operator

The logical AND (&&) operator returns 1 if both statements are true.

int x = 10;

Serial.print((x > 5) && (x > 3));
// returns 1

The expression above — (x > 5) && (x > 3) — returns 1 because both statements are true. That is, x > 3 and x > 3. If either or both of those statements were false, then we'd have a return value of 0.

Logical OR (||) Operator

The logical OR (||) operator returns 1 if one of both statements is true.

int x = 10;

Serial.print((x > 5) && (x > 15));
// returns 1

The code above returns 1 although one of the statements is false. This is because the || operator returns 1 if either or both statements are true.

Logical NOT (!) Operator

The NOT (!) operator negates or reverses the value of its operand. If the operand statement is true, it returns false, and returns false if the operand is true.

Here's an example:

int x = 10;

Serial.print(!(x > 5));
// returns 0

The code above returns 0, but why? x > 5 is true so the expected result is 1.

We got 0 because the ! operator reversed the return value of the operand from 0 to 1.

Conditional Statements in Arduino

You can use conditional statements to make decisions or execute code based on specific conditions. You can combine conditional statements and logic (like operators in the last section) to control how code is executed.

Let's take a look at some conditional statements and how to use them:

if Statement

The if statement is used to execute code if a condition is true. Here's what the syntax looks like:

if (condition) {
    // code to be executed if condition is true
}

In the syntax above, condition denotes a specified logic. If the condition is true then the code in the curly brackets will be executed. Here's an example:

int x = 5;
if (x < 10) {
  Serial.print("x is less than 10");
}

// x is less than 10

In the code above, we gave a condition— x < 10 — and a block of code within curly brackets that prints "x is less than 10". The code in the curly brackets will only run if the condition is true.

This is the same as saying "if x is less than 10 then print 'x is less than 10' to the serial monitor". Since x is less than 10, the condition evaluates as true and we get the message printed out.

But what if the condition is false? The code in the curly brackets won't run, so we'll need a different type of logic to handle situations like that. We can do this using the else statement.

else Statement

The else statement is used to execute code if a condition is false.

int score = 20;
if (score > 50 ) {
  Serial.print("You passed the exam!");
} else {
  Serial.print("You have to rewrite the exam!");
}

// You have to rewrite the exam

In the code above, the condition given is false. So the code for the else statement will be executed because the score variable is not greater than 50.

Remember: the code for the else statement only runs when the condition is false. If the condition is true then the code for the if statement will be executed.

else if Statement

You can use the else if statement to define multiple conditions to be checked. Here's the syntax:

if (condition1) {
    // code to be executed if condition1 is true
} else if (condition2){
    // code to be executed if condition2 is true
} else {
    // code to be executed if condition1 and condition2 are false
}

In the syntax above, there are two conditions (you can create more than two conditions). If condition1 is true, then code in the curly bracket for condition1 will be executed.

If condition1 is false, then condition2 will be evaluated. If condition2 is true, its block of code will be executed.

If both condition1 and condition2 are false, the else statement's code will be executed.

int score = 80;
if (score > 50 ) {
  Serial.print("You passed the exam!");
} else if (score < 50) {
  Serial.print("You have to rewrite the exam!");
} else {
  Serial.print("No records for your exam score found!");
}

// You passed the exam!

switch-case Statement

In the last section, we saw how to create multiple conditions using else if statements. Your code might become hard to read if you have many conditions. We can clean it up and make the code more readable using switch statements.

Here's what the syntax looks like:

switch (expression) {
    case 1:
        // Code to be executed if expression equals case 1
        break;
    case 2:
        // Code to be executed if expression equals case 2
        break;
     case 3:
        // Code to be executed if expression equals case 3
        break;
    default:
        // Code to be executed if expression doesn't match any case
        break;
}

Let's break the syntax down:

• The expression is compared to the value of each case.
• When a case matches the expression, the code for that case is executed.
• The break keyword stops the switch statement's iteration once a match for the expression has been found.
• The code for the default keyword is executed if none of the cases match the expression.

Here's an example:

int day = 2;

switch (day) {
  case 1:
    Serial.print("Monday");
    break;
  case 2:
    Serial.print("Tuesday");
    break;
  case 3:
    Serial.print("Wednesday");
    break;
  case 4:
    Serial.print("Thursday");
    break;
  case 5:
    Serial.print("Friday");
    break;
  case 6:
    Serial.print("Saturday");
    break;
  case 7:
    Serial.print("Sunday");
    break;
  default:
    Serial.print("Number out of range");
  }

//  Tuesday

The code above prints "Tuesday" because the expression which has a value of 2 matches case 2.

Loops in Arduino

You can use loops to execute code repeatedly until a certain condition is met. You can also use loops to iterate over a collection of data and execute code on all elements of the collection.

There are different type of loops you can use in Arduino like the for loop, while loop, and do-while loop. Let's take a look at their syntax along with some practical examples:

for loop

You can use the for loop to iterate through a collection or execute code until a certain condition is met. It is commonly used when you know the number of times the loop is supposed to run.

Here's the syntax:

for (initialization; condition; increment/decrement) {
   // code to be executed
}

There are three important keywords in the syntax above:

• initialization denotes an initial variable (usually an integer) which specifies the starting point of the loop.
• condition is used to control the number of times the loop is expected to run for. The loop stops when the condition is false.
• increment/decrement increases/decreases the value of the initial variable after every iteration.

Here's an example to help you understand the keywords:

for (int i = 0; i < 11; i++){
  Serial.println(i);
}

// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

In the loop above, we created an initial variable called 1 with a value of 0.

The condition stated i < 11 which implies that the loop will continue to run as long as i is less than 11.

Using the increment operator i++, we increased the value of i by 1 every time the loop ran.

Lastly, we printed the value of i at every iteration. In the serial monitor, you'll notice the numbers from 0 to 10 printed out. This is because after the number 10, i is no longer less than 11 (the condition given), so the loop terminates.

while loop

The while loop works just like the for loop — it executes code as long as the given condition is true. But its often used when the number of times the loop is supposed to run is unknown.

Here's the syntax:

while (condition) {
    // Code to be executed
}

In the syntax above, the code will continue to run until the condition becomes false.

while (i < 11) {
  Serial.println(i);
  i++;
}

// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

do-while Loop

The do-while loop is just like the while loop, but it executes its code block first before checking the validity of the condition given. That is, at the beginning of the loop, the code in curly brackets will run first even if the condition is false. After that, it starts checking if the condition is true or false, just like a normal loop.

In summary, the code for a do-while loop will run at least once, irrespective of the condition given. Here's an example:

do {
  // code block to be executed
}
while (condition);

Here's the code example:

int i = 0;

do {
  Serial.println(i);
  i++;
} while ( i < 11);

// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

Arrays in Arduino

You can use arrays in Arduino to store multiple variables of the same data type in a single variable. Each element stored in an array can be accessed using its index number.

Array Declaration

Declaring an array simply means to create one. You can do that in Arduino using the syntax below:

dataType arrayName[arraySize]

In the syntax above:

• dataType represents the data types that'll be stored in the array. For instance, if the data type is int, then only integers can be stored in the array.
• arrayName denotes the name of the array.
• arraySize denotes the number of elements that can be stored in the array.

Here's an array declaration code example:

int ages[4];

In the code above, we created an array called ages. The array can only store four elements with an int data type.

Array Initialization

To initialize an array means to assign values to the array. In the last section, we created an array called ages. Now, let's assign some elements to it:

int ages[4] = {2, 4, 6, 8};

You can see from the example above that there are only four elements in the array — 2, 4, 6, 8. Assigning a fifth element would throw an error because we specified that the array can only have for integer elements: int ages[4];.

You can access the elements of the array using their index number. Indexes start at zero (0) – so the first element has an index of 0, the second element has an index of 1, the third element has an index of 2, and so on.

int ages[4] = {2, 4, 6, 8};

Serial.print(ages[0]);
// 2

As can be seen above, we accessed the first element using the array name and the index of the element in square brackets: ages[0].

You can also assign and reassign values to a particular element using its index:

ages[0] = 10;

Note that you can declare and initialize an array at the same time. I only divided them into separate sections to help you understand what each term means.

Functions in Arduino

In the last chapter, we discussed some built-in functions in Arduino that can be used to carry out a variety of tasks related to Arduino hardware and software components. All we did was write the function name and pass in parameters where necessary and we got the desired outcome.

For instance, the digitalWrite() function writes values to digital pins using two parameters (the pin number and the value to be sent to the pin). Under the hood, some code logic handles that operation.

Let's assume that the logic required to send values to digital pins was up to a hundred lines of code. Without functions, you'll have to write those hundred lines every time you wanted to send values to digital pins.

Functions prevent you from having to reinvent the wheel. They also help you break your code down into smaller, more readable and manageable parts.

Just like how built-in functions can be reused to perform a particular task repeatedly, you can also create your own functions for specific functionalities, and that's exactly what you'll learn in this chapter.

How to Declare Functions in Arduino

There are four main parts of a function in Arduino:

• The type of data the function returns.
• The name of the function.
• The function parameter(s) which is optional.
• The body of the function.

Here's what that looks like:

dataType functionName(optionalParameters) {
    // body of the function
}

So from the syntax above, dataType is the data type the function returns. It can be int, String, and so on. A function that has no return statement uses the void type as its data type.

The functionName is the name given to the function. The name is used to call the function to execute the logic defined in the body of the function. You'd see words like "call", "fire", and "invoke" associated with functions. They all mean the same thing — to execute the function's logic.

optionalParameters are variables that you define when creating a function. They enable functions to accept external data which can be used within the function body. Function parameters are defined along with their data types. You'll understand this when we look at some examples.

The body of the function is where all the logic goes to. What the function does when it is invoked is written in the body.

Now that we've seen the different parts of a function, let's create some functions!

How to Declare a Function with the void Type

In the last chapter, we discussed the void Setup() and void loop() functions. They are two built-in functions that you'll use in every Arduino sketch. These functions are defined using the void keyword because they return nothing

Here's what the syntax looks like for functions that use the void type:

void functionName(optionalParameters) {
    // code logic
}

In the syntax above, functionName denotes the name of the function. We can use that name to call the function in order to execute the code defined in the function.

optionalParameters are used to pass external data to the function while the code logic that runs when the function is called is written between the curly brackets.

Here's an example:

// function declaration
void printName(String userName) {
  Serial.println("Hello " + userName);
}

void setup() {
  Serial.begin(9600);
}

void loop() {
  printName("Ihechikara"); // function call
  delay(1000);
}

In the code above, we created a function called printName which accepts a string parameter called userName. The function's task is to print "Hello " along with whatever the parameter value is.

In the void loop(), we called the function and passed a parameter to it: printName("Ihechikara"). In the serial monitor, you'll see "Hello Ihechikara" printed.

To call a function, all you have to do is write the name of the function with parenthesis: printName(). Remember to pass in parameters when required: printName("Ihechikara").

Using a parameter that has the wrong data type will result in an error. For instance, we defined a string parameter in our example. Using an integer will raise an error because the function expects a string.

How to Declare a Function with a Return Data Type

In this section, I'll use the int data type to show you how functions declared without the void type are used. The logic here is the same with other functions that use the return statement.

// function declaration
int addNums(int a, int b) {

  int result = a + b;
  return result;
}

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println(addNums(2, 10)); // function call
  delay(1000);
}

In the code above, we declared a function with the int type: int addNums(int a, int b) {...}. This implies that the function is expected to return an integer value.

The function's logic adds the value of the two parameters (a and b) and returns their sum. We used the return statement to return the sum of the parameters.

We can now say that the task of the addNums function is to return the sum of two given parameters. This can be seen when we used the function in the void loop():

Serial.println(addNums(2, 10));

We called the function with two parameters and got their sum printed out in the serial monitor.

What You Should Know About the return Statement

In the last two sections, we saw how to use functions in two different ways — functions that use the return statement and functions that don't use it.

But what if you used the return statement in a void function? Would that break the code? The answer is no. I'll explain why.

The main use of the return keyword is to return a value from the function, and then terminate the function. Consider the example below:

int addNums(int a, int b) {

  int result = a + b;
  Serial.println(result);
  return result;

  // This part will be ignored
  Serial.println("Hello World");
}

The function above takes in two parameters — a and b — and returns their sum. You'll notice that we printed "Hello World" after the return statement. The part of the code that comes after the return statement will not be executed because the function terminates/stops its operation once it sees a return statement.

So you should always remember that anything that comes after the return statement will be ignored.

You can use the return statement in void functions but it is a convention not to. We simply use the void keyword to define functions that have no use for the return statement.

Commonly Used Built-in Functions in Arduino Sketch

In this section, we’ll discuss some of the commonly used built-in functions you’ll come across when writing or reading Arduino code. We'll make use of them in most of the upcoming chapters of this handbook.

We'll begin with the two main parts of an Arduino sketch — the setup() and loop() functions.

setup() and loop() Functions in Arduino

You can use the setup() function to configure analog and digital pins, initialize variables, and do other setup functionalities. The setup() function is executed once — when the board is powered on or reset.

The loop() function runs continuously. This part of the sketch is where you write all the code logic. You can use the loop() function to give the Arduino board instructions on different components and sensors.

void setup() {
  // put your setup code here, to run once:

}

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

}

pinMode() Function in Arduino

The pinMode() function is used to configure pins as input or output pins. It can also be used to configure a resistor to act as either a pull-up or pull-down resistor. You'll understand more about this function in the Sensors and Actuators chapter.

Syntax

pinMode(pin, mode)

• pin denotes the pin number on an Arduino board.
• mode denotes the configuration of the pin which can be INPUT, OUTPUT, or INPUT_PULLUP.

digitalRead() Function in Arduino

You can use the digitalRead() function to read the state of digital pins. It returns either 0 (LOW) or 1 (HIGH).

Syntax

digitalRead(pin)

In the code above, pin denotes the pin number on an Arduino board.

digitalWrite() Function in Arduino

The digitalWrite() function assigns or writes values (either HIGH or LOW) to digital pins.

Syntax

digitalWrite(pin, value)

• pin denotes the pin number on an Arduino board.
• value denotes the value to be assigned to pin. Can be HIGH or LOW.

analogRead() Function in Arduino

The analogRead() function reads values from analog pins and returns values that fall within the range of 0 and 1023.

Syntax

analogRead(pin)

In the code above, pin denotes the pin number on an Arduino board.

analogWrite() Function in Arduino

This function writes or assigns an analog value to a pin.

Syntax

analogWrite(pin, value)

• pin denotes the pin number on an Arduino board.
• value denotes the value to be assigned to pin. Range from 0 to 255.

Serial Functions in Arduino

Serial communication enables an Arduino board to communicate with the computer and other devices using the built-in serial monitor. Here are some of the commonly used functions:

Serial.begin()

The Serial.begin() function initializes serial communication. It is the first function you use when working with the serial monitor. The function takes in a baud rate as its parameter.

In this case, baud rate represents the rate or speed of data transfer in serial communication.

Here's the syntax:

Serial.begin(baudRate)

Serial.print() and Serial.println()

You can use the print() and println() functions to print data to the serial monitor.

print(val)
println(val)

In the code above, val denotes the value to be printed.

We'll talk more about serial communication in Chapter 6: How to use the Serial Monitor in Arduino.

delay() Function in Arduino

You can use the delay() function to pause the Arduino program for a specified amount of time. Here's what the syntax looks like:

delay(ms)

In the code above, ms denotes the specified time in milliseconds.

Chapter 3: How to Use Digital Pins in Arduino

Digital pins are used to send and receive digital signals in two states — HIGH and LOW. The digital pins on a Arduino board can be configured as either input or output pins.

These states can also be represented using numbers (1 for HIGH and 0 for LOW), or in volts (V) (5V for HIGH and 0V for LOW).

The number and arrangement of pins differ in various Arduino boards, but they serve the same purpose. So if you understand how to use them in this chapter, you won't have a problem working with them in other boards.

The Uno board has 14 digital pins numbered from 0 to 13. Although each pin can be configured to serve as either a digital input or output pin, some of them come with extra functionalities like:

• Pins 0 (RX) and 1 (TX) enable the Arduino board to communicate serially. RX receives while TX sends.
• Pins that have the tilde (~) symbol beside them support PWM (Pulse Width Modulation) signals. This means that you can use these pins like analog pins (to receive analog values).
• Pins 2 and 3 can be used for interrupt-based functionalities.

How to Configure Digital Pins as Input or Output Pins

When a digital pin is configured as an INPUT pin, it serves as a point for receiving information from components. This way you get data from sensors, electronic components, and so on.

You can use the pinMode() function to configure a pin to serve as either an INPUT or OUTPUT pin. Note that the pins on an Uno board are set to INPUT by default so if you don't specify prior to using them, they'll serve as input pins.

In this section, you'll learn how to use digital pins as both input and output pins. You'll start by learning about them individually, and then see how to combine input and output signals to build a mini project.

We'll start with INPUT.

Digital Pins as INPUT

The information or signal sent to input pins can be read using the digitalRead() function. In this section, you'll learn how to configure and read signals from a digital input pin using different built-in functions.

We'll use the following hardware components:

• Arduino Uno.
• Breadboard.
• Pushbutton.
• Jumper wires.

Here's the diagram for the connection:

Configuration diagram – INPUT

Here's the code:

int pushBtn = 7;
int push_btn_state;

void setup(){
  pinMode(pushBtn, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop(){
  push_btn_state = digitalRead(pushBtn);
  Serial.println(push_btn_state);
  delay(1000);
}

Let's break the code down.

We started by creating two integer variables — pushBtn and push_btn_state:

int pushBtn = 7;
int push_btn_state;

pushBtn was assigned a value of 7. We used this value to denote pin 7 on the Arduino board. We declared the push_btn_state variable but didn't assign any value to it because we'll use it to store the value of the push button later.

In our setup() function, we configured the push button to act as an input pin using the pinMode() function:

pinMode(pushBtn, INPUT_PULLUP);

The function took in two parameters — the pushBtn variable which denoted pin 7, and INPUT_PULLUP which sets the pin as an input with a pull-up resistor.

We also initialized the serial monitor using Serial.begin(9600).

At this point, we've configured the Arduino software and hardware to recognize pin 7 as an input pin.

Next, we used the digitalRead() function to read signals coming from pin 7. Remember the push_btn_state variable we created? That's where we stored the signal:

push_btn_state = digitalRead(pushBtn);

After that, we printed the value being read from pin 7 to the serial monitor using Serial.println(push_btn_state);.

When you open the serial monitor, you'll see 1 being printed out repeatedly. This is the initial state of the pushbutton using a pull-up resistor. When you press down the pushbutton, the value will become 0. When you release the button, the value will become 1.

0 denotes LOW while 1 denotes HIGH. With this example, you should understand how to configure, read, and display signals from an input pin.

Digital Pins as OUTPUT

The main use of an output pin is to send out signals. Since we're working with digital output, we can send either HIGH (5V) or LOW (0V) signals. We can do this for digital pins using the digitalWrite() function.

In this section, we'll use a LED (Light Emitting Diode) to demonstrate how to configure and send signals to components.

Here are the components we'll use:

• Arduino Uno.
• Red LED.
• 1k Ohm resistor.
• Jumper wires.
• Breadboard.

Here's the circuit diagram:

Configuration diagram – OUTPUT

int RedLED = 8;

void setup(){
  pinMode(RedLED, OUTPUT);
}

void loop(){
  digitalWrite(RedLED, HIGH);
  delay(1000);
  digitalWrite(RedLED, LOW);
  delay(1000);
}

In the code above, we configured the red LED, which is connected to pin 8 on the Uno board, as an output pin using the pinMode() function.

We then used the digitalWrite() function to send signals to the pin:

  digitalWrite(RedLED, HIGH);
  delay(1000);
  digitalWrite(RedLED, LOW);
  delay(1000);

With the HIGH parameter, we send 5V to the pin which makes the LED come on. With LOW, we send 0V which turns the LED off. So the LED comes on and off continuously with a delay of 1000 milliseconds. This example is commonly known as the "BLINK" example.

Digital I/O Project

Now that we've understood how to send and receive digital signals using Arduino, let's combine both of them to build an interactive project.

The idea is to control an LED using a pushbutton. When you press the button, the LED goes off, and comes back on when you release the button.

We'll combine the components used in the previous examples:

• Arduino Uno.
• Red LED.
• 1k Ohm resistor.
• Pushbutton.
• Jumper wires.
• Breadboard.

Configuration diagram - INPUT and OUTPUT project

Here's the code:

int pushBtn = 7;
int push_btn_state;
int RedLED = 8;

void setup(){
  pinMode(pushBtn, INPUT_PULLUP);
  pinMode(RedLED, OUTPUT);
}

void loop(){
  push_btn_state = digitalRead(pushBtn);

  if (push_btn_state == 1) {
    digitalWrite(RedLED, HIGH);
  } else {
    digitalWrite(RedLED, LOW);
  }
}

Here's a breakdown of the code above:

First, we connected the pushbutton to pin 7 and the red LED to pin 8.

Then we configured both pins — pin 7 as input, and pin 8 as output.

Next, we read the value of the pushbutton using the digitalRead() function and stored the value in a variable called push_btn_state.

Using an if statement, we checked for the state of the pushbutton. When push_btn_state is not being pushed down, it has a value of 1 (HIGH). We send 5V to the LED using digitalWrite().

When push_btn_state is pushed down, it has a value of 0, and we send 0V to the LED which turns it off.

Chapter 4: How to Use Analog Pins in Arduino

Analog pins can be used to receive and send voltage values from/to different sensors and components. Unlike digital signals that fall within two states of 0 (LOW) and 1 (HIGH), analog values have a wider range of values from 0 to 1023.

The Uno board has six analog pins — A0, A1, A2, A3, A4, and A5. These pins are INPUT pins by default.

Similar to digital pins, there are in-built functions for receiving and sending analog voltage signals. You can use the analogRead() function to read/receive analog values from pins while the analogWrite() function can be used to write to specific pins.

Note that the analogWrite() function doesn't write or send analog values to analog pins. It sends analog voltage values (that get converted to digital signals) to digital pins that support PWM (Pulse Width Modulation).

You can find PWM digital pins on the Arduino board by the (~) symbol beside them. On the Uno board, there are pins 3, 5, 6, 9, 10, and 11.

In the project for this section, you'll learn how to adjust the brightness of an LED using a potentiometer. We'll use the potentiometer as an input component, and send its voltage to an LED to increase/decrease the LED's brightness.

Here are the components we'll use:

• Arduino Uno.
• Yellow LED.
• Potentiometer.
• 1k Ohm resistor.
• Jumper wires.
• Breadboard.

Here's the circuit diagram:

Configuration diagram

Here's the code for the circuit:

int potentiometer = A0;
int pot_value = 0;
float pot_in_PWM;
int yelowLED = 6;

void setup(){
  pinMode(potentiometer, INPUT);
  pinMode(yelowLED, OUTPUT);
}

void loop(){
  pot_value = analogRead(potentiometer);
  pot_in_PWM = pot_value * (255.0 / 1023.0);

  analogWrite(yelowLED, pot_in_PWM);
}

In the code above, we set the potentiometer (connected to analog pin A0) as an input component. The yellow LED (connected to digital pin 6) was set as an output component. The LED is connected to a PWM pin because we'll be sending analog values to it.

Using the analogRead() function, we got the value of the potentiometer and stored it in a variable called pot_value. The potentiometer returns values from 0 to 1023.

We then converted the values returned by the potentiometer to a range of 0 to 255 which corresponds with PWM values. This is because the analogWrite() function sends PWM values that fall within that range (0 to 255). The new range of values was stored in a variable called pot_in_PWM.

Lastly, we used the analogRead() function to send PWM values to the LED: analogWrite(yelowLED, pot_in_PWM).

When you verify and upload the code to your Arduino board, you'll be able to control the brightness of the LED by turning the potentiometer's knob.

Chapter 5: How to Use Sensors and Actuators in Arduino

Sensors and actuators play a crucial role in developing projects using Arduino. They help microcontrollers get information about changes in the physical environment, and make decisions based on that information.

The goal of this chapter is to help you understand the difference between sensors and actuators, and how to use them. Of course, there are numerous sensors and actuators, but we'll focus on just a few. You should be able to explore other sensors on your own at the end of this chapter.

We'll first talk about what sensors are, types of sensors, and how to work with them using code. We'll then do the same for actuators, and conclude by looking at an example that uses both sensors and actuators in a project.

Let's get started!

What are Sensors in Arduino?

A sensor is a device that listens for or detects changes in the environment. Sensors convert the information they detect in the physical environment to electrical signals which are then sent to the microcontroller (the brain of the board).

You can look at sensors like the human sense organs — we use them to gather information about our environment. Each sense organ (like eyes and ears) in the human body has a specific function and mode of operation that's different from other organs.

In the same manner, sensors in Arduino have their specific functions and use cases. For example, we have sensors that can measure and detect temperature, motion, moisture, and so on.

Types of Sensors in Arduino

Here are some commonly used sensors you'll come across when working with Arduino:

• Temperature sensor: Measures the temperature and humidity of the environment.
• Light-Dependent Resistor (LDR): Measures/senses the intensity of light.
• Ultrasonic sensor: Measures the distance of an object from the sensor.
• Motion sensor: Generally detects motion by sensing changes in infrared energy/radiation.
• Soil moisture sensor: Measures the moisture level of the soil.
• Water sensor: Measures water level/detects water, and so on.

There are other types of sensors that you can use with Arduino, but we'll just focus on two: the LDR (light-dependent resistor) and ultrasonic sensor.

With the examples in this section, you'll be able to explore how other sensors work on your own.

How to use the Light-Dependent Resistor (LDR) in Arduino

The light-dependent resistor (LDR), also known as a photoresistor, is an electronic component that has varying levels of resistance depending on the intensity of light.

Basically, you can use this sensor to sense light. You can do cool things with it like creating an automated lighting system that turns on electric lights in your house when it's dark, or a weather station that tracks and monitors sunlight, and so on.

A LDR usually looks like this:

Diagram of an LDR

Here's what the circuit connection looks like:

Configuration diagram

In the circuit above, one leg of the LDR is connected to 5V (volts). The other leg is connected to a 1K Ohm resistor — one end of the resistor is connected to ground (GND) while the other end is connected to an analog pin (A1 in our circuit).

Here's the code:

int ldrPin = A1;
int ldrValue;

void setup() {
  pinMode(ldrPin, INPUT);
  Serial.begin(9600); 
}

void loop() {
  ldrValue = analogRead(ldrPin);
  Serial.println(ldrValue);
  delay(1000); 
}

In the code above, we created a variable called ldrpin with a value of A1. This denotes the connection made in the circuit where one leg of the LDR is connected to the analog pin. This pin will help us know the value of the sensor.

We then created an ldrValue variable which will be used to store the value of the sensor.

In the setup() function, we set the LDR as an INPUT pin. We also initialized the serial monitor.

Next, we read the value of the LDR using the analogRead function, and stored the value in the ldrValue variable:

ldrValue = analogRead(ldrPin);

Lastly, we printed the read value to the serial monitor with a delay of 1000 milliseconds (one second).

At this point, if you increase the exposure of light on the LDR, the value increases. If you decrease the light intensity or cover the sensor to block off light, the value will decrease or become zero, respectively.

How to Use the Ultrasonic Sensor in Arduino

The ultrasonic sensor is generally used to measure the distance of objects. You can use this sensor in a lot of applications like:

• Home automation (you can perform certain actions when the presence of an object/human is sensed, like turning on lights in a dark room).
• Automated doors.
• Security systems.
• Measurement of distance, and so on.

Just like other sensors, there are various types. In this example, we'll use the HC-SR04 ultrasonic sensor. Don't worry, the working principle is the same. So if you understand how to use this one, you can configure and use other types of ultrasonic sensors you come across.

Here's what the circuit diagram looks like:

Configuration diagram (from https://howtomechatronics.com/tutorials/arduino/ultrasonic-sensor-hc-sr04/)

The sensor has four pins — VCC, Trig, Echo, and GND.

• The VCC pin is connected to 5V on the Uno board
• The Trig pin is connected to digital pin 9.
• The Echo pin is connected to digital pin 10.
• The GND pin is connected to GND on the Uno board.

The trig pin is used to "trigger" the ultrasonic sensor while the echo pin is used to distance of objects based on the amount of time it takes for ultrasonic waves/signals to bounce back from an object.

Here's a code example:

int trigPin = 9; 
int echoPin = 10;  

long duration, distance;

void setup() {
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  duration = pulseIn(echoPin, HIGH);

  distance = (duration / 2) * 0.0343;

  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(1000);
}

In the code above, the trig pin denotes digital pin 9, and the echo pin denotes digital pin 10.

We declared two variables — duration and distance — to be used to store their respective values.

We triggered the sensor by sending the HIGH signal to the trigger pin for 10 microseconds. Without this, the sensor might not work:

  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

We measured and stored the duration of the ultrasonic pulse/signals using the pulseIn(echoPin, HIGH) function and stored it in the duration variable.

We then calculated the duration in centimeters and stored it in the distance variable.

Lastly, we printed the distance to the serial monitor with a delay of 1000 milliseconds.

At this point, you can place an object closer to or farther away from the sensor and see the value of the distance of the object change in the serial monitor.

What are Actuators in Arduino?

Actuators in Arduino are components that convert electrical signals into physical/mechanical motion.

Here are some actuators:

• LED (Light Emitting Diode): Used as light/visual indicators.
• Buzzer: Used to produce sound.
• Relay modules: Used to control high voltage devices.
• LCD (Liquid Crystal Display): Used as visual display for text, images, sensor data, and so on. We'll dedicate a separate chapter to displays.
• Servo motors: Used to control angular or rotational motion (an example is the movement of a robotic arm).

We'll focus on the buzzer and LED in this section.

How to use LEDs in Arduino

LEDs are usually the first components you learn about in Arduino. There are easy to connect and use.

Here's what an LED looks like:

Here's the circuit connection:

In the circuit above, the longer leg of the LED (the anode or positive leg) is connected to digital pin 7.

The shorter leg (cathode) is connected to ground.

Here's the code:

int redLED = 7;

void setup() {
  pinMode(redLED, OUTPUT);
}

void loop() {
  digitalWrite(redLED, HIGH);
  delay(1000);
  digitalWrite(redLED, LOW);
  delay(1000);
}

The code above will make the LED blink once the code has been uploaded.

How to use a Buzzer in Arduino

You can use buzzers to produce sound. There are generally two types of buzzers: active and passive buzzers.

Active buzzers usually have a predefined type of sound that they produce when voltage is supplied to them. The sound cannot be modified. Active buzzers have an internal circuit that triggers the sound production.

Passive buzzers are a bit more flexible when it comes to producing sound because they rely on external signals. This means that you can determine the frequency (or frequencies) of the sound produced by the buzzer.

Buzzers can be used in different applications like:

• Alarm systems.
• Sound indictor for home appliances.
• Doorbells.
• Communication devices to denote the start/end of a signal communication, and so on.

We'll work with the passive buzzer because of its flexibility. This is what it looks like:

The buzzer has a positive and negative terminal. The positive is connected to a digital pin while the negative is connected to ground.

Here's the circuit diagram:

In this example, we'll use the buzzer to produce the DO, RE, MI, FA, SOL, LA, TI music notes sound.

Here's the code:

int buzzerPin = 7;

int notes[] = {262, 294, 330, 349, 392, 440, 494};

int noteDurations[] = {400, 400, 400, 400, 400, 400, 400};

void setup() {
  pinMode(buzzerPin, OUTPUT);
}

void loop() {
  for (int i = 0; i < 8; i++) {
    tone(buzzerPin, notes[i], noteDurations[i]);
    delay(noteDurations[i] + 50);
    noTone(buzzerPin);
  }

  delay(1000);
}

In the code above, we used the buzzerPin variable to denote pin 7 on the Uno board.

We then created an array called notes[] which stores the respective frequency of each note, and another array called noteDurations which stores the duration of each note as they're being produced by the buzzer.

In the void loop() function, we looped through each note a played them using the tone() function. The function takes in three parameters — the pin connected to the buzzer, the frequency, and the duration.

We used the noTone() function to stop the generation of sound. Lastly, we added a delay of 1000 milliseconds which is the amount of time it'll take to play the notes from the start after the last note has been played.

If you've followed along up to this point, then you should have the DO, RE, MI, FA, SOL, LA, TI music notes playing through the buzzer.

Arduino Sensor and Actuator Example

Now that you understand what sensors and actuators are and how to use them, let's use them together in one project.

In many embedded systems, sensors and actuators work together to get a specific task/functionality done. Here's how that works:

• A sensor detects/senses changes in the environment, and sends signals to the microcontroller to notify it of the detected changes.
• The microcontroller processes the signals from the sensor. Depending on the existing logic (defined in the code), it sends signals to the actuator.
• The actuator converts the signal from the microcontroller to physical/mechanical motion.

Let's demonstrate these using an example. The idea here is to turn on an LED in a dark environment and turn it off when there's enough light.

The sensor will be the LDR sensor, the microcontroller will be the Arduino Uno board/software, and the actuator will be the LED.

Here's the circuit diagram:

Here's the code:

int redLED = 7;

int ldrPin = A1;
int ldrValue;

void setup() {
  pinMode(ldrPin, INPUT);
  pinMode(redLED, OUTPUT);
  Serial.begin(9600); 
}

void loop() {
  ldrValue = analogRead(ldrPin);

  if (ldrValue > 200) {
    digitalWrite(redLED, LOW);
  } else if (ldrValue < 200) {
    digitalWrite(redLED, HIGH);
  }

  Serial.println(ldrValue);
  delay(1000); 
}

As usual, we created variables to represent the Arduino pins connected to the LED and LDR. We then set the LDR as INPUT and the LED as output in the setup() function.

We read the value of the LDR using the analogRead() function and stored it in the ldrValue variable.

Next, we used the an if statement to check the value of the LDR.

If the value is greater than 200, we turn off the LED. If the value is less than 200, we turn on the LED.

Chapter 6: How to Use the Serial Monitor in Arduino

The serial monitor is a useful tool for every Arduino builder. You can use it for a variety of tasks like:

• Debugging and testing code/components.
• Serial communication between the Arduino board and the computer.
• Display sensor and component data and readings.

In this chapter, you'll learn how to initialize and use the serial monitor using the Arduino IDE. You'll learn about different built-in functions that can be used to send and receive data between the Arduino board and the computer.

Lastly, you'll build a project that uses values sent from the serial monitor to power specific LEDs connected to the Arduino board.

How to Initialize the Serial Monitor With Serial.begin()

You can use the Serial.begin() function to initialize the serial monitor. It takes in the baud rate as its parameter. Here's what the syntax looks like:

Serial.begin(baudRate)

The baud rate is the speed of data transfer between the Arduino board and the computer or any other device communicating with the Arduino board through the serial monitor.

The most commonly used baud rate is 9600, but you'll also come across resources that make use of 115200, 57600, and 38400, and so on. Whichever baud rate you specify in the Serial.begin() function should always match the baud rate seen in the serial monitor window.

For example, we can initialize the serial monitor in the IDE using the Serial.begin() function like this:

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

}

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

}

In the code above, using the Serial.begin() function, we initialized the serial monitor in the setup() function with a baud rate of 9600.

At this point, nothing is happening. You can verify that the baud rates match by opening the serial monitor window. Once you have it open, you should have the serial monitor appear at the base of the IDE. You'll see the baud rate of the serial monitor within the window, usually written like "9600 baud".

Image showing baud rate

If you're using an older version of the IDE, the serial monitor may pop up as a separate window. The functionality is still the same.

Now that we've initialized the serial monitor, let's see how to send and receive data with it.

How to Send Data with Serial Monitor

You can use different built-in functions reserved for serial communication in Arduino. We won't discuss all the built-in serial functions in Arduino – we'll just look at some you'll use/come across regularly. You can see more functions here.

print() and println() Functions

The print() and println() functions both print data to the serial monitor. The difference between the two is that print() prints data on the same line while println() prints each data on a new line.

Here are some examples:

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.print("Hello"); 
  delay(1000);
}

In the code above, we used the print() function to print "Hello" to the serial monitor repeatedly with a delay of 1000 milliseconds. Here's what the output looks like in the serial monitor:

Here's another example using the println() function:

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println("Hi");
  delay(1000);
}

Here's the output in the serial monitor:

How to Receive Data with Serial Monitor

We'll discuss four functions in this section — available(), readString(), parseInt(), and parseFloat(). You can read up on other serial functions here.

available() Function

The Serial.available() function checks the number of characters in the serial port. It is mostly use to run code only when data is available in the serial monitor.

Here's a code example:

int userInput;

void setup(){
  Serial.begin(9600);
}

void loop(){
  if (Serial.available() > 0) {
    userInput = Serial.parseInt();

    Serial.println(userInput);
  }

}

In the code above, the code block in the if statement will not run until the number of characters in the serial monitor is greater than 0.

When you initialize the serial monitor, the number of readable characters will be zero because there is no data available yet. The Serial.available() function checks and returns the number of characters available in the serial monitor. So it is used to create logic that only lets code be executed when data is available.

readString() Function

You can use the readString() function to read characters from the serial monitor. It returns a string object so whatever values/characters you input in the serial monitor will be seen as string values when using the readString() function.

String userInput;

void setup(){
  Serial.begin(9600);
}

void loop(){
  if (Serial.available() > 0) {
    userInput = Serial.readString();

    Serial.println(userInput);
  }

}

parseInt() Function

The parseInt() function returns valid integer values from incoming serial data. Non integer values will be returned as 0.

int userInput;

void setup(){
  Serial.begin(9600);
}

void loop(){
  if (Serial.available() > 0) {
    userInput = Serial.parseInt();

    Serial.println(userInput);
  }

}

parseFloat() Function

The parseFloat() function returns valid floating point numbers from incoming serial data.

float userInput;

void setup(){
  Serial.begin(9600);
}

void loop(){
  if (Serial.available() > 0) {
    userInput = Serial.parseFloat();

    Serial.println(userInput);
  }

}

Serial Monitor Project

In this section, you'll build a project that uses string values from the serial monitor to turn on LEDs. We'll make use of some of the serial functions discussed in previous sections.

Here's the circuit diagram:

In the circuit diagram above, we have three LEDs. The red LED is connected to pin 6, the blue LED to pin 5, and the yellow LED to pin 4.

Here's the code:

int redLED = 6;
int blueLED = 5;
int yellowLED = 4;

String userInput;

void setup(){
  pinMode(redLED, OUTPUT);
  pinMode(blueLED, OUTPUT);
  pinMode(yellowLED, OUTPUT);
  Serial.begin(9600);

  Serial.println("Choose an LED to turn on from the list below:");
  Serial.println("red");
  Serial.println("blue");
  Serial.println("yellow");
}

void loop(){

  if (Serial.available() > 0) {

    userInput = Serial.readString();

    if (userInput == "red") {
      digitalWrite(redLED, HIGH);
      digitalWrite(blueLED, LOW);
      digitalWrite(yellowLED, LOW);
    } 

    if (userInput == "blue") {
      digitalWrite(redLED, LOW);
      digitalWrite(blueLED, HIGH);
      digitalWrite(yellowLED, LOW);
    }

    if (userInput == "yellow") {
      digitalWrite(redLED, LOW);
      digitalWrite(blueLED, LOW);
      digitalWrite(yellowLED, HIGH);
    }

  }

}

Let's break down the code above.

Just like the connection in the circuit diagram, we initialized the three LEDs with their respective pin numbers. We also created a string variable called userInput that will be used to store the data from the serial monitor:

int redLED = 6;
int blueLED = 5;
int yellowLED = 4;

We then configured the three LEDs as output pins using the pinMode() function:

pinMode(redLED, OUTPUT);
pinMode(blueLED, OUTPUT);
pinMode(yellowLED, OUTPUT);

We initialized the serial monitor with a baud rate of 9600, and printed some strings to give users a hint at the expected values to be used in the serial monitor:

Serial.begin(9600);

Serial.println("Choose an LED to turn on from the list below:");
Serial.println("red");
Serial.println("blue");
Serial.println("yellow");

At this point, you'll have an output like this in the serial monitor:

Using the Serial.available() function, we check for availability of serial data before running the code in the if statement:

if (Serial.available() > 0) {
    ...
}

The next thing we did was to read and return the incoming data as string values, and store the data in the userInput variable. We did that using the readString() function:

userInput = Serial.readString();

Lastly, we used if statements to check which LED color value the user has typed in/sent through the serial monitor, then turn on/off the respective LEDs:

if (userInput == "red") {
  digitalWrite(redLED, HIGH);
  digitalWrite(blueLED, LOW);
  digitalWrite(yellowLED, LOW);
} 

if (userInput == "blue") {
  digitalWrite(redLED, LOW);
  digitalWrite(blueLED, HIGH);
  digitalWrite(yellowLED, LOW);
}

if (userInput == "yellow") {
  digitalWrite(redLED, LOW);
  digitalWrite(blueLED, LOW);
  digitalWrite(yellowLED, HIGH);
}

If you type and send red through the serial monitor, the red LED comes on while the others goes off. The same logic applies to sending blue or yellow through the serial monitor.

Chapter 7: How to Use Displays in Arduino

You can use display components in Arduino to represent data visually in different formats like text, images, and so on.

Displays provide an alternative to showing data other than the serial monitor. You can use them to display sensor values, instructions to users, user input, and so on.

There are various types of display components when it comes to building with Arduino but we'll focus on the LCD (Liquid Crystal Display).

To be more specific, we'll use the 16 x 2 LCD (HD44780). This is what it looks like:

From the image above, there are sixteen pins with different values. We'll use most of these pins to make connections to the Uno board which will enable us use and control the component.

There are generally two ways of connecting the LCD — using the built-in library or using a third-party library.

With the built-in LiquidCrystal library, you'll make use of about 12 pins on the LCD component. When it comes to using a third-party library like LiquidCrystal_I2C, you'll make use of just 2 pins.

We'll be using the first method — this will help you understand how the pins work. Now let's talk about those pins.

What are the pins in an LCD used for?

The pins control functionalities like memory management, data transfer, and power on an LCD. Let's talk about them in detail:

• The first pin from the left is the GND pin, which is the LCD's ground pin. It is connected to GND on the Arduino board. In some LCD modules, it may be written as VSS.
• The VCC is the power pin which is connected to 5V on the Arduino board. In some LCD modules, it may be written as VDD.
• The V0 pin is used to adjust the contrast of the LCD. It is connected to a potentiometer. Tuning the potentiometer changes the contrast of the data being displayed.
• The RS (Register Select) pin can be used to control the LCD's memory. It is usually connected to a digital pin.
• The RW (Read/Write) pin controls whether data is written or read to the LCD. It is usually connected to ground (GND) which sets the LCD to write mode — this enables you to send and display data with the LCD.
• The E (Enable) pin "enables" data transfer between the microcontroller (in our case, the Uno board) and the LCD. It is usually connected to a digital pin.
• The D0 to D7 (can also be written as DB0 to DB7) are the data pins. There are used to send data to the LCD in bits. In most cases, the D4 to D7 pins are used. The main difference is that data is sent in 4-bits with the D0 to D3 pins, while data is sent in 8-bits with the D4 to D7 pins. There are usually connected to digital pins.
• The LED pins are used to control the backlight of the LCD. In some LCD modules, they may be written as BLA and BLK, or A and K. The first LED pin is connected to 5V using a resistor while the second LED pin is connected to ground (GND).

Example #1 – How to Connect and Use an LCD with Arduino

In the last section, we talked about the meaning of the pins on an LCD. In this section, you'll see a practical example on how to connect them in a circuit, and write code to display data on the LCD.

We'll use the following components:

• Arduino Uno.
• 16 x 2 LCD.
• Potentiometer.
• Jumper wires.
• Resistors.
• Breadboard.

Here's what the circuit diagram looks like:

In the circuit above, we made the following connections from the LCD to the Uno board:

• The LCD's GND pin was connected to GND on the Uno board.
• The LCD's VCC pin was connected to 5V on the Uno board.
• The V0 pin was connected to the potentiometer.
• The RS pin was connected to digital pin 4 on the Uno board.
• The RW pin was connected to GND on the Uno board.
• The LCD's D4 was connected to digital pin 6 on the Uno board.
• The LCD's D5 was connected to digital pin 7 on the Uno board.
• The LCD's D6 was connected to digital pin 8 on the Uno board.
• The LCD's D7 was connected to digital pin 9 on the Uno board.
• The first LED pin was connected to 5V.
• The second LED pin was connected to GND.

For the potentiometer, one of the outer legs (either the left or right) was connected to 5V, the other outer leg was connected to GND. Then the middle leg of the potentiometer was connected to the V0 pin on the LCD. This will enable you to control the contrast of the LCD.

Next, we'll write some code!

#include <LiquidCrystal.h>

LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

void setup() {
  lcd.begin(16, 2);
  lcd.print("freeCodeCamp!");
}

void loop() {

}

In the code above, we first included/imported the built-in LiquidCrystal library which can be used to interact with an LCD using Arduino code: #include <LiquidCrystal.h>.

We then initialized the lcd object with the required pin numbers: LiquidCrystal lcd(4, 5, 6, 7, 8, 9). The first number denotes the RS pin. The second number denotes the E pin. The last four numbers denote the data pins (D4 to D7).

Next, we initialized the number of columns and rows using the lcd.begin() function: lcd.begin(16, 2). We have 16 columns and 2 rows.

The lcd.print function prints data to the LCD. If you've made all the connections right, you should see "freeCodeCamp" displayed on the LCD.

In the next examples, we'll work with user input and sensor data, and also see other lcd functions.

Example #2 – How to Display User Input with LCD in Arduino

In this example, we'll accept input from the user using the serial monitor, and display the input along with a welcome message on the LCD screen.

We'll make use of the same circuit in the previous example. Here's the code:

#include <LiquidCrystal.h>
LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

String userInput;

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);

  lcd.print("Input name");

  lcd.setCursor(0, 1);
}

void loop() {
  if (Serial.available() > 0) {

    userInput = Serial.readString();
    lcd.print("Welcome " + userInput);
  }
}

In the code above, we created a string variable called userInput which will be used to store the value of the user's input.

We then initialized the serial monitor — Serial.begin(9600);

Next, we set the rows and columns of the LCD using the lcd.begin function.

Using the lcd.print function, we printed "Input name" on the LCD screen.

This was followed by the lcd.setCursor(0, 1) function which has two parameters — 0 and 1. 0 represents first column on the left while 1 represents the second row. So the cursor will be set to the second line of the LCD.

We set the cursor to be on the second line because we already have some text ("input name") on the first line so it would be more ideal in this case to print the message to the user on the next line. I'll show you an alternative way to do this after this example.

In the void loop() function, we used the Serial.readString() function to read the value of user's input and stored it in the userInput variable.

Lastly, we printed a welcome message and the user's name in the LCD. This will be printed on the second line because that's where we set the cursor to be.

Play around with the code and see what happens as you adjust the parameters of the lcd.setCursor() function. This will help you understand it better.

Example #2 Alternative

An alternative way to print the message to the user is by using the same line where the initial message was displayed. We can clear whatever is written on the first row of the LCD and display a different value.

Here's how:

#include <LiquidCrystal.h>
LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

String userInput;

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);

  lcd.print("Input name");
}

void loop() {
  if (Serial.available() > 0) {
    lcd.clear();
    userInput = Serial.readString();
    lcd.print("Welcome " + userInput);
  }
}

In this example, we used the lcd.clear() function to clear the initial request message and display/print the welcome message to the user. The rest of the logic is the same.

So when you type in a name in the serial monitor an hit enter, the request message ("Input name") will be cleared while the welcome message will be displayed with the name you inputted.

Example #3 – How to Display Sensor Data with LCD in Arduino

In this example, we'll display data from a sensor on the LCD. We'll use the temperature sensor. The logic here is to sense the temperature of a room and display the varying values on the LCD.

Here are the components we'll use:

• Arduino Uno.
• 16 x 2 LCD.
• Light-Dependent Resistor (LDR).
• Potentiometer.
• Jumper wires.
• Resistors.
• Breadboard.

Here's the circuit diagram:

The circuit diagram is almost the same as the ones in the previous examples, except that we added an LDR to measure the intensity of light. Using the LDR, we'll read, store, and display the value of light intensity on the LCD.

Here's the code:

#include <LiquidCrystal.h>
LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

int ldrPin = A1;
int ldrValue;

void setup() {
  pinMode(ldrPin, INPUT);
  lcd.begin(16, 2);
}

void loop() {
  ldrValue = analogRead(ldrPin);

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("LDR value:");

  lcd.setCursor(0, 1);
  lcd.print(ldrValue);

  delay(1000);
}

Let's break down the code.

We started by including the built-in LiquidCrystal library and initialized the respective pins for working with the LCD (refer to the first example if you do not understand how the connection and initialization works).

We then created two variables: ldrPin which denoted the analog pin connected to the LDR, and ldrValue to store the readings from the LDR.

In void setup(), we configured the LDR as an input pin and set the columns and rows of the LCD.

Next, we read the value of the LDR using the analogRead function and stored that value in the ldrValue variable.

Using the lcd.clear() function, we clear the display after each reading. This helps in making the reading appear more accurately. If you remove the function, then some values will still be on display and make your results appear inaccurately (I spent about thirty minutes figuring this out 😂).

After that, we set the cursor on the first row and column of the LCD: lcd.setCursor(0, 0), and displayed a message ("LDR value:").

Using the lcd.setCursor(0, 1) function, we moved the cursor down to the second row, and used lcd.print(ldrValue) to print/display the value of the LDR on the LCD.

Lastly, we added a delay of 1000 milliseconds.

Now you can see the value of light intensity in your environment displayed on the LCD.

You can use a flashlight to increase and decrease the exposure of light on the LDR, and then observe the values change on the LCD. Pretty cool!

Conclusion

Congratulations! We've come to the end of this handbook. You now have enough knowledge to take on bigger projects.

And that should be your next goal — applying these concepts to projects that aid you and the people around you. There is no limit to what you can create. You can start by watching a couple of videos to see the type of projects people build, then you can come up with yours.

This handbook covered the necessary parts of Arduino (both hardware and software) that you'll need as a beginner to kickstart your journey.

The best way to improve and retain what you've learned is by practicing and building.

Happy tinkering!

A dataframe is two-dimensional data structure in Pandas that organizes data in a tabular format with rows and columns.

In this article, you'll learn how to get the number of rows in a dataframe using the following:

• The len() function.
• The shape attribute.
• The index attribute.
• The axes attribuite.

How to Get the Number of Rows in a Dataframe Using the len() Function

You can use the len() function to return the length of an object. With a dataframe, the function returns the number of rows.

Consider the dataframe below:

import pandas as pd

data = {
  "name": ["John", "Jane", "Jade"],
  "age": [2, 10, 3]
}

df = pd.DataFrame(data)
df

In the example above, we created a dataframe with three rows — row 0, 1, and 2.

You can use the len() function to verify the number of rows:

import pandas as pd

data = {
  "name": ["John", "Jane", "Jade"],
  "age": [2, 10, 3]
}

df = pd.DataFrame(data)
df

num_of_rows = len(df)

print(f"The number of rows is {num_of_rows}")
# The number of rows is 3

In the code above, we passed the dataframe as a parameter to the len() function and stored it in a variable called num_of_rows:

num_of_rows = len(df)

When num_of_rows was printed, we got a value of 3 (the number of rows).

How to Get the Number of Rows in a Dataframe Using the shape Attribute

The shape attribute returns a tuple with the number of rows and columns in a dataframe.

Here's an example using the same dataframe as in the last section:

import pandas as pd

data = {
  "name": ["John", "Jane", "Jade"],
  "age": [2, 10, 3]
}

df = pd.DataFrame(data)
df

num_of_rows = df.shape

print(num_of_rows)
# (3, 2)

In the code above, a tuple — (3, 2) — was returned when we used the shape attribute on the dataframe: df.shape.

The first value, 3, is the number of rows in the dataframe while the second value, 2, is the number of columns.

Since we're only interested in the number of rows, we can extract just that value using its index in the tuple (remember that index numbers start at 0). That is:

import pandas as pd

data = {
  "name": ["John", "Jane", "Jade"],
  "age": [2, 10, 3]
}

df = pd.DataFrame(data)
df

num_of_rows = df.shape[0]

print(f"The number of rows is {num_of_rows}")
# The number of rows is 3

Now we're getting just the number of rows using its index in the tuple: df.shape[0].

How to Get the Number of Rows in a Dataframe Using the index Attribute

You can use the index attribute to access the number of elements in a dataframe, which corresponds with the number of rows.

You can do this in two different ways:

• Using the index attribute's size property.
• Passing the index property as a parameter to the len() function.

Here are examples to explain the methods above:

import pandas as pd

data = {
  "name": ["John", "Jane", "Jade"],
  "age": [2, 10, 3]
}

df = pd.DataFrame(data)
df

num_of_rows = df.index.size

print(f"The number of rows is {num_of_rows}")
# The number of rows is 3

In the example above, we accessed the number of rows in the dataframe using df.index.size.

Without the size property, you'd get a result like this: RangeIndex(start=0, stop=3, step=1).

• start denotes the first index number.
• stop denotes the number of rows in the dataframe.
• step denotes the way indexes are incremented (indexes are increased by 1 in our case).

So the size property is way of specifying that you're only interested in the number of elements in the dataframe.

Here's another example that uses the len() function:

import pandas as pd

data = {
  "name": ["John", "Jane", "Jade"],
  "age": [2, 10, 3]
}

df = pd.DataFrame(data)
df

num_of_rows = len(df.index)

print(f"The number of rows is {num_of_rows}")
# The number of rows is 3

In the code above, we passed df.index as a parameter to the len() function. This returns the number of rows in the dataframe.

The difference between this example and the previous one is that we're not attaching the size property to df.index. Instead, we're using df.index as the len() function's parameter.

How to Get the Number of Rows in a Dataframe Using the axes Attribute

The axes attribute returns the value as the index attribute: RangeIndex(start=0, stop=3, step=1).

Similarly, you can return the number of rows using either the size property or the len() function:

import pandas as pd

data = {
  "name": ["John", "Jane", "Jade"],
  "age": [2, 10, 3]
}

df = pd.DataFrame(data)
df

num_of_rows = df.axes[0].size

print(f"The number of rows is {num_of_rows}")
# The number of rows is 3

import pandas as pd

data = {
  "name": ["John", "Jane", "Jade"],
  "age": [2, 10, 3]
}

df = pd.DataFrame(data)
df

num_of_rows = len(df.axes[0])

print(f"The number of rows is {num_of_rows}")
# The number of rows is 3

The logic in the two code blocks above is the same as those in the last section:

• df.index.size returns the number of elements/rows in the dataframe.
• len(df.index) returns the number of rows in the dataframe.

Summary

In this article, we talked about dataframes in Pandas. They are two-dimensional data structures that organize data in rows and columns.

We saw different methods for getting the number of rows in a dataframe. We discussed the following methods along with code examples to show their application:

• The len() function.
• The shape attribute.
• The index attribute.
• The axes attribuite.

Happy coding! You can learn more about Python on my blog.

In this article, you'll learn how to exit a Python program in the terminal using the following methods:

• The exit() and quit() functions in Windows and macOS (and other Unix-based systems – we'll use macOS to represent them).
• The Ctrl + Z command in Windows.
• The Ctrl + D command in macOS.

How to Run a Python Program in the Terminal

To run Python in the terminal, you have to open your terminal and run the python command.

Note that the Python command will only work in your terminal if you have Python installed on your computer.

After running the command, you should have something like this in the terminal:

C:\Users\USER>python
Python 3.10.8 (main, Nov  6 2022, 23:27:16)  [GCC 12.2.0 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.

Python command in the terminal

I am using Command Prompt for Windows but this should work the same way if you're using macOS or Linux.

Now you can run Python code in the terminal:

>>> print("Welcome to Py in the terminal!")
Welcome to Py in the terminal!

How to Exit a Python Program in the Terminal Using the exit() and quit() Functions

You can use the exit() and quit() functions to exit a Python program in Windows and macOS.

>>> print("Welcome to Py in the terminal!")
Welcome to Py in the terminal!
>>> exit()

C:\Users\USER>

exit() command in Python terminal

In the example above, we printed "Welcome to Py in the terminal!" before exiting the terminal using the exit() function.

After the function is executed, you'll be able to use the terminal the regular way (with the Python environment).

The process is the same for the quit() function:

>>> print("Welcome to Py in the terminal!")
Welcome to Py in the terminal!
>>> quit()

C:\Users\USER>

exit() command in Python terminal

How to Exit a Python Program in the Terminal Using the Ctrl + Command

You can exit a Python program running in a Windows terminal using the Ctrl + Z command:

>>> print("Welcome to Py in the terminal!")
Welcome to Py in the terminal!
>>> ^Z


C:\Users\USER>

ctrl + z command to exit Python terminal in Windows

Similarly, you can use the Ctrl + D command in macOS.

Summary

In this article, we talked about running a Python program in the terminal.

We saw how to run Python in the terminal using the Python command.

We also saw how to exit a Python program in the terminal using a couple different methods.

The exit() and quit() functions can exit a Python program in the terminal for both Windows and macOS.

Alternatively, you can use the Ctrl + Z command to exit a Python program in the terminal in Windows and Ctrl + D in macOS.

Happy coding! You can learn more about Python on my blog.

You can read about the different methods you can use to access, modify, add, and remove elements in a dictionary here.

In this article, you'll learn how to merge two dictionaries using the following:

• The update() method.
• The double asterisk/star operator (**).
• The chain() method.
• The ChainMap() method.
• The merge operator (|).
• The update operator (|=).

How to Merge Two Dictionaries in Python

In this section, we'll discuss the different methods you can use to merge dictionaries in Python, along with code examples.

All the examples you'll see in this article will involve the merging of two dictionaries, but you can merge as many as you want.

How to Merge Two Dictionaries in Python Using the update() Method

The update() method is a built-in method that you can use to add data to dictionaries.

Consider the dictionary below:

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

devBio.update({"role": "Technical Writer"})

print(devBio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'role': 'Technical Writer'}

In the code above, we created a dictionary called devBio with three key and value pairs: {'name': 'Ihechikara', 'age': 50, 'language': 'Python'}.

Using the update() method, we added another key and value pair: devBio.update({"role": "Technical Writer"}).

In the same manner, we can merge two dictionaries by passing another dictionary as a parameter to the update() method. Here's an example:

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

devBio.update(tools)

print(devBio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

In the code above, we created two dictionaries — devBio and tools.

Using the update() method, we merged the key and value pairs of the tools dictionary to the devBio dictionary: devBio.update(tools).

The merged dictionaries looked like this:

{
    'name': 'Ihechikara', 
    'age': 500, 
    'language': 'Python', 
    'dev environment': 'JupyterLab', 
    'os': 'Windows', 
    'visualization': 'Matplotlib'
}

How to Merge Two Dictionaries in Python Using the Double Asterisk Operator (**)

You can use the double asterisk (also called double star) operator (**) to "unpack" and merge the key and value pairs of two or more dictionaries into a variable.

Here's a code example:

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

merged_bio = { **devBio, **tools}

print(merged_bio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

In the code above, we unpacked the devBio and tools dictionaries using the double asterisk operator: { **devBio, **tools}.

We then stored them in a variable called merged_bio.

How to Merge Two Dictionaries in Python Using the chain() Method

The chain() method takes multiple iterable objects as its parameter. It merges and returns the objects as one iterable object.

You have to import the chain() method from the itertools module before using it:

from itertools import chain

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

merged_bio = dict(chain(devBio.items(), tools.items()))

print(merged_bio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

In the code above, we passed the dictionaries to be merged as parameters to the chain() method: chain(devBio.items(), tools.items()).

We used the items() method to access the key and value pairs of each dictionary.

Lastly, we nested the chain() method and its parameters in the dict() method: dict(chain(devBio.items(), tools.items())).

The dict() method can be used to create a dictionary so we used it to convert the iterable objects returned (the key and value pairs) into a dictionary, and stored them in the merged_bio variable.

How to Merge Two Dictionaries in Python Using the ChainMap() Method

The ChainMap() method works the same way as the chain() method as regards to merging dictionaries. The main difference is that you don't need the items() method to access the key and value pairs of the dictionaries.

You can import the ChainMap() method from the collections module.

Here's how you can use the ChainMap() method to merger two dictionaries:

from collections import ChainMap

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

merged_bio = dict(ChainMap(devBio, tools))

print(merged_bio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

You can check the explanation in the last section to understand the logic in the code above.

How to Merge Two Dictionaries in Python Using the Merge Operator (|)

The merge operator (|) was first introduced in Python 3.9. It's a shorter and simpler syntax that you can use to merge dictionaries.

Here's an example:

from collections import ChainMap

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

merged_bio = devBio | tools

print(merged_bio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

So to merge the devBio and tools dictionary, we put the | operator between them: devBio | tools.

How to Merge Two Dictionaries in Python Using the Update Operator (|=)

The update operator (|=) operator is another operator that was introduced in Python 3.9.

It works just like the update() method. That is:

from collections import ChainMap

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

devBio |= tools

print(devBio)
# {'name': 'Ihechikara', 'age': 50, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

In the code above, we used the |= to mege the key and value pairs in the tools dictionary into the devBio dictionary.

Summary

In this article, we talked about dictionaries in Python. You can use them to store data in key-value pairs.

We saw how to merge two dictionaries in Python using:

• The update() method.
• The double asterisk/star operator (**).
• The chain() method.
• The ChainMap() method.
• The merge operator (|).
• The update operator (|=).

Each method had its own section with code examples that showed how to use them to merge dictionaries.

Happy coding! You can learn more about Python on my blog.

There are different bitwise operators like the bitwise AND (&), bitwise OR (|), bitwise XOR (^), and so on.

In this article, we'll focus on the bitwise XOR (^) operator. You'll learn about its mode of operation along with some practical examples.

How the Python XOR Operator Works

The XOR operator first converts the integers involved in the operation to their binary format. The operator then evaluates the corresponding bits of the binary values.

When two bits are evaluated, the value returned will be dependent on the bits. If both bits are 0, 0 is returned. If both bits are 1, 0 is returned. If either of the bits is 1 while the other is 0 then 1 will be returned.

So the XOR operator will only return 1 when two bits have different values. That is:

0 ^ 0 = 0.
1 ^ 1 = 0.
1 ^ 0 = 1.
0 ^ 1 = 1.

After evaluating all the corresponding bits, the resulting binary value will be returned in base 10.

Don't worry if the explanations above seem confusing – the examples in the next section should simplify how the XOR operator works.

Python XOR Operator Example

In this section, you'll see code examples that show how the bitwise XOR operator works.

x = 12
y = 10

print(x ^ y)
# 6

In the code above, we created two variables x and y with 12 and 10 as their respective values.

Using the XOR operator — x ^ y — we got 6 returned.

Let's break the code down to see how we got a value of 6 from the operation.

Step #1 - Conversion to Binary Values

We started with two values (12 and 10):

x = 12
y = 10

These values have to be converted to their binary format by the XOR operator before the operations starts.

The binary value of 12 is 1100 while the binary value of 10 is 1010.

Step #2 - Evaluating Corresponding Bits

Now that the values have been converted to their binary formats, the next thing that the XOR operator does is to compare corresponding bits.

So the first bit in 1100 will be compared to the first bit in 1010. The second bit in both binary values will be compared next. This comparison will continue until there are no bits left to compare.

Recall that we discussed how the XOR operator returns a value from each comparison:

0 ^ 0 = 0.
1 ^ 1 = 0.
1 ^ 0 = 1.
0 ^ 1 = 1.

Using the logic above, lets compare the bits in both operands — 1100 and 1010. We'll denote them as operand A and B, respectively.

Operand A's first bit value = 1. Operand B's first bit value = 1.
1 ^ 1 = 0.

Operand A's second bit value = 1. Operand B's second bit value = 0.
1 ^ 0 = 1.

Operand A's third bit value = 0. Operand B's third bit value = 1.
0 ^ 1 = 1.

Operand A's fourth bit value = 0. Operand B's fourth bit value = 0.
0 ^ 0 = 0.

When we collect the resulting values from each comparison, we have 0110 which is the same as 6 in base 10.

The bit comparisons above explain how the code in the last section returned a value of 6. That is:

x = 12
y = 10

print(x ^ y)
# 6

Summary

In this article, we talked about bitwise operators in Python. They are used to perform operations involving the individual bits of integers.

We talked about the bitwise XOR (^) operator which converts integers to their binary format, and the compares their corresponding bit values.

We saw an example that showed how the XOR operator works under the hood.

Happy coding! You can learn more about Python on my blog.

You can also parse a string by converting it to an integer or float variable. Although this should be categorized as a type conversion operation, you'll come across resources that refer to it as string parsing.

In this article, you'll learn how to parse a string using the split() and strip() methods. You'll also learn how to convert a string to an integer using the int() function.

How To Parse a String in Python Using the split() Method

You can use the split() method in Python to "split" substrings of a string into a list.

Here's what the parameter looks like:

string.split(separator, maxsplit)

The split() method has two optional parameters:

• separator specifies where to start splitting from (you'll understand this better with the examples in the next section).
• maxsplit specifies the maximum number of splits.

split() Method Example #1 - How To Use the Separator Parameter

favorite_languages = "JavaScript, Python, and Java"

lang_split = favorite_languages.split(",")

print(lang_split)
# ['JavaScript', ' Python', ' and Java']

In the example above, we created a string called favorite_languages which had three substrings: "JavaScript, Python, and Java".

Using the split() method, we specified that each substring should be split after each comma in the string: favorite_languages.split(",").

The result was a list of each substring: ['JavaScript', ' Python', ' and Java'].

This example shows how to use the first parameter of the split() method. The next example will help you understand the second parameter.

split() Method Example #2 - How To Use the Maxsplit Parameter

favorite_languages = "JavaScript, Python, and Java"

lang_split = favorite_languages.split(",", 1)

print(lang_split)
# ['JavaScript', ' Python, and Java']

In the code above, we made use of the maxsplit parameter which specifies the number of splits to be performed.

So favorite_languages.split(",", 1) means that only one substring should be split, while the rest would remain as they were in the original string.

In the output of the code, only JavaScript was split, while Python and Java retained their initial positions in the string. That is: ['JavaScript', ' Python, and Java'].

How To Parse a String in Python Using the strip() Method

You can use the strip() method to remove white spaces or specified characters in a string.

Here's what the syntax looks like:

string.strip([chars])

The chars parameter specifies the set of characters to be removed. This parameter is optional, so leaving the parenthesis empty will only remove white spaces.

Let's see some examples.

strip() Method Example #1

username = "       Doe      "

user = username.strip()

print(user) 
# Doe

In the example above, we had a string with leading and trailing whitespace characters: " Doe ".

Using the strip method without any parameter, we got rid of the whitespaces: username.strip().

In the next example, we'll pass in parameters to the strip() method.

strip() Method Example #2

In this section, we'll use a string that has different characters in it that aren't whitespaces:

username = "=+---Doe---+="

The goal here is to get rid of the unwanted characters (=+-) found in the username variable.

If you use the strip() method without any parameters, it won't get rid of those characters. Without parameters, the strip() method only removes whitespaces.

To remove the characters in the string, you have to use them as a parameter to tell the strip() method that they should be removed. That is:

username = "=+---Doe---+="

user = username.strip("=+-")

print(user) 
# Doe

In the code above, we passed in the characters to be removed from the string as a parameter to the strip() method: username.strip("=+-").

Note that you have to nest those characters in quotation marks ("=+-").

How To Convert a String to an Integer Using the int() Function

Data type conversion helps you perform certain operations that involve incompatible data types.

For instance, the example below shows what happens when you try to add an integer and a string:

age = "300"

print(age + 300) 
# TypeError: can only concatenate str (not "int") to str

In the code above, we created a string value with a value of "300". When we tried adding it to an integer value of 300, we got an error.

The error is thrown because the compiler assumes we're trying to add two strings. String concatenation in Python cannot be performed using a string and an integer.

To solve this problem, you can convert the string to an integer before using it in a mathematical operation.

Here's how you can do that using the int() function:

age = "300"

age_to_int = int(age)

print(age_to_int + 300) 
# 600

In the code above, we used the int() function to convert the age string to an integer: int(age).

Now, you're to use the variable as an integer.

A common use case for converting from a string to an integer is seen when getting input from a user. You can see an example like that in this article.

Summary

In this article, we talked about parsing strings in Python.

We saw examples that showed how to parse a string using the split() and strip() methods.

We also saw how to convert a string to an integer using the int() function.

Happy coding! I also write about Python on my blog.