DigitArena

digitarena

Why use AI for tweet writing? Well, why not? Posting on X, like many other tasks that require consistency, is something AI tools can help you with. Writing a tweet seems to be an easy and quick job, but done daily takes a lot of effort. To grow a following, you should post at least a few times a day. Coming up with so much content is demanding. I prefer to save time without compromising on the form and value given to followers. Now, I just need a general topic for the discussion in my mind and then let ChatGPT do the writing job. What does a ‘perfect’ attention-grabbing tweet include? While doing my research, I found out a perfect tweet has certain requirements. Should be short, not exploit the whole characters limit - in that case, rather posted in the form of a thread. Long-form works for certain types of write-ups, but not all. Should have a maximum of 3 or 4 relevant hashtags. Though, I’ve seen the ones without them received as more genuine. Should include a call to action. There are also some copywriting techniques that help develop an attention-grabbing tweet. The most popular is AIDA (Attention, Interest, Desire, Action), but I found out that actually, APP (Awareness, Problem, Positioning) can also be efficient for sparkling up discussions. Let’s see how to use them in ChatGPT. Practical ChatGPT Input for Tweets on Any Topic First, I create a general outline on a given topic. I chose ebooks. Develop a Twitter post on the topic of: "Here put your topic" using the APP (Awareness, Problem, Positioning) framework.
Make sure the tweet aligns with APP stages. This is what I get: Awareness: Discover the digital reading revolution. 📚 Ebooks or paper?
Problem: Paper waste grows. Ebooks offer eco-friendly alternatives for sustainable reading.Positioning: Make the switch. Embrace ebooks. Contribute to a greener planet. 🌱📱#DigitalReading #Sustainability Then, I adjust the given outline to fit into tweet requirements better and make it more digestible: Now, adjust the given outline into a Twitter tweet following the given rules.
Don't repeat yourself. Keep the language clear and simple.For each part follow the given rules:"Awareness": The hook of the tweet. Not more than 7 words allowed. Either in the imperative form or a question. No hashtags allowed."Problem": Logically explains the situation behind "Awareness". Not more than 10 words allowed."Positioning": Call to action regarding the "Problem". Not more than 5 words allowed.Make tweet informative. Assume the audience is new to the topic.No exclamation marks, no emojis That’s the result: Awareness: Opt for ebooks or paper?
Problem: Paper waste grows; ebooks offer sustainable reading alternatives.Positioning: Embrace ebooks, contribute to sustainability. That’s not the end though. I still want to take part in the discussion I created myself. How to include your personal perspective in the discussion? It’s always more authentic and fun to share your personal opinion on the given topic when posting on X. It sparkles up the discussion and makes people more prone to share their thoughts too. I do it like this: Now, get rid of the names of the following steps and form a final tweet.
Add my personal perspective in the fun and engaging way regarding: “here share your personal perspective/experience” I put: Bought my first Kindle last week, love it. And this is the final version I get: Ebooks or paper?
Paper waste grows; ebooks offer sustainable reading alternatives.
Embrace ebooks, contribute to sustainability.
Got my first Kindle last week—total game-changer. Come up with tweets that will make people join the conversation just under 5 minutes. Be consistent, and make your mark in the X community. Thanks for reading Productive Impact! Click subscribe on the left to receive new posts and support my work. Check out my newsletter. And other socials: @productiveimpct Why use AI for tweet writing? Well, why not? Posting on X, like many other tasks that require consistency, is something AI tools can help you with. Writing a tweet seems to be an easy and quick job, but done daily takes a lot of effort. To grow a following, you should post at least a few times a day. Coming up with so much content is demanding. I prefer to save time without compromising on the form and value given to followers. Now, I just need a general topic for the discussion in my mind and then let ChatGPT do the writing job. What does a ‘perfect’ attention-grabbing tweet include? While doing my research, I found out a perfect tweet has certain requirements. Should be short, not exploit the whole characters limit - in that case, rather posted in the form of a thread. Long-form works for certain types of write-ups, but not all. Should have a maximum of 3 or 4 relevant hashtags. Though, I’ve seen the ones without them received as more genuine. Should include a call to action. There are also some copywriting techniques that help develop an attention-grabbing tweet. The most popular is AIDA (Attention, Interest, Desire, Action), but I found out that actually, APP (Awareness, Problem, Positioning) can also be efficient for sparkling up discussions. Let’s see how to use them in ChatGPT. Practical ChatGPT Input for Tweets on Any Topic First, I create a general outline on a given topic. I chose ebooks. Develop a Twitter post on the topic of: "Here put your topic" using the APP (Awareness, Problem, Positioning) framework. Make sure the tweet aligns with APP stages. Develop a Twitter post on the topic of: "Here put your topic" using the APP (Awareness, Problem, Positioning) framework. Make sure the tweet aligns with APP stages. This is what I get: Awareness: Discover the digital reading revolution. 📚 Ebooks or paper? Problem: Paper waste grows. Ebooks offer eco-friendly alternatives for sustainable reading. Positioning: Make the switch. Embrace ebooks. Contribute to a greener planet. 🌱📱 #DigitalReading #Sustainability Awareness: Discover the digital reading revolution. 📚 Ebooks or paper? Problem: Paper waste grows. Ebooks offer eco-friendly alternatives for sustainable reading. Positioning: Make the switch. Embrace ebooks. Contribute to a greener planet. 🌱📱 #DigitalReading #Sustainability Then, I adjust the given outline to fit into tweet requirements better and make it more digestible: Now, adjust the given outline into a Twitter tweet following the given rules. Don't repeat yourself. Keep the language clear and simple. For each part follow the given rules: "Awareness": The hook of the tweet. Not more than 7 words allowed. Either in the imperative form or a question. No hashtags allowed. "Problem": Logically explains the situation behind "Awareness". Not more than 10 words allowed. "Positioning": Call to action regarding the "Problem". Not more than 5 words allowed. Make tweet informative. Assume the audience is new to the topic. No exclamation marks, no emojis Now, adjust the given outline into a Twitter tweet following the given rules. Don't repeat yourself. Keep the language clear and simple. For each part follow the given rules: "Awareness": The hook of the tweet. Not more than 7 words allowed. Either in the imperative form or a question. No hashtags allowed. "Problem": Logically explains the situation behind "Awareness". Not more than 10 words allowed. "Positioning": Call to action regarding the "Problem". Not more than 5 words allowed. Make tweet informative. Assume the audience is new to the topic. No exclamation marks, no emojis That’s the result: Awareness: Opt for ebooks or paper? Problem: Paper waste grows; ebooks offer sustainable reading alternatives. Positioning: Embrace ebooks, contribute to sustainability. Awareness: Opt for ebooks or paper? Problem: Paper waste grows; ebooks offer sustainable reading alternatives. Positioning: Embrace ebooks, contribute to sustainability. That’s not the end though. I still want to take part in the discussion I created myself. How to include your personal perspective in the discussion? It’s always more authentic and fun to share your personal opinion on the given topic when posting on X. It sparkles up the discussion and makes people more prone to share their thoughts too. I do it like this: Now, get rid of the names of the following steps and form a final tweet. Add my personal perspective in the fun and engaging way regarding: “here share your personal perspective/experience” Now, get rid of the names of the following steps and form a final tweet. Add my personal perspective in the fun and engaging way regarding: “here share your personal perspective/experience” I put: Bought my first Kindle last week, love it. And this is the final version I get: Ebooks or paper? Paper waste grows; ebooks offer sustainable reading alternatives. Embrace ebooks, contribute to sustainability. Got my first Kindle last week—total game-changer. Ebooks or paper? Paper waste grows; ebooks offer sustainable reading alternatives. Embrace ebooks, contribute to sustainability. Got my first Kindle last week—total game-changer. Come up with tweets that will make people join the conversation just under 5 minutes. Be consistent, and make your mark in the X community. Thanks for reading Productive Impact! Click subscribe on the left to receive new posts and support my work. Check out my newsletter . newsletter And other socials: @productiveimpct @productiveimpct

Here's How to Never Run Out of Tweet Ideas With ChatGPT

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

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

The Effectiveness of AI and ML on Supply Chains Amidst a Global Pandemic

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

has been nominated for a 2020 Noonie in the Future Heroes and Technology categories. are Hacker Noon’s way of getting to know — from a community perspective —  what matters in tech today. So, we asked our Noonie Nominees to tell us. Here’s what Joseph had to share. Joseph Chukwube from Nigeria The Noonies 1. Which 2020 Noonie have you been nominated for? Hacker Noon Contributor of the Year - AUGMENTED REALITY Security Advocate of the Year Hacker Noon Contributor of the Year - IoT 2. Tell us a bit about yourself. I'm a professional digital marketer; the founder of Digitage.net, a digital marketing agency. I'm highly enthusiastic about all things business and technology, and I share informative resources to help businesses and consumers stay informed, safer, and smarter online. 3. Tell us about the things you make / write / manage / build. I write about tech trends such as AR/VR and IoT, share cybersecurity tips and measures, and I discuss business strategies and solutions. 4. What are you most excited about right now? I'm excited and honored to have been nominated in this prestigious award, and in three categories at that! 5. What are you worried about right now? Nothing in particular 6. What's the most useful advice you've ever given somebody? If it's worth doing, it's worth doing properly! 7. How has the pandemic changed your life and/or career? The pandemic enabled me to take a deep self-reflection, overcome old weaknesses, and discover new strengths and new ways to get things done. I learned to diversify and learn a new hustle (Forex Trading) and I couldn't be happier. 8. If we gave you $10 million to invest in one thing right now, where would you put it? Real Estate 9. What's an opinion you have that most people don't agree with? I can't think of any. 10. What or Who are you keeping an eye on in 2020? The tech space and the innovations around AR/VR in regards to adapting to the new normal. 11. Which apps can't you live without? LinkedIn, Skype What are you currently learning? 13. Forex Trading For much the same reasons Hacker Noon decided not to put good ideas behind pop-ups or paywalls — nor abuse your personal data to target you with creepy ads — we also decided that you don’t have to be an influencer or have 50k followers on Twitter to earn the recognition that comes with a 2020 Noonie Nomination. Make somebody’s day and nominate them to be recognized in the internet’s most independent and community-driven awards: . NOONIES.TECH

"The Pandemic Enabled me to Take a Deep Self-reflection" - Joseph Chukwube, 2020 Noonie Nominee

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

The How and Why of Establishing Trust in High Schools How would your work in high school have been different if you knew that in order to earn a credit for it, it would be reviewed by an anonymous teacher outside your school and, if approved, would be posted online alongside the work of your peers across the planet? What if a college admissions officer or scholarship award committee needed little more than a student transcript to evaluate eligibility: no SAT, no entrance essay required. Imagine if students in classrooms across the nation could respond to a common assignment posted by FOX, CNN, NPR, AL JAZEERA or any media outlet seeking youth voices? What if teachers were incentivized to develop media projects? These thoughts are a subset of the implications of launching digital native high school credits. Here’s the short version of what sixteen years in public education taught me: federal budgets, union contracts, mayoral election cycles, and even the Supreme Court impose their authority on school communities to the detriment of students. Lawyers and politicians who rarely set foot in a school, let alone learn what it takes to mentor a young person who has experienced crippling poverty, make decisions about how things should be run. Even when these policies are well thought out, the next election cycle hits and the new administration always seeks to distinguish themselves from their predecessor. Within a school building, change fatigue is unavoidable: the average tenure of a principal in a New York City public school is less than four years. That is, the kids outlast their administration in high schools. I was myself an enthusiastic new teacher, but soon even I began folding my arms and waiting for each new initiative to pass me by. I had invested time to implement promising programs which had each since been discarded and replaced. And I worked for one of the best principals in the city — he was my role model. The remarkable thing is that despite the immense challenges, nearly every school community has a majority of teachers who work hard, and demand students do the same, maintaining stability in their classrooms despite the hurricane-like destruction of political seasons. Too often, these professionals have to isolate themselves to survive a career in this system, limiting their contribution to a single classroom or program within an otherwise dysfunctional community. I was trained as a principal within a network of alternative high school principals who taught me that I needed to dedicate my career to a single building if I hoped to build anything meaningful. These New York City Transfer Schools are, in my experience, among the most admirable leaders of the education reform movement. Alternative school students represent “limit conditions” in the sense that a physicist uses values like zero and infinity to test a new idea. In education reform, limit conditions include students who have been kicked out of every other school or faced the brutality of poverty or immigration status or racial injustice or gender discrimination or family tragedy or administrative runaround. Such “safety net” schools have a lot to teach us about what education reform is meaningful and what is just electioneering or (worse) profiteering in the name of public education. I get the same sense of limit conditions when I find myself at the family court building where foster care is litigated in downtown Manhattan. It’s where I get to see the impact of how we treat our poorest (in the financial sense) members of society. The solution of introducing digital native credits is surprisingly simple. Not that it will be easily implemented — that will require a miracle. But if you indulge me, the simplicity of just creating digital native ledger to record hard earned academic credits has implications which are quite exciting. In fintech, a digital native ledger, implemented using blockchain technology, is just like a modern checking account with the record of how much money is in each account being maintained by a global network of machines instead of by machines at a centralized headquarters like that of Bank of America. Similarly, high school credits are a centralized government ledger of certified student learning. What would happen if ledger were to be decentralized? that With a top-down system of record-keeping, substantial educational malpractice is unavoidable as union, legal, district, state, and federal government representatives lobby for adult interests in how credits are defined, losing sight of what is best for the students. Credits for learning devolve into flimsy proxies like seat time or test results. This systemic malfunction leads to regulations put in place to increase “accountability,” laying a foundation of mistrust. Dealing with mistrust becomes the core work of school and district leaders, hassling teachers for more “data” than they would otherwise need while being tied down by ordinances which act as bandages to lawsuits that had exposed the systemic malpractice. Consider the implications for colleges and universities of these watered-down public-school credits. They have been forced to create a separate system to evaluate student learning beyond the high school transcript which is a step away from being totally useless in any standardized way across the nation, let alone across the planet. The SAT/ACT and college essays are needed because public high school credits are not trusted by universities to represent any reliable learning across all schools. High school credits are “soft” in the same way that the US Dollar is a “soft” asset — it can be easily inflated, and that is exactly what happens. Just as bitcoin stores hard earned money, blockchain credits store hard earned academic credit. Permanently. More specifically, every credit is linked to a digital file (QR codes when printed on paper). Click or scan the credit to find content such as a PDF monograph, MP3 podcast, or MP4 video. A student uploads original content in exchange for a credit on their transcript. A transcript that is known for representing a higher standard of learning 100% of the time, verified by following the link to see the quality of student work produced. In such a system, student work is the only currency we need to focus on if we are hoping to improve the quality of public high school education. Schools producing high quality student-produced content are good schools. The surprising byproduct of the simple act of creating digital-native high school credits is that an online network of curated student media is born. Each time a student uploads their work for credit, the network owns another asset. Poor quality work is not allowed into the network by those evaluating the work for credit. The incentives are designed to ensure alignment to a new “gold standard” credit. Producing high quality content is really hard. While teachers can be trained in video production, audio editing, and research/writing, and teacher training programs should do this, students must be incentivized by the culture to invest their sweat equity. This is where the title of this book comes from. A BIG Deal for Education hangs a Basic Income Guarantee (“BIG”) as an incentive “carrot” driving this network of high-quality student media. Every year a small number of students will earn a Basic Income Guarantee as a result of their high school media productions. The idea is to offer a financial incentive based on work product in the same way that the digital network economy that students are graduating into will award payment. Just punching in and logging time in school will not earn this reward — hard work that leads to a quality product that has social impact will be required. The BIG Deal is a way to: 1. Incentivize citizens to accelerate the digital economy 2. Invest in diversity 3. Invest in our young citizens who are ready to work hard and produce high quality digital products 4. Phase in a Basic Income Guarantee At first very few BIG Awards would be given. Each award would be a big deal. As the network grows, more awards become available. The BIG Award is an incentive, but the crucial element of such a system would be the value of the credits themselves. That is, it will be critical that earning these BIG Credits will be demanded by universities first, then parents, pressuring schools to increase their support for students to earn these “gold standard” digital-native, globally recognized credits. The relatively few students who actually earn a BIG will incentivize competition and diversity which I address in a separate chapter. The number of BIG credits will be linked to the amount of money that is invested for this purpose in each local community. Perhaps a city invests to award one student per school with the BIG, perhaps a philanthropist invests in more for a specific school, a specific district, or nationally. The BIG Deal will offer a high leverage means for governments and philanthropists alike to invest in the incentives that drive high school learning. Such a credit system would demand that if politicians wanted “BIG Certification” rates in these credits to increase, they would be forced to focus on the quality of students’ work, as evaluated by anonymous and independent master teachers outside of the student’s school. No longer could they doctor the cutoff score of exams or change standards or otherwise manufacture statistics needed for their next election bid. No longer can students sweet talk their teachers into getting a better grade than they deserve. Decentralized credits would be entirely validated based on quality of work as determined by anonymous master teachers. The next obvious questions are: who gets to be a master teacher? And how do master teachers normalize their practice? Remember the only currency that matters in this system is student work. It is important to keep our focus on that atomic source of value. A teacher could only, then, earn the master teacher credential after their students consistently and over a period of ten years, upload work which is approved for credit by the existing master teacher community. It is hard to game such a system when a student video is the artifact being evaluated for credits relating to academic research or digital production standards. Teachers would invest for a decade as unpaid adjuncts before being paid generously to evaluate incoming work based on clearly defined credit standards. With the administrative act of decentralizing high school record-keeping, we would effectively transfer the authority to award digital high school credits from state governments to a network of veteran educators. A college admissions officer at your alma mater who clicks on any credit shown on such a digital transcript would see the culminating task that resulted from that learning. And they would be impressed by the production values, the research, the writing, the creativity, the mastery of the medium used. Note that the credit blockchain only captures the polished student voice, not the content or application sweat equity layers that go into publishing that digital file. More specifically: · (off chain): students study relevant content (flash cards, quizzes, practice problems, academic habits); Layer I · (off chain): students integrate content into their own worldview through application assignments such as forming their own questions about the content, reflecting on learning in journals, planning their extension project by writing scripts; Layer II · “ :” students extended their learning to the real world with multiple revisions to produce a final product that is local, academic, nuanced, and self-aware. BIG Layer After a while, that college admissions officer would learn that they can trust these golden digital native credits to represent meaningful learning experiences for those few students who were able to achieve them. They would not need to take time to click on every single link to verify what the transcript represented, although by doing so, they would learn much more about the student’s unique voice and skills than any essay or standardized exam can show in the college admissions process. These golden measures of academic value would not replace local centralized credit systems which would remain in place to capture students work in layer I and layer II activities. The intention is that the global BIG Standards would drive local school districts to adjust their content and application activities to help students achieve subsequent BIG Credits because of the demand for these opportunities by parents and the students themselves. BIG Credits would exist on top of these systems the way college applications and the SAT do today, and universities would be encouraged to evaluate students with BIG Credits without asking them to write essays or take standardized tests, thus freeing students to seek BIG credits with dreams of achieving the ultimate prize of the income guarantee, the Basic Income Guarantee. Even more than money, high school students care about how they look in front of peers. By creating a public ledger of their podcasts, PDF monographs, and videos showing them applying digital habits to local issues we learn about our own society through fresh eyes while grounding our young people’s academic learning in the complex, messy, and ambiguous world they live in. By defining a set of digital-native standards and awarding students who meet those standards on a public blockchain, we can force local education districts to rearrange their efforts, refocusing on the quality of student work products as evaluated by objective colleagues who use the standards to determine which pieces are approved for a BIG Credit. #DigitalNativeAcademicCredits This essay appears as a Chapter in my upcoming book “ The BIG Deal : the end of jobs, the e-birth of work, and a role for education ” You can hear me discussing the book . here Follow @NZeimer . A more technically complete version of this blog post is here: CryptoCredit whitepaper . Click and hold that CLAP button so that more people find this idea. Progress on book publication and advance orders available at TheBIG.net

Stories, News & Mentions about DIGITARENA

Categories

Trending Topics

Stories, News & Mentions about DIGITARENA

Digitarena’s Stories on HackerNoon

Categories

Trending Topics