DigitalReef

It all started when we ordered an actuator, with an encoder, from China for a project. But something went wrong, and a month later, we received actuators without an encoder. It was necessary to complete the project code urgently, but it would not be possible to control the actuators without encoders. For the project, you need to know the rod extension length, and for this, you need to know the number of engine rotations. So we decided to spend one day and make our encoder for actuators. At first, we thought to put a multi-turn potentiometer. But there can be a lot of rotations, and we didn’t have such an encoder at hand. Then we wanted to use an encoder like , EC11 but such encoders have a very small resource of work.
And in the end, we chose the option: of two digital hall sensors and magnets. SS443A The SS443A hall sensor outputs a logic HIGH on one polarity of magnets and a logic LOW on the other and retains that value even when the magnet is removed. If briefly: We take two hall sensors and put them at an angle of 45 degrees to each other. We glue two magnets to the motor axis, with different poles, and when the motor is spinning, each sensor turns on and off in turn. If each sensor turned on and off one time, then there was one turn of the engine. With two sensors, we can count a quarter of a turn. And knowing the sequence of turning on and off the sensors, we can determine the direction of rotation. We dismantled the actuator to find a place to mount the magnets. No place was there, and magnets could not be glued because everything was oily with grease. Then we decided to throw away the original cap of the actuator, which will have a built-in gear with magnets and two hall sensors. The gear will be driven, and we will place the gear on a separate axis. And the gear will spin without load from the drive gear of the engine. We took two magnets with a diameter of 5mm and a thickness of 4mm. In SolidWorks, with the help of the “GearTrax” plugin, we drew the gear of the required size and drew the case cap for the actuator with a 6-pin GX16 connector. We printed the case on a 3D printer from PETG plastic, and on the 3rd attempt, we got a working mechanism. It took about 11 hours for all these, along with 3D printing. All that’s left is to write the code to calculate the length of the rod extension. For the test, we took the Arduino MEGA 2560 board; there are six pins with hardware interrupts. You can make the code without interruptions, but if at least one pulse (a quarter of a turn) is skipped, the error will be 1.6mm, and this is already a lot for our task. Tests have shown that without interruptions, the error can accumulate to large values with active use. Therefore, we use two interrupt pins for each actuator. 1 pin = 1 hall sensor. The code, in the end, turned out to be quite simple, but I decided to leave it here as a cheat sheet for the future, or maybe it will come in handy for someone else: const byte M1_HALL1_pin = 20; //connect pintout Hall sensor 1
const byte M1_HALL2_pin = 21;	//connect pintout Hall sensor 2

const byte M1_HALL1_pin_interupt = 3; //Interrupt pin3 match Pin20 Arduino Mega
const byte M1_HALL2_pin_interupt = 2; //Interrupt pin2 match Pin21 Arduino Mega

volatile byte M1_HALL_cur_state = B00; //Current state hall sensors. If Hall1 and Hall2 is LOW then variable value is B00
volatile byte M1_HALL_last_state = B00; //Last state hall sensors. If Hall1 is HIGH and Hall2 is LOW then variable value is B10

volatile long countPulsesM1 = 0; //Counter

/*
Arrays dirUpM1 and  dirDownM1 have directions of rotation.
*/
byte dirUpM1[] = {1,3,0,2}; 	//01 11 00 10
byte dirDownM1[] = {2,0,3,1}; 	//10 00 11 01

void setup(void){
  attachInterrupt(M1_HALL1_pin_interupt, countRotationInteruptsM1, CHANGE);
  attachInterrupt(M1_HALL2_pin_interupt, countRotationInteruptsM1, CHANGE);

  //Be sure to pullup the pins to avoid noises
  pinMode(M1_HALL1_pin, INPUT_PULLUP); 
  pinMode(M1_HALL2_pin, INPUT_PULLUP); 

  Serial.begin(9600);
}

void loop(void){
  Serial.println(countPulsesM1);
}

void countRotationInteruptsM1(){
  //Present cur status of hall sensor as binary number
  M1_HALL_cur_state = digitalRead(M1_HALL1_pin);  //Read HALL1 state (for example: if HALL1 is HIGH then value is  B01)
  M1_HALL_cur_state = M1_HALL_cur_state << 1; //Shift the bit to make room for the second value (for example: value is  B10)
  M1_HALL_cur_state += digitalRead(M1_HALL2_pin); //Read HALL2 state and ADD it to HALL1 value (for example: if HALL2 is HIGH too, then value is B11)

	//If in an array dirUpM1 of sequences, the previous value is followed by the current, means the actuator moves up
	if(dirUpM1[M1_HALL_cur_state] == M1_HALL_last_state){
		countPulsesM1++;
	//else  the actuator moves up
	} else if(dirDownM1[M1_HALL_cur_state] == M1_HALL_last_state){
		countPulsesM1--;
		if(countPulsesM1 < 0){
			countPulsesM1 = 0;
		}
	}
} Arrays dirUpM1 and  dirDownM1 have directions of rotation.
As the gear turns, the hall sensors will turn on and off one after the other. For example: at first, HALL1 and HALL2 is LOW. This can be written as binary B00 then HALL1 is LOW, and HALL2 is HIGH. This can be written as binary B01 then HALL1 and HALL2 are HIGH. This can be written as binary B11 then HALL1 is HIGH, and HALL2 is LOW. This can be written as binary B10 and then the cycle repeats 00 - 01
01 - 11
11 - 10
10 - 00 This can be represented as a combination: 0 - 1
1 - 3
3 - 2
2 - 0 If you convert binary numbers to decimals, it will look like this: Now let's represent it as an array: arrD[0] = 1; arrD[1] = 3; arrD[3] = 2; arrD[2] = 0; byte dirUpM1[] = {1,3,0,2}; And finally: If suddenly the connection of the hall sensors changes, the array with the direction can be “trained”: void setDerectionUp(){	
  if(M1_HALL_cur_state != M1_HALL_last_state){
    dirUpM1[M1_HALL_last_state] = M1_HALL_cur_state;
    M1_HALL_last_state=M1_HALL_cur_state;
  }
  if(M2_HALL_cur_state != M2_HALL_last_state){
  	dirUpM2[M2_HALL_last_state] = M2_HALL_cur_state;
  	M2_HALL_last_state=M2_HALL_cur_state;
  }
} The factory actuator with an encoder costs: $41
Actuator without encoder + homemade encoder costs: $26 + $4 = $30 PS:

My Experience with Length Control for a DC Actuator

I have figured out a way to develop the popular pong game on the Arduino board. The game is not complicated but interesting to develop and play. Here 0.96 inch OLED display and two buttons have been used. The display is small but enough for our project. Two buttons will be used to move our racket up and down. The The first and last 16 pixels will be used to display scores. display size is 128x64 pixels. The scores will be displayed vertically. One racket will be controlled by the player, and the second one, the opponent will be controlled by the Arduino. We will write code so that it will try to move towards the ball. At the beginning of the game, it will move slowly, and then, it will gradually accelerate. We will control the ball direction through ball_direction_X and ball_direction_Y variables. The ball will move in a specified direction each moment. If the ball hits a wall, ball_direction_Y will be reversed and the same logic for ball_direction_X and rackets. The project code is published on my GitHub . ‘Arduino Ping Pong Game’ project page Connection Buttons’ one leg will be connected to the GND. The second legs will be connected to pins 6 and 5 of the Arduino. The display will be connected by I2C pins: V - 5V, GND - GND, SCL - A5, SDA - A4. Developing Pong on Arduino Let’s include libraries and initiate all variables we need. Here we have buttons, scores, player, opponent, and the ball-related variables. //oled libraries:
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
//oled vars:
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
#define OLED_RESET     4 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

//Button pins:
const int buttonUP = 6;
const int buttonDOWN = 5;
//button vars:
int lastButtonStateUP = LOW;   // the previous reading from the input pin
int lastButtonStateDOWN = LOW;   // the previous reading from the input pin
unsigned long debounceDelay = 10;    // the debounce time; increase if the output flickers

//GAME vars:
//scores:
int player_score = 0;
int enemy_score = 0;

//player:
int player_position_X = 19; // static
int player_position_Y = 0;
int player_width = 16;
int player_thickness = 4;

//enemy:
int enemy_position_X = 104; // static
int enemy_position_Y = 47;
int enemy_width = 16;
int enemy_thickness = 4;
long enemy_last_move_time = 0;
long enemy_speed_of_moving = 2000;//update time in ms


//ball:
//void fillCircle(uint16_t x0, uint16_t y0, uint16_t r, uint16_t color);
int ball_position_X = 63;
int ball_position_Y = 31;
int ball_radius = 1;
int ball_direction_X = 3;
int ball_direction_Y = 3;
int ball_speed = 8;//9,8,7...1
long ball_last_move_time = 0; In the , we will initiate buttons, Serial, randomSeed, and display. After that, we will show a starter screen and start the game: setup void setup() {
  pinMode(buttonUP, INPUT_PULLUP);
  pinMode(buttonDOWN, INPUT_PULLUP);

  Serial.begin(9600);
  Serial.println("Start");

  //initiate random
  randomSeed(analogRead(0));
  ball_direction_X = -3;
  ball_direction_Y = random(-5, 5);
  //ball_direction_Y = -5;//test

  
  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }

  // Show initial display buffer contents on the screen --
  // the library initializes this with an Adafruit splash screen.
  display.display();
  
  // Clear the buffer
  display.clearDisplay();
  
  
  //draw lines:
  display.drawLine(16,  0,  16, 63, SSD1306_WHITE);
  display.drawLine(111, 0, 111, 63, SSD1306_WHITE);
  display.display();
  
  //scores field init:
  display.setTextSize(2);    
  display.setTextColor(SSD1306_WHITE); // Draw white text

  player_score = 8888; // test
  enemy_score = 8888; // test
  print_score(player_score, 0);
  print_score(enemy_score, 115);
  
  display.setTextSize(3);
  display.setCursor(28, 0);
  display.write("Ping");
  display.setCursor(28, 31);
  display.write("Pong");
  display.display();
  
  display.setTextSize(2);
  delay(2000); // Pause for 2 seconds
  
  //NEW GAME:
  
  // Clear the buffer
  display.clearDisplay();
  
  //draw lines:
  display.drawLine(16,  0,  16, 63, SSD1306_WHITE);
  display.drawLine(111, 0, 111, 63, SSD1306_WHITE);
  display.display();
  
  //Write scores:
  player_score = 0; //reset player_score
  enemy_score = 0;  //reset enemy_score
  print_score(player_score, 0);
  print_score(enemy_score, 115);
  
  //Display players:
  //void fillRect(uint16_t x0, uint16_t y0, uint16_t w, uint16_t h, uint16_t color);
  display.fillRect(player_position_X, player_position_Y, player_thickness, player_width, SSD1306_WHITE);
  display.fillRect(enemy_position_X, enemy_position_Y, enemy_thickness, enemy_width, SSD1306_WHITE);
  display.display(); // Update screen with each newly-drawn rectangle

  
  //Display the ball:
  display.fillCircle(ball_position_X, ball_position_Y, ball_radius, SSD1306_WHITE);
  display.display();

  delay(500); // Pause for 0.5 second  
} In the , we have three main functions which will be explained in detail below. loop void loop() {
  buttons_check();

  move_the_ball_and_check_for_collisions();

  move_enemy();
} In the function, we will check if the UP or DOWN button is pressed and update the position of the player's racket accordingly. The racket position change is done in three main steps: Drawing a black rectangle in the old position, changing the position variable, and drawing a white rectangle in the new position. buttons_check void buttons_check(){ 
  if (!digitalRead(buttonUP) && !lastButtonStateUP) {
    lastButtonStateUP = true;
//    Serial.println("UP pressed");
    if(player_position_Y > 0){
      display.fillRect(player_position_X, player_position_Y, player_thickness, player_width, SSD1306_BLACK);
      player_position_Y = player_position_Y-3;
      display.fillRect(player_position_X, player_position_Y, player_thickness, player_width, SSD1306_WHITE);
      display.display(); // Update screen with each newly-drawn rectangle
    }
  }
  if (digitalRead(buttonUP) && lastButtonStateUP) {
    lastButtonStateUP = false;
  }


  if (!digitalRead(buttonDOWN) && !lastButtonStateDOWN) {
    lastButtonStateDOWN = true;
//    Serial.println("DOWN pressed");
    if(player_position_Y < 64-player_width){
      display.fillRect(player_position_X, player_position_Y, player_thickness, player_width, SSD1306_BLACK);
      player_position_Y = player_position_Y+3;
      display.fillRect(player_position_X, player_position_Y, player_thickness, player_width, SSD1306_WHITE);
      display.display(); // Update screen with each newly-drawn rectangle
    }
  }
  if (digitalRead(buttonDOWN) && lastButtonStateDOWN) {
    lastButtonStateDOWN = false;
  }
} In the function, we will move the ball and check for collisions with horizontal walls, rackets, and vertical walls (player win or lose). Before moving the wall, we will check the required time passed from the last move of the ball. I have set the required time as ball speed multiplied by twenty. To display the ball we will draw a filled circle. In general, the ball position update will be done in the same way as the racket position update. move_the_ball_and_check_for_collisions To check for collision of the ball with one of the horizontal walls we need to make sure that the add up of ball_position_Y and ball_direction_Y is in the range between 0 and 63 (not less than -1 and not greater than 64). If so, the ball_direction_Y will be reversed. To check if the player’s racket missed the ball we need to check if ball_position_X is less than player_position_X and start a new round of the game. The same logic for the enemy's racket, only since it is placed on the other side of the field the check will be for more.To check if the player’s racket hit the ball we will check if the ball is inside of the racket. If so, the ball_direction_X will be reversed and a random value for ball_direction_Y will be given. As always the same logic for hitting the ball with the enemy’s racket. void move_the_ball_and_check_for_collisions(){
  //move th ball:
  if(millis() > ball_speed*20+ball_last_move_time){
    //erase ball on old position:
    display.fillCircle(ball_position_X, ball_position_Y, ball_radius, SSD1306_BLACK);
    display.display();
    
    //set new posion of the ball:
    ball_position_X = ball_position_X + ball_direction_X;
    
    if(ball_position_Y + ball_direction_Y < -1) ball_direction_Y = ball_direction_Y * -1;
    if(ball_position_Y + ball_direction_Y > 64) ball_direction_Y = ball_direction_Y * -1;
    
    ball_position_Y = ball_position_Y + ball_direction_Y;
    
    //draw ball on new position:
    display.fillCircle(ball_position_X, ball_position_Y, ball_radius, SSD1306_WHITE);
    display.display();
//    Serial.print("ball_position_Y: "); Serial.println(ball_position_Y);
    ball_last_move_time = millis();

    //Check for player loose:
    if(ball_position_X < player_position_X){
      Serial.println("Player lose!");
      newRound("enemy");//player
    }
    //check for collision of the ball and the player:
    if(player_position_X <= ball_position_X && player_position_X+player_thickness >= ball_position_X
    && player_position_Y <= ball_position_Y && player_position_Y+player_width >= ball_position_Y){
      Serial.println("Collision of the ball and the player");
      //send the ball to enemy with random values:
      ball_direction_X = 3;
      ball_direction_Y = random(-5, 5);
      display.fillRect(player_position_X, player_position_Y, player_thickness, player_width, SSD1306_WHITE);
      display.display(); // Update screen with each newly-drawn rectangle
      
    }
    //check for enemy loose:
    if(ball_position_X > enemy_position_X+enemy_thickness){
      Serial.println("Enemy lose!");
      newRound("player");//enemy
    }
    //check for collision of the ball and the enemy:
    if(enemy_position_X <= ball_position_X && enemy_position_X+enemy_thickness >= ball_position_X
    && enemy_position_Y <= ball_position_Y && enemy_position_Y+enemy_width >= ball_position_Y){
      Serial.println("Collision of the ball and the enemy");
      //send the ball to player with random values:
      ball_direction_X = -3;
      ball_direction_Y = random(-5, 5);
      display.fillRect(enemy_position_X, enemy_position_Y, enemy_thickness, enemy_width, SSD1306_WHITE);
      display.display(); // Update screen with each newly-drawn rectangle
    }
  } 
} As you noticed above, the function takes as input winner (player/enemy). The input is required to increase the appropriate score. In the function, we will reset all the required game-related variables, print updated scores, display all game objects, and if required update the speed of the enemy and ball. The game will become more difficult as you progress through it. newRound void newRound(String winner){
  // Clear the buffer
  display.clearDisplay();
  
  //draw lines:
  display.drawLine(16,  0,  16, 63, SSD1306_WHITE);
  display.drawLine(111, 0, 111, 63, SSD1306_WHITE);
  display.display();
  
  //Update scores:
  if(winner == "enemy"){
    enemy_score++;
  }else{
    player_score++;
  }
  print_score(player_score, 0);
  print_score(enemy_score, 115);

  //reset gaming vars:
  //player:
  player_position_X = 19; // static
  player_position_Y = 0;
  player_width = 16;
  player_thickness = 4;
  
  //ball:
  ball_position_X = 63;
  ball_position_Y = 31;
  ball_radius = 1;
  //set random direction for th ball:
  
  ball_direction_X = -3;
  ball_direction_Y = random(-5, 5);
  //ball_direction_Y = -5;//test
  ball_last_move_time = 0;
  
  //Display players:
  //void fillRect(uint16_t x0, uint16_t y0, uint16_t w, uint16_t h, uint16_t color);
  display.fillRect(player_position_X, player_position_Y, player_thickness, player_width, SSD1306_WHITE);
  display.display(); // Update screen with each newly-drawn rectangle

  //enemy:
  enemy_position_X = 104; // static
  enemy_position_Y = 47;
  enemy_width = 16;
  enemy_thickness = 4;
  enemy_last_move_time = 0;

  //checking for if we need to update enemy_speed_of_moving and ball_speed
  if((player_score+enemy_score)%5 == 0){
    //5,10,15 and so on
    if(ball_speed > 3) ball_speed = ball_speed - 1; //10,9,8...
    Serial.print("ball_speed: ");Serial.println(ball_speed);
  }
  if((player_score+enemy_score)%10 == 0){
    //10,20,30 and so on
    if(enemy_speed_of_moving > 1) enemy_speed_of_moving = enemy_speed_of_moving * 0.9; //2000,1800,1620,1458...
    Serial.print("enemy_speed_of_moving: ");Serial.println(enemy_speed_of_moving);
  }
  
  delay(500); // Pause for 0.5 seconds
} Printing scores vertically is a little tricky. So, I decided to split it into a separate function. Each digit of the score will be displayed one by one and the cursor needs to be updated accordingly. void print_score(int temp_num, int X){ //0/115
  for(int i=48; i>=0; i-=16){
    
    int num = temp_num % 10;
    char cstr[16];
    itoa(num, cstr, 10);
    
    display.setCursor(X, i);
    display.write(cstr);
    display.display();
//    Serial.println(cstr);
    temp_num = temp_num/10;
    if(temp_num==0){
      break;
    }
  }
} And the last one is . It will try to hit the ball. And for this, it will try to equalize its center with the center of the ball. Here we have some supplemental checks to stay the racket inside the screen. In order for such an enemy to be won, its movement speed will be slow in the beginning and will accelerate as the game progresses. moving the enemy racket void move_enemy(){
  //enemy:
  if(millis() > enemy_speed_of_moving+enemy_last_move_time){
    display.fillRect(enemy_position_X, enemy_position_Y, enemy_thickness, enemy_width, SSD1306_BLACK);
    
    if(ball_position_Y < enemy_position_Y+enemy_width/2){
      enemy_position_Y = enemy_position_Y - 3;
    }else{
      enemy_position_Y = enemy_position_Y + 3;
    }

    //checking if enemy is within the wall:
    if(enemy_position_Y > 64-player_width) enemy_position_Y = 64-player_width;
    if(enemy_position_Y < 0) enemy_position_Y = 0;
      
//    Serial.print("enemy_position_Y: "); Serial.println(enemy_position_Y);
    display.fillRect(enemy_position_X, enemy_position_Y, enemy_thickness, enemy_width, SSD1306_WHITE);
    display.display(); // Update screen with each newly-drawn rectangle
    enemy_last_move_time = millis();
  } 
} Conclusion I hope you enjoyed both the development of the game and playing the game. The game is familiar to many since childhood and nostalgia are felt when playing. Developers have a unique opportunity to get to know the game not only from the outside, but to see how everything works from the inside. Here are some ideas for enhancements to the project: Currently, the game is endless. It would be great to implement the Official Rules of Table Tennis to determine a winner. As the speed of the ball increases, make a visual effect so that the ball has a tail. The angle of flight of the ball during the rebound should be made dependent on the place where the ball touches the racket.

How I Developed the Classic Pong Game on an Arduino Board

Cómo desarrollé el clásico juego de pong en una placa Arduino

Comment j'ai développé le jeu Classic Pong sur une carte Arduino

मैंने एक Arduino बोर्ड पर क्लासिक पोंग गेम कैसे विकसित किया

Arduino ボードで古典的な Pong ゲームを開発した方法

Como desenvolvi o clássico jogo Pong em uma placa Arduino

Cách tôi phát triển trò chơi Pong cổ điển trên bảng Arduino

我如何在 Arduino 板上开发经典乒乓球游戏

In this article, we will develop an Arduino Starship game which will be displayed on LCD display 16x2. The game will be controlled by a joystick and by a computer through the Serial Monitor. In addition, we will store a high score in EEPROM and update them when the record is broken. The project code is published on my GitHub . In the article, we will deal with each element separately and how it will all work together. ‘Arduino_Starship_Game’ project page The project is interesting and opens up opportunities to learn new: How does an LCD display work How to make and display a custom character on the LCD display How to read data from the Serial Monitor How does a joystick work How to read and write data to EEPROM (non-volatile memory) In the game, the player controls the starship. In front of the flying starship will be some enemies. As there will be a collision of the starship with one of the enemies, the game will be over. Starship has a bullet to fire but with a limit. The limit for the bullet is only one bullet at a time. It means, that while we can see the bullet on the screen, no more bullets can be fired, we should wait until it collides with one of the enemies or disappears from the screen. Video of the gameplay: https://www.youtube.com/watch?v=HW6j_PRgFx4 First, we will go through each element individually. Then we will figure out how all this will interact to make the game run. If you know how an element works, you can skip to the next section. LCD display Let's start with the LCD display. In the project, I have been using the popular LCD Display 16x2 which can be found almost in every Arduino kit. In my case the display comes with an I2C LCD Adapter and the connection will be GND-GND, VCC-5V, SDA-A4, and SCL-A5. Code As always, first of all, we need to include libraries: #include <Wire.h> 
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 16, 2); In the LiquidCrystal_I2C lcd(0x3F, 16, 2) function we define the address of our I2C LCD Adapter. And Yes, it means, we can connect many I2C elements to Arduino. The address by default is 0x3F or 0x27. The next two elements are the size of our display. Here is how we initiate and display text: void setup()
{
  lcd.begin();
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Hello World!");
  lcd.setCursor(0,1);
  lcd.print("Chingiz");  
} lcd.begin() - initiates the lcd.
lcd.backlight() - turns on LCD backlight.
lcd.clear() -  clears the display
lcd.setCursor(0,0) - sets cursor to the written position. Please note that the first digit is X axis and the second digit is Y axis.
lcd.print("Hello World!") - prints the written text to the LCD. Custom characters Each display digit consists of 5x8 pixels. To create a custom character as a spaceship, we need to define and initiate it: byte c1[8]={B00000,B01010,B00000,B00000,B10001,B01110,B00000,B00000}; //Smile-1
byte c2[8]={B10000,B10100,B01110,B10101,B01110,B10100,B10000,B00000}; //Starship-2

//In setup:
lcd.createChar(0 , c1);   //Creating custom characters in CG-RAM
lcd.createChar(1 , c2);   //Creating custom characters in CG-RAM As you can see the custom character creation is done by using a byte with a length of five which stands for one line and we have eight of them to have one custom digit. I found a that will be helpful with LCD custom character creation. Here you can draw your custom character and the code will be automatically generated for it: site And here is how we display our custom character(s): lcd.print(char(0));
lcd.print(char(1)); Joystick The joystick has a button, X and Y-axis. The button works as usual. The X and Y axis can be thought of as a potentiometer, which provides data between 0 and 1023. A default value is half of that. We will use only the X-axis to control the starship. I have connected the SW to pin 2 and X-axis to A1. Here is the initiation of the joystick: // Arduino pin numbers
const int SW_pin = 2; // digital pin connected to switch output
const int X_pin = 1; // analog pin connected to X output

//In setup:
  //joystick initiation 
  pinMode(SW_pin, INPUT);
  digitalWrite(SW_pin, HIGH); //default value is 1 Reading the Joystick data and detecting commands: //In loop:
  //Joystick input to commands:
  if(digitalRead(SW_pin)==LOW){
    //Fire bullet detected
  }
  if(analogRead(X_pin)>612){
    //Go up command detected
  }
  if(analogRead(X_pin)<412){
    //Go down command detected
  } Game development Initiation Let’s include all libraries and initiate all required variables for the game: I tried to name each variable so that it was clear what it is for. Three custom characters: starship, enemy, and bullet. Lcd array 2x16, which has been used to easily debug the game. game_score and game_start are used to get the score of the game. and we have some variables related to the bullet and enemies. #include <Wire.h> 
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 16, 2);
#include <EEPROM.h>
byte c1[8]={B10000,B10100,B01110,B10101,B01110,B10100,B10000,B00000}; //Starship
byte c2[8]={B00100,B01000,B01010,B10100,B01010,B01000,B00100,B00000}; //Enemy
byte c3[8]={B00000,B00000,B00000,B00110,B00110,B00000,B00000,B00000}; //Bullet

String lcd_array[2][16] = 
  {{"}"," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "},
   {" "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "}}; 

/*
} - Starship
> - Bullet
< - Enemy
*/

const unsigned int MAX_MESSAGE_LENGTH = 12;
int starship_possiton = 0;
bool game_is_in_progress = false;
unsigned long game_score = 0;
unsigned long game_start = 0;
bool bullet_is_in_progress = false;
int bullet_possiton[2];
unsigned long bullet_last_move = 0;
unsigned long bullet_speed = 100;
bool enemies_array[5] = {false,false,false,false,false};//{false,true,true,true,true};//
long randNumber;
int enemies_possiton[5][2] = {{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
unsigned long enemies_last_move[5] = {0,0,0,0,0};
unsigned long enemies_overall_last_move = 0;
unsigned long enemies_speed = 200;

char message[MAX_MESSAGE_LENGTH] = ""; //w - UP, s - Down, f - Fire

/*
Commands:
Up
Down
Fire
*/

// Arduino pin numbers
const int SW_pin = 2; // digital pin connected to switch output
const int X_pin = 1; // analog pin connected to X output Setup In the setup, we will initiate the Serial monitor, LCD, Joystick and set a starter game screen. Here we have used some of earlier initiated variables. void setup(){
  Serial.begin(9600);
  lcd.begin();
  //Creating custom characters in CG-RAM
  lcd.createChar(1 , c1);
  lcd.createChar(2 , c2);
  lcd.createChar(3 , c3);
  //initiate random
  randomSeed(analogRead(0));
  //joystick initiation 
  pinMode(SW_pin, INPUT);
  digitalWrite(SW_pin, HIGH); //default value is 1
  //Starter screen of the game
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print(" Starship game");
  lcd.setCursor(0,1);
  lcd.print(char(1));
  lcd.print(" Press any key to start");
} Loop In the loop we will listen to the serial monitor to get a command to go up (w), down (s), or fire (f): while (Serial.available() > 0){
  static unsigned int message_pos = 0;
  //Read the next available byte in the serial receive buffer
  char inByte = Serial.read();
  //Message coming in (check not terminating character) and guard for over message size
  if ( inByte != '\n' && (message_pos < MAX_MESSAGE_LENGTH - 1) ){
    //Add the incoming byte to our message
    message[message_pos] = inByte;
    message_pos++;
  }else{//Full message received...
    //Add null character to string
    message[message_pos] = '\0';
    //Print the message (or do other things)
    Serial.print("[[");
    Serial.print(message);
    Serial.println("]]");
    print_array_to_serial();
    //Reset for the next message
    message_pos = 0;
  }
} As one of the keys will be pressed the game will be started: //Start game
if (game_is_in_progress==false && (message[0] == 'w' || message[0] == 's' || message[0] == 'f')){
  game_is_in_progress = true;
  game_start = millis();
} We need to update the position of the starship as we get the Up or Down command. As we get fire command, we need to make sure if the bullet is not already in progress and after that, it will be initiated with X position 1 and Y position as the current starship position. //Processing input
    if(message[0] == 'w'){ // Up command
      starship_possiton = 0;
    }else if(message[0] == 's'){ // Down command
      starship_possiton = 1;
    }else if(message[0] == 'f' && bullet_is_in_progress == false){ //Fire command
      bullet_possiton[0] = starship_possiton;
      bullet_possiton[1] = 1;
      bullet_is_in_progress = true;
      bullet_last_move = millis();
    } Moving the bullet We will check if the add-up of bullet_last_move and bullet_speed is equal to or less than millis(). Because of that, if you want to make the bullet faster the bullet_speed variable needs to be decreased. We will move the bullet till the end of the screen and as its position will go over the screen size, the bullet will be reset. if(bullet_is_in_progress && bullet_last_move+bullet_speed <= millis()){
      if(bullet_possiton[1] != 15){
        Serial.println("moving bullet");
        bullet_last_move = millis();
        bullet_possiton[1] = bullet_possiton[1]+1;
      }else if(bullet_possiton[1] == 15){
        bullet_possiton[1] = -1;
        bullet_is_in_progress = false;
      }
    } Enemies initiation We will have a maximum of 5 enemies at a time. As earlier, we need to check if we have an inactive enemy to activate it. Also, to have a bit of space between enemies, we will wait for triple of enemies speed from enemies overall last move. We will generate a random value from 0 to 6. If the value is zero or one, the enemy will be initiated with the corresponding Y position and the last cell (15) in the X position. //Enemies initiation
    if((enemies_array[0]==false || enemies_array[1]==false || 
       enemies_array[2]==false || enemies_array[3]==false || enemies_array[4]==false) &&
       enemies_overall_last_move+enemies_speed*3 <= millis() ){
      // print a random number from 0 to 6
      randNumber = random(0, 6);
//      Serial.print("randNumber: "); Serial.println(randNumber);
      if(randNumber==0 || randNumber==1){
//        Serial.print("Enemies initiation: "); Serial.println(randNumber);
        for(int i=0; i<5; i++){
          if(enemies_array[i]==false){
            lcd_array[randNumber][15]="<";
            enemies_array[i]=true;
            enemies_possiton[i][0] = randNumber;
            enemies_possiton[i][1] = 15;
            enemies_last_move[i] = millis();
            enemies_overall_last_move = millis(); 
            break;
          }
        }
      }
    } Moving enemies is pretty similar to moving the bullet but in the reverse direction: //moving enemies
    for(int i=0; i<5; i++){
      if(enemies_array[i]==true && enemies_last_move[i]+enemies_speed <= millis()){
        enemies_possiton[i][1] = enemies_possiton[i][1] - 1;
        enemies_last_move[i] = millis();
      }
      //if enemy passed through starship
      if(enemies_possiton[i][1]==-1){
        enemies_array[i]=false;
      }
    } Update lcd_array and check crushes. We will insert our game elements to the lcd_array. By default, all cells will be blank. Then, we will draw the starship, bullet, and enemies. In the array the elements have the following symbols: } - starship bullet < - enemy for(int i=0;i<2;i++){
      for(int j=0;j<16;j++)
        if(game_is_in_progress){
          lcd_array[i][j] = " ";//by default all cells are blank
          //drawing starship
          if(starship_possiton==i && j==0){
            lcd_array[i][j] = "}";
          }
          //drawing bullet
          if(bullet_is_in_progress == true && bullet_possiton[0] == i && 
          bullet_possiton[1] == j){
            lcd_array[i][j] = ">";
          }
          //drawing enemies
          for(int k=0; k<5; k++){
            if(enemies_array[k]==true && enemies_possiton[k][0] == i 
            && enemies_possiton[k][1] == j){
              lcd_array[i][j]="<";
            }
          }
        }
      }
    } Next one, we will check for crushes: bullet enemy crush starship enemy crush for(int k=0; k<5; k++){
            if(bullet_is_in_progress == true && bullet_possiton[0] == i && 
            bullet_possiton[1] == j &&
            ((enemies_array[k]==true && enemies_possiton[k][0] == i 
            && enemies_possiton[k][1] == j) || 
            (enemies_array[k]==true && enemies_possiton[k][0] == i 
            && enemies_possiton[k][1] == j-1) )
            ){
              Serial.println("bullet enemy crush");
              enemies_array[k] = false;
              enemies_possiton[k][0] = -1; 
              enemies_possiton[k][1] = -1;
              bullet_is_in_progress = false;
              bullet_possiton[0] = -1;
              bullet_possiton[1] = -1;
              lcd_array[i][j]=" ";
            } 
          }
          
          //starship enemy crush
          if(j==0 && starship_possiton==i){
            for(int k=0; k<5; k++){
              if(enemies_array[k]==true && enemies_possiton[k][0] == i 
              && enemies_possiton[k][1] == j){
                Serial.println("starship enemy crush");
                //Game Over. Your score. High Score
                game_score = millis() - game_start;
                
                //need to reset all game values
                starship_possiton = 0;
                game_is_in_progress = false;
                bullet_is_in_progress = false;
                for(int z=0; z<5; z++){
                  enemies_array[z] = false;
                  enemies_possiton[z][0] = -1;
                  enemies_possiton[z][1] = -1;
                }   
                enemies_speed = 200;
                message[MAX_MESSAGE_LENGTH] = ""; //w - UP, s - Down, f - Fire
                break;
              } 
            }
          } In the bullet enemy crush, if we check only if the bullet and enemy are in the same position, we can face an issue when the enemy and bullet change their position at the same time. This will look like the enemy passed through the bullet: https://www.youtube.com/watch?v=E5Qm3N1_h5o This will be not every time but quite often. To prevent it, we also need to check if the enemy is located behind the bullet. It does not interfere with the game in any way and perfectly solves our problem. After the starship and the enemy crush, we will get the game score by subtracting the game start millis from the current millis. Also, game variables will be reset. After the lcd array update, we will print the array to the LCD. The enemy, bullet, and enemy symbols will be replaced by our custom characters: //Printing game to lcd
    for(int i=0;i<2;i++){
      lcd.setCursor(0,i);
      for(int j=0;j<16;j++){
        if(lcd_array[i][j] == "}"){
          lcd.print(char(1));
        }else if(lcd_array[i][j] == "<"){
          lcd.print(char(2));
        }else if(lcd_array[i][j] == ">"){
          lcd.print(char(3));
        }else{
          lcd.print(lcd_array[i][j]);
        }   
      }
    } After the crush of the enemy and starship, we will display the high score (record) and the score of the game. If the game score is more than a high score, it will be updated. Next time the new high score will be displayed, even after the Arduino power off: if(game_score!=0){
      EEPROM.get(0, game_start);
      Serial.print("High score: ");
      Serial.println(game_start);
      Serial.print("Score: ");
      Serial.println(game_score);
     
      //Game over screen
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Record: ");
      lcd.print(game_start);
      
      lcd.setCursor(0,1);
      lcd.print("Score:  ");
      lcd.print(game_score);
      if(game_score > game_start){
         EEPROM.put(0, game_score);
      }
      game_score = 0;//reset game score for next game
    } At the end of the loop we will have a short delay and reset command: delay(50);
  message[0] = ' '; //reset command The printing of the lcd_array to the serial monitor has been separated to function and can be displayed by request or constantly: void print_array_to_serial(){
  //Printing game to Serial Monitor:
  Serial.println("lcd_array:");
  for(int i=0;i<2;i++){
    for(int j=0;j<16;j++){
      Serial.print(lcd_array[i][j]);
    }
    Serial.println("");
  }
} And the game control by the joystick is added in this easy way: if(digitalRead(SW_pin)==LOW){
    message[0] = 'f';
  }
  if(analogRead(X_pin)>612){
    message[0] = 'w';
  }
  if(analogRead(X_pin)<412){
    message[0] = 's';
  } Conclusion This game will help you practice creating a game at a basic level and you will further turn on your imagination to create more complex games. For fans of Arduino and game development, this is a good base to polish your skills. The best thing after such a lot of work is to play the game that was developed by you. Hope the project was interesting for you. Through this project, we have learned about and used in practice the LCD display and the joystick. Here are some enhancement ideas for the project, which can be implemented by you: Lives Game difficulty levels A complication of the game as the player progresses Make a Boss enemy which will have the ability to send enemies and fire bullets. Ability to enter name or nick if the high score has been broken. Which will also be entered into the EEPROM.

How to Build an Arduino Starship Game Controlled by Joystick and Computer

Cómo construir un juego Arduino Starship controlado por joystick y computadora

In this article, I will list the best resources all over the internet which will help you to be a hacker. I would be answering the following questions: What is hacking? Why learn to hack? Where can you learn to hack? What we’ll Cover Introduction to hacking. Why learn to hack. Video sources. Web-articles. Books. Paid and free courses. Introduction to Hacking. Hacking in its simplest explanation is breaking into a system that has a certain degree  of security. Hacking is a skill set and requires a lot of practice to become good at. There are 3 types of hackers, they are: Black Hat. White Hat. Grey Hat. This category of hackers do hacking for malicious purposes. Black hat hackers: This category of hackers do hacking for the benefit of others. They hack to secure the vulnerability that can lead to harm. White hat hackers: This category of hackers acts as both white Hat and black hat hackers. This makes them be on both the good and bad side, depending on the situation 😀 . Grey Hat Hackers: Hacking is a vast subject. It has a lot of sub-categories which includes: Web application. Forensic. Networking. Cloud. Systems both mobile and desktop devices. Hardware. These are some of the various things you can learn and each has sub-topics that are interesting. The main goal of a white-hat hacker is to find a potential vulnerability, exploit it, gain access, create a detailed document and report it to the authorities. Hackers or pentesters are paid on the scale of priority of the vulnerability reported. This is decided based on a priority table that is made by the board showing which part of their infrastructure is most important and needs special attention. If you are successful in finding a vulnerability in that specific section you can expect a high reward. If you are not into full-time pentesting and want to do part-time then Bug-bounty hunting is the go-to thing for you. Bug-bounty hunting is a program hosted by company websites with specified rules and regulations. They usually specify things they won't consider a bug and other than those things, any other possible bug you find will get you some reward from the website. A Bug in this sense is a vulnerability that can be exploited to gain information or unauthorized access into the server. Bug bounty hunters usually have extensive knowledge of different types of bugs. Some of the  common types of bugs include XSS, HTML-INJECTION, CSRF, etc. Having knowledge and being able to detect these vulnerabilities as a bug-bounty hunter can get you a decent amount of pay from the bounty. Other than being a bug-bounty hunter, you can also be a freelance pentester, where the work will be more but the payout is more than that of a bug bounty. Why Learn to Hack? In my previous explanation, I have introduced you to various types of hackers and what they do for a living. Having knowledge of hacking and how it works, you can be able to protect yourself and others, and also educate them with your experience. You can also make a living via hacking by being a bug-bounty hunter or a freelance pentester. You could also get a job after gaining a few certifications. This leads us to our next question if you ask me there is no way you can excel in any field without knowing the basics relating to the field you are going to choose. where to start? All the things such as basic networking, web application, and programming can be learned from web sources such as Youtube or Udemy but if you want professional teaching then you can opt for training from official sources such as Offensive security, INE, EC-Council, etc. Fundamentals are easy to understand anyone can achieve learning the fundamentals, but the main goal is to learn the advanced things, for example, if you understand how the server works with the client-side request, you can learn how to manipulate and possibly exploit the server. You need not worry, anyone can achieve this. Some people are afraid to learn things from a new field while studying in a different field, for example, a commerce student fears that studying this topic will be of no use for him in the future even though it has potential. I am a commerce student and I started to learn hacking while I was in 12th grade. I felt the topics were interesting and changed my goal from pursuing a commerce-based job and instead started learning to hack. I hope to become a professional pentester and in the future even start a security-related firm. Similarly, anyone from any field can learn to hack and become a hacker but it requires dedication and a lot of practice to learn and perfect your skills. Cybersecurity is a fast-growing field for job opportunities and even new freshers can also get a high salary job with work experience if you have prior experience and certifications then you can expect a good salary and high growth in your job profile. Professional aspect: Video Sources There are a lot of online video sources such as Youtube and Udemy. On social media platforms, you can follow some professionals who have great links and useful resources to learn from. Social media . David bombal . Cryptothelamma nt. Eleme Hackersking. in . Cybertechsociety . Mattupham These are some of the best social media influencers who share information of value and can help you in your works. On Youtube, you can refer to the following Youtube channels: . NullByte . Zsecurity . David Bombal . Loi Liang Yang . Hackersploit . NetworkChuck I would recommend you follow David Bombals's Youtube video as he gives a lot of giveaways. I love his works, his explanations are also really easy to understand and beginner-friendly. Web-articles. Web articles are write-ups that enable people with knowledge to share their thoughts and points related to a certain topic or a certain event that matters in the cybersecurity world. There are several websites where one can find web articles. But I am going to mention a few of them that I find to be quite informative. : Website links (security section) Hackernoon.com Latesthackingnews.com Thehackernews.com Hackingarticles. in These are some of the useful websites you can use to learn more about the latest events and more related to security-related content. Books. Cybersecurity-related books are all over the internet but some of them stand out. I am going to list 11 of the best ones to start your security journey. Book links: Hacking: The Art of Exploitation. The Basics of Hacking and Penetration Testing. The Hacker Playbook. Penetration Testing. The Web Application Hacker’s Handbook. Hacking: Computer Hacking, Security Testing is a book written by Gary Hall. Computer Hacking Beginners. Hackers & Painters. Advanced Penetration Testing. The Hardware Hacker is a book written by Andre Huang. BackTrack 5 Wireless Penetration Testing Beginner’s Guide. These are some of the most useful books out there for beginners and intermediate-level hackers. Paid and free courses. Udemy courses: Complete cyber-sec course by Nathan House. Complete Web hacking by Loi Liang Yang. Complete Mobile hacking course by Loi Liang Yang. CompTIA Network+ with expertise from David bombal. Weblinks to gain infinite knowledge in any field for free: HacksPlanning.com Edx.org Hackerstop.org Digitaldefynd.com guru99.com Securitytube.net Simplylearn.com Sources The main source for this article is my personal experience but the bonus link is something I felt can be of some use. I am including that link as it will be useful and can help many others in their journey to become ethical hackers. Bonus. This one is a bonus it is a complete compiled version of all the most popular and underrated resources all over the internet made available in one link. I appreciate the effort made by to make such a great resource, the above links and resources are which I used to learn to hack and the basics but this link has all the resources A-Z everything. Vitalysim Link: Awesome-Hacking-Resource. Contact me. INSTAGRAM TWITTER EMAIL: morpheuslord@protonmail.com

Top Resources to Learn Ethical Hacking

This article gives you a complete description of the very famous Arduino UNO board. The article discusses the hardware technicalities and programming of the board. If you are a beginner then, you may find this article very useful. Arduino UNO is an open-source microcontroller board developed by Arduino. cc. Arduino UNO board is a mini-computer that gives a controlled output when provided with some input. One can make a wide range of projects using the Arduino platform. It is inexpensive and easy to use. In order to obtain more out of the Arduino platform, you just need to be familiar with the basics of C or C++ and the basics of circuit connections. You can use the Arduino IDE (Integrated Development Environment) for writing the code for your project and upload it on the board using the same. The Arduino board takes the input from the devices like switches, sensors, etc. and the output is obtained based on the code uploaded on the board. Below I have given a brief description of Arduino UNO hardware and software. Also, at the end of the article, I have demonstrated the working of the UNO board with a simple example of LED control. Hardware description Microcontroller on the board Arduino UNO boards have the famous ATmega328P installed on it which is an 8-bit Atmel AVR microcontroller based on RISC architecture. It has 32 KB of flash memory where the program gets stored and out of this 32 KB, 0.5 KB is used by the bootloader. Besides this, it has 2KB SRAM and 1 KB EEPROM. ATmega328P has 32 general-purpose registers out of which 31 registers are directly connected to the arithmetic logic unit(ALU). This makes these microcontrollers code efficient and 10 times faster than conventional CISC microcontrollers. It has a clock speed of 16MHz. Pinout In order to make proper circuit connections, you need to understand the purpose of each pin. Arduino UNO board has 14 digital pins, 6 analog pins, a power jack, a USB connection, and an ICSP header. These pins allow us to connect the board with different sensors, keypads, LEDs, and more. The pins of the Arduino UNO board can be categorized into 3 classes: Barrel Jack: Arduino board can be powered by connecting the barrel jack to the DC power supply. Usually, barrel jacks are connected to the wall adapter. It is recommended by the manufacturer to use a voltage supply of 7–12 Volts. The voltage supply lower than 7 Volts might not be sufficient and above 12 Volts might overheat the voltage regulators on the board. VIN: This pin is used to power up the board using an external power source like a battery. The voltage range should be between 7–12 Volts. USB: Using a USB cable the board can be connected to the computers. It provides 5 Volts at 500 mA. Using a USB cable you can burn your program on the microcontroller. 3.3 Volts and 5 Volts: These pins provide a regulated supply to power external components. GND: Ground pins RESET Power Pins: Pin A0 to A5 are the analog input pins. These pins read the analog input. But in order to perform further operations, these analog inputs should be converted into bits so that microcontroller can understand it. This conversion of the analog input to bits is done by ADC (analog to digital converter). In the Arduino UNO board, the input analog voltage can be represented in a 10-bit format that implies 2¹⁰ = 1024 levels. IN Analog Pins: Arduino board has 14 digital input-output pins starting from 0 to 13. These pins are capable of reading only two states HIGH(1 or high voltage) or LOW (0 or low voltage). Among these pins, pin 3, 5, 6, 9, 10, and 11 are capable of performing Pulse Width Modulation. I/O Digital Pins: Pulse-width modulation is a modulating technique where messages are converted into pulses. PWM involves two components, frequency, and duty cycle. Frequency determines the number of times the signal fluctuates in a unit time period. The duty cycle determines how long the pulse remains in the HIGH state. The PWM is basically used to control the speed of the DC motor and to control the dimming of LEDs. Pin 13 is connected to the LED in-built on the board. Pin 2 and 3 can be used to trigger external interrupt INT0 and INT1. Arduino UNO has 6 ICSP header pins. ICSP stands for In-circuit serial programming and is used to program Arduino board’s firmware. Also, it has 1 AREF pin. Communication Arduino boards can communicate serially with computers and other Arduino boards (not specifically UNO). Atmega328P provides UART TTL which is available in digital pins 0 (receiving pin or RX) and 1 (transmitting pin or TX) for serial communication. In serial communication, data of 1-bit size is transmitted and received at a time. Communication can also be established via USB cable. The Arduino board has TX and RX which flashes when data is transmitted and received via USB connection only. ATmega328P also supports I2C and SPI communication Software Description Arduino IDE Arduino Integrated Development Environment is a software where you can write the code and upload it on your Arduino board. It can be used in Windows, Linux, and Mac operating systems. The environment supports both C and C++ programming languages. Before programming, you need to select which Arduino board are you using in your project. The main code of the Arduino project is called the sketch. Whenever you compile the sketch a .hex file generated. This .hex file is then uploaded to the microcontroller on the board. In the above image, you can see the six options that Arduino IDE provides: VERIFY — Once you have written your code press this button. It will compile your code and will give information about errors in the program. UPLOAD — After connecting your Arduino board to the computer via USB cable, press this button to upload the program on the microcontroller. NEW — Press this to create a new sketch. OPEN — Press this to open the existing sketch or example programs. SAVE — Press this to save your sketch. SERIAL MONITOR — Useful for sending data from the Arduino to the PC for debugging purposes. A basic Arduino sketch has two functions: void setup() and void loop(). Under the void setup(), you need to write the code that you want to run only once as soon as the program starts running. Below is two basic functions that are often used under in setup() function: begin() — Sets the data rate in bits per second (baud) for serial data transmission and initializes the device. For communicating with the computer, use one of these rates: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, or 115200. This function can be used to set up serial monitor, LCD, etc. Example: Serial.begin(), lcd.begin(). pinMode(pin, mode) — Using this you can set pins to INPUT or OUTPUT mode. Example: pinMode(8, OUTPUT) Under the void loop(), you need to write the program that you want to run as long as there is no interruption. Below are some basic functions that are often used under in loop() function: analogRead() — for reading the status of analog pins digitalRead() — for reading the status of digital pins. digitalWrite() — for setting the pin to either HIGH or LOW. You can also use arithmetic operators, comparison operators, boolean operators, bitwise operators, and compound operators as per your requirement. The syntax is very much like C++. EXAMPLE: LED CONTROL Now, for a better understanding, I am going to make a simple project with the Arduino UNO board. Any Arduino project involves three things: Make circuit connection. Write a program for the circuit functionality. Burn (upload) the program on the board. Circuit I have used the Proteus simulation software for the project simulation. In the above circuit, the digital pin 3 is connected to LED and in between, there is a resistor of 330 ohms. When using the simulation tool there is no need to connect the VIN and GND pin of the Arduino UNO board. But the same is not applicable when making physical connections. Now, we need to write the program as per the above connection. Suppose we want to make the LED blink continuously at an interval of 1sec. Code In the above code, you can see that in the setup function I have set pin 3 as the output pin and its state is continuously being toggled at an interval of 1sec in the loop function. Output In the above image, LED glows for the first 1 sec. In the above image, LED does not glow for the next 1 sec. Conclusion In this article, we discussed the Arduino UNO board, how to use Arduino IDE for programming it and lastly, we made a simple LED control project.

Arduino UNO Board: Under The Hood

In this short tutorial, I’ll walk you through the process of turning any bicycle into an arcade-like controller for computer games. Despite not setting the example for leading a healthy lifestyle, my wife and I do try to eat our greens, avoid too much junk, and keep in shape. Our 5 year old on the other hand, couldn’t care less about doing any physical activity, unless it gets him closer to his (my…) iPad. best Normally, This issue is partially remedied simply by being a kid, which involves a fair amount of running, climbing, falling… and recently cycling! But unfortunately, with the advent of the COVID-19 pandemic, we can’t really do much of that. So, I turned his bicycle into a keyboard. Now, he can play his favorite computer games and exercise at the same time! In this short article, I’ll walk you through the process of building your very own . keyboard bike Foundations: The first step is turning the bicycle into indoor training bikes by getting the rear wheel to spin freely without touching the ground, and allow the handlebars to turn freely as well. If your kid is propelled forward, you should NOT proceed to the following steps. There are many ways of getting the bike to remain in place while spinning the pedals. Hanging the bicycle from the ceiling, digging a hole in the floor beneath the wheel and many more. I personally used the training wheels to support the rear, but this is your place to get creative, and more importantly, . I am deliberately avoiding getting into too much detail about my implementation of this part (you can get a pretty good idea from the various pictures and gifs in this article…) as it is your responsibility to make sure that the bicycle are secure and safe to use. be responsible The plan After securing the bike so that it can be pedalled in place, we will connect sensors to capture the rotation of the rear wheel, position of the handle bars and some buttons for extra control (these can be easily programmed later to map any keyboard key). Data from all sensors will be captured and transformed by an Arduino that will function as a keyboard and send keystrokes to a computer running a (most likely racing) game. Hardware We must use a board that can function as a USB keyboard. I used . Arduino Leonardo I used 3 types of sensors: . — This sensor changes its output voltage when in the proximity of a magnetic field. We will use it to transform the rotation of the rear wheel to a forward key press. — Used to transform the handlebar orientation to left/right keys. — used as extra controllers. I recommend using this type of switches (limit switch) and not going for some fancy buttons. these switches are very responsive, whereas some buttons can sometimes be challenging for a kid to press. 1 A1302 Hall Effect Sensor 2. 10K ohm linear potentiometer 3. Microswitch highly Connecting the parts Hall effect sensor By placing magnets on the rear wheel, and positioning the sensor close (as close as possible without touching the wheel), we can sense the wheel’s rotation as the magnets pass by the sensor. I used two magnets equally spaced (that is ~180 degrees apart). A tip for attaching the magnets - You could probably find a more elegant solution, but the one I used here is to wrap the magnets in plastic wrap and twist the ends, like a candy wrap (I am referring to the white blobs seen spinning with the wheel in the gif above). Then use the loose ends to tie the magnets to the wheel’s spokes, and secure with hot glue. In order to get the sensor (this is referring to the red vertical rod in the gif, the sensor itself is located at its end) as close to the wheel as possible I mounted it to a flexible wire (I used some heavy duty electrical wire but any wire that will flex and keep its position will do). Potentiometer The potentiometer needs to be connected to the pivot point of the handlebars. There should be a socket for an allen wrench at that point. I used a fitting driver bit and connected it to the potentiometer. Originally, my plan was to solder both parts together, but driver bits have low (none) solder-ability. I ended up taking a short piece of straw (seen in the gif below in violet) sticking the potentiometer and driver bit from both sides, and injecting it with hot glue, to keep everything together. It’s solid as a rock. As for securing the potentiometer to the bike frame, you will again need to get creative. my solution (which can be seen in the trailer gif and in the image at the end of the article showing all components detached from the bike) was based on making a plexiglass “arm” to hold the potentiometer in place, and may not work for your child’s bike. The idea is simple, the potentiometer needs to spin with the handlebars. Simple as it is, the implementation can be quite challenging… Switches I placed one of the switches behind the (redundant) front wheel brake lever, and the other one behind the not redundant back wheel brake lever, and disconnected this brake, so that the switches are pressed by pressing the brakes, which feels very natural. Again, I’m not taking any responsibility here. if you feel the supports you made in part 1 are not strong enough and are worried about obstructing and/or disconnecting brakes, you can, and should place the buttons somewhere else. No right or wrong, as long as it’s comfortable and safe. I limited myself to two buttons but you can obviously go as high as the board allows. Wiring A note on thinking ahead. After completing , I set up to improve it by making sure I can easily disconnect all components and reassemble them again as quickly as possible, this required some tweaking, that could have been avoided if I had thought of this at the get go. It took me nearly to upgrade to , but it now takes to assemble/disassemble. keyboard-bike version 1.0 2 hours keyboard-bike version 2.0 less than a minute Another point to keep in mind is what’s the best place to secure the board. I thoughtlessly put it on the side my son gets on and off the bike. In retrospect, I should have chosen the other side… Code As explained in the hardware section, the setup is composed of 3 types of sensors: Hall effect sensor, potentiometer, and buttons. I’ll explain the code for each component separately. keyboard bike Hall effect sensor The hall effect sensor is “activated” when the wheel spins and the magnets pass by the sensor, inducing a change in output voltage. For this part, I switched on the key (forward key in my case) whenever there was an absolute change in voltage above a certain threshold (hall_effect_threshold). I then keep it on and start counting back for a certain amount of time (drive_decay_const). This allows tuning the amount of motion you get from each "spike". Increase the value of drive_decay_const to get more movement. Potentiometer Here we’re basically trying to convert an “analog” motion of turning the handlebars into a “binary” left or right clicks. A continuous press is way too dramatic if you just want to make small adjustments, so the amount of turn needs to be represented as “click amount”. I’m doing this by activating and deactivating turning movement at a set interval (interval), so that turning the handlebars beyond a certain threshold, will start pressing intermittently. In addition, I add a delay while the button is activated, that grows with the amount of turn. So for higher angle turns, the button will be pressed for a longer duration (that is, each click will be longer) resulting in a more aggressive turn. Also, notice that I'm initialising pot_center at setup. this is helpful for cases where the potentiometer gets disconnected from the socket. Instead of having to relocate the center, you can just reset the board, and the center will be reset. Switches Nothing special here. Just replace the activated key to suit your needs. The code here is for playing which is a great racing game for kids, but the bike could obviously be adjusted for many other games. We also use it to play Minecraft, which works great. SuperTuxKart hall_effect_threshold = turn_threshold = ; drive_decay_const = ; turn_decay_const = ; button_1_val = ; button_2_val = ; interval = ; button_1 = ; button_2 = ; pot_center = ; prev_hallSensorValue = ; delay_time = ; drive_decay = ; previousMillis = ; allow_turn = ; turn_amount = ; {
  Serial.begin( );
  Keyboard.begin();
  pinMode(button_1, INPUT);
  pinMode(button_2, INPUT);
  pot_center = analogRead(A1);
} { currentMillis = millis(); hallSensorValue = analogRead(A0); pot = analogRead(A1); ( (hallSensorValue- prev_hallSensorValue) > ){
    prev_hallSensorValue = hallSensorValue;
    Keyboard.press(KEY_UP_ARROW);
    drive_decay = drive_decay_const;
  } { (drive_decay <= ){
        Keyboard.release(KEY_UP_ARROW);
        } {
      drive_decay -= ;
      }
    } (allow_turn== ){ (pot < pot_center - turn_threshold) {
    Keyboard.press(KEY_RIGHT_ARROW);
    } (pot > pot_center + turn_threshold){
    Keyboard.press(KEY_LEFT_ARROW);
  }} (currentMillis - previousMillis >= interval) { previousMillis = currentMillis;
    turn_amount = (pot-pot_center); (allow_turn == ) { (turn_amount > turn_threshold){
          delay(turn_amount); }
      allow_turn = ;
    } {
      allow_turn = ;
      } Keyboard.release(KEY_RIGHT_ARROW);
      Keyboard.release(KEY_LEFT_ARROW);
    } (digitalRead(button_1) == HIGH){
    Keyboard.press(button_1_val);
    } {
     Keyboard.release(button_1_val);
    } (digitalRead(button_2) == HIGH){
    Keyboard.press(button_2_val);
    } {
     Keyboard.release(button_2_val);
    }
} /*
bicycle_keyboard
*/ # include "Keyboard.h" const int 1 // threshold for hall effect sensor. const int 35 // threshold for detecting a left/right movement. const int 100 // drive_decay speed of car (larger => slower decreasing / faster car) const int 0.75 // multiplier for intensity of turn. higher value => sharper turns. const char ' ' // value for button 1 const char 'n' // value for button 2 const long 200 // interval for allowing not allowing turns. const int 2 // button_1 pin const int 3 // button_2 pin int 500 // center point for potentiometer. this value is being reset in setup. int 0 // initial value for sensor const int 1 // delay between reads int 0 // initial drive_decay value unsigned long 0 // initial value bool true // allow turn is a boolean to only allow turns every passing interval int 0 // initial value void setup () 9600 void loop () unsigned long int int //  Serial.println(hallSensorValue); //  Serial.println(pot);  delay(delay_time);        // delay in between reads for stability  // DRIVE: if abs 1 else if 0 else 1 if true //TURN RIGHT if // TURN LEFT if if // interval has passed abs // switch allow turn state: if true if //keep button pressed longer the more aggressive the turn. false else true // release the turn keys: //check buttons if else if else Summary To conclude, I hope I did a good job of explaining how to get the built. If you chose to build one, and find that I have not, don’t hesitate to send me a message. keyboard bike Also published behind a paywall: https://towardsdatascience.com/keeping-your-kids-in-shape-during-quarantine-by-turning-their-bicycle-into-a-keyboard-e1f8a34fac2e

Quarantine Life: How to Keep Your Kids Active by Turning their Bicycle into an Arcade Controller

Digital marketing is an umbrella term that covers all the facets of online marketing including content marketing, video marketing, email marketing, search engine marketing (SEM), and other digital formats. As the industry has evolved over the past few years, it has adopted the usage of new buzzwords such as Artificial Intelligence (AI), Big Data, and Machine Learning. Image Credit: Digitalready You’ve probably noticed that Artificial Intelligence (AI) and Machine Learning have stepped into almost every domain to augment work efficiency and reduce errors, and . While the technology has not been leveraged to its full potential yet, it has made a big difference in the lives of people making it easier than ever. From virtual assistants to autonomous vehicles, Artificial Intelligence has made it easier for people to perform their tasks with ease without spending extra time. Though there are , . Let us try to understand how Artificial Intelligence and Machine Learning are shaping the digital marketing industry. the marketing and advertising world is no exception innumerable possibilities that are yet to be explored AI is becoming a robust tool for the digital marketing industry 1 Use AI-Powered Chatbots to Improve UX Many business enterprises across the world are familiar with live chatbots, or AI systems that are responsible for interacting with customers and clients. Even many of them are already using it on their website. But have you ever ponder over upgrading the traditional live chats with AI-powered chatbots? If yes, it’s the right time to do so. AI-powered chatbots can make your website stand out on the internet. Here are some prime benefits that AI-powered chatbots offer over live chat: · AI chatbot remembers your customers’ visits, past chats, and become accustomed to their requirements. In other words, AI-powered chatbots retain your customer data so that they don’t have to repeat themselves with every interaction. This will make the customer experience hassle-free · It can assist customers 24×7 and do things beyond answering basic questions · It can handle multiple customer requests simultaneously · It can also be helpful in creating which often convert to sales personalized advertisements · It can be used to track . This will help business enterprises to revamp their marketing campaign and boost sales customers buying behavior · They are customer friendly and never lose patience in any circumstances. Your customers may be angry, but your AI chatbot will always treat your customers politely #2 Optimize Your Site for Voice Search Queries With the rise in voice search queries, it becomes essential for digital marketers to optimize sites for natural language long-tailed voice queries. Google has clearly stated in its blog that almost are expressed in natural conversational language, not the typical keywords that are used in text search query in a web search. 70% of requests to the Google Assistant A user isn’t going to voice search for Image Credit: seopressor Instead, a user is going to say something like this: Image Credit: seopressor Long gone are the days when keywords were stuffed in a webpage to rank higher in Google’s SERPs, nowadays it has become vital to identify the intent behind the search query. When optimizing your site for voice search, you can create pages that provide a direct answer to the questions start with “how,”, “what,” “who,” ” “why,” and “when”. If your business is present in multiple locations, you can also create local landing pages for every location that you want to target. While people of all ages are using voice search, but it’s teens that are ahead of adults in exploring all angles of voice search. Image Credit: Google Blog #3 Leverage the Power of AI to Generate Personalized Content for Marketing Generating engaging content for online marketing campaign would be a challenging task particularly if you want to personalize the campaign and make it user-centric. Typically, it would take a couple of months of hard work and strategic planning to pull off a successful campaign. However, with the advent of new AI-based tools, it becomes easy to develop natural and creative content on every topic. Though these tools are in its early stages, they would give digital marketers a competitive edge in the market. Imagine targeting hundreds of thousands of customers using personalized marketing content for each one of them. At present, it may seem like an unrealistic thing, however with AI and Machine Learning on board, it won’t take much time to launch such a massive campaign with a high success rate. #4 Simpler Predictive Marketing Earlier marketers used to do a lot of market research before launching any campaign. With AI on board, marketers need not worry about tough marketing decisions, since AI can uncover the most impactful insight by understanding consumer behavior and activity. For example, if you run an Adwords campaign, you can use Google’s , in which you have to define your campaign objectives and your targeted audience, and this tool will automatically recommend strategies for better conversions. DoubleClick Bid Manager #5 Personalizing User Experience Today, a lot of marketing tools use sophisticated algorithms to understand buyer behavior and decision-making. However, with the help of AI, marketers can deliver personalized experiences to the user. With AI, you can display personalized content to every customer based on their past interaction and buying behavior. Wrapping Up AI and Machine Learning have started shaping the digital marketing industry. As a digital marketer, you need to understand that whether it’s automatic selection of an ad copy or dynamic price optimization, Artificial Intelligence has the power to do it all. Identify your most pressing needs and AI can do the rest for you.

Know How AI and Machine Learning are Shaping the Digital Marketing Industry

Besides the massive , what makes the one answering the questions about data collection by big tech companies? Facebook is not alone as the and other companies arguably collect information than Facebook. Here’s a look at why Facebook is taking the floor in answering questions from the Senate. Cambridge Analytica scandal Facebook internet’s privacy villain even more People Know Who Mark Zuckerberg Is Mark Zuckerberg is likely one of the most recognizable CEOs in the world. Thanks to , a movie about how Zuck founded Facebook, people know more about his story than any other CEO. The Social Network Other CEOs: Alphabet’s , Google’s , Amazon’s , and Twitter’s are well known in the tech realm. However most people wouldn’t recognize them in person or know much about them beyond their position. Zuckerberg is an icon, he embraces the spotlight — even if people . Larry Page Sundar Pichai Jeff Bezos Jack Dorsey criticize his authenticity People Use Facebook on a Daily Basis on average log onto Facebook daily and are considered daily active users. Internet users can relate to concerns about Facebook because they use the service so often and have a deep connection with it. 4 billion people Adding privacy protection to Facebook is something people can directly relate to and understand. People Agree To Facebook’s Privacy Policy & Terms of Service Facebook uses a broad blanket when users create an account. However, many features on Facebook are opt-out, meaning they are enabled by default and users have to choose to turn them off. privacy policy These policies, which very few users actually read, are a problem. If people can’t easily understand how their data is used, the privacy policies aren’t accomplishing their purpose for the users (only protecting the companies legally). Users Are Generally Comfortable with Sharing Information on Facebook People are comfortable sharing content on Facebook. Whether it’s a photo of their family or a status update, putting this out there has become the norm for Facebook users. Because people perceive Facebook as a social environment, they are given reinforcement — likes, shares, comments — for sharing information. Make your online presence work for you, not against you. Employers and admissions officers report that the internet can be a good place for applicants to present their talents, professionalism, and sociability. -Source: DigitalResponsibility.org Filling out a profile on Facebook involves making certain information about you public, at least to your friends. People don’t associate sharing information with or Amazon, by contrast. Google Facebook’s Data Collection Goes Well Beyond It’s Core Product Facebook says it has removed these , but prior to 2015 users could be targeted under the categories “diagnosis with HIV or AIDS”, “erectile dysfunction” and “binge-eating disorder awareness”. How would Facebook gather this data through its core products? targeting options “Facebook can learn almost anything about you by using artificial intelligence to analyze your behavior,” said for the Electronic Frontier Foundation, a digital rights nonprofit. “That knowledge turns out be perfect both for advertising and propaganda. Will Facebook ever prevent itself from learning people’s political views, or other sensitive facts about them?” Peter Eckersley, the chief computer scientist Facebook uses its to collect information about users and their connections. many apps and products Facebook’s Product Line Facebook Instagram Messenger WhatsApp Internet.org by Facebook Oculus Facebook Has Virtually No Direct Competitors Mark Zuckerberg may be adamant that , but the numbers don’t lie. There are companies that provide parts of what Facebook does, but none are true alternatives. Facebook is not a monopoly Even companies calling themselves offer just a portion of Facebook’s features. And none can even come close to Facebook’s . alternatives to Facebook 2.2 billion users Facebook Offers Very Little Transparency Unfortunately because Facebook has so little competition, they don’t need to offer transparency. And users have demonstrated that even if they would like for the platform to share more about how it works, they aren’t willing to delete their accounts over it. Facebook discloses which information it gathers in its terms of use. However, users are often surprised to learn about the social network sharing other information with third-parties such as advertisers or other firms, like . Cambridge Analytica Source: Statista.com The company owns Facebook Messenger and WhatsApp, making it the biggest player in the mobile messaging market by far. Messaging as a market is unique because users rely on other people using the same apps as them to communicate. If a user wants to switch to a different messaging app, in most cases they need the people they are communicating with to also switch. Conclusion So Facebook’s celebrity CEO, it’s massive user base and its monopoly status, make it a prime example for the tech industry as a whole. Because Facebook is so ingrained throughout the internet and every browsing session, people can clearly see the effects of . How Facebook responds to lawmakers’ questions will impact the future of for the entire internet and tech industry. data collection privacy regulations Read More _Google’s parent company, Alphabet, has a market cap of $712 billion. Within Google’s range of products, there are seven…_hackernoon.com Data Privacy Concerns with Google _Facebook's house of cards has taken yet another tumble today after Ars Technica revealed that Facebook tracks call and…_choosetoencrypt.com Facebook May Have Consent, But Not Approval - Choose To Encrypt _Facebook just revamped its privacy settings and terms of use, mostly in response to users who were upset about the…_choosetoencrypt.com Facebook Won't Fix the Internet's Bigger Privacy Problem - Choose To Encrypt

DIGITALREEF

vyng.me

-- employees

Since n.d.

COMPANY RANKING

DIGITALREEF

EVERGREEN INDEX #3006

Representing this company? Click here to claim and customize this page!

DigitalReef WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

DIGITALREEF

vyng.me

-- employees

Since n.d.

COMPANY RANKING

DIGITALREEF

EVERGREEN INDEX #3006

RELATED COMPANIESRANK

STORIES ABOUT DIGITALREEF

Representing this company? Click here to claim and customize this page!

DigitalReef WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!