Member Spotlight
Posts: 19
Joined: September 2021
Today's Birthdays
There are no members with birthdays on this day.
Popular Topics (Views)
35,720 Motivation
17,608 Rainbow War
Top Posters (30 Days)
John 4
Belma 3
shayla 1
von 1
Forum Statistics
Forums6
Topics530
Posts2,472
Members202
Most Online366
Nov 11th, 2023
Previous Thread
Next Thread
Print Thread
Rate Thread
Hop To
#438 05/10/2021 11:29 AM
Joined: Dec 2020
Posts: 103
Likes: 6
Ghast
OP Offline
Ghast
Joined: Dec 2020
Posts: 103
Likes: 6
This week in Robotics, we're going to create a project that incorporates an LCD screen. Here are some components to consider!

Resistors
Breadboard

Outputs
LEDs
LEDs (RGB)
Vibration Motor
DC Motor
Micro Servo
Hobby Gearmotor
Piezo speaker

Inputs
Push Buttons
Potentiometer
Slideswitch
Photoresistor (LDR)
Ultrasonic Distance Sensor
Temperature Sensor
PIR Sensor (Passive Infrared Motion Sensor)

Ideas?


"Kindness is the language which the deaf can hear and the blind can see." - Christian Nestell Bovee
Joined: Dec 2020
Posts: 103
Likes: 6
Ghast
OP Offline
Ghast
Joined: Dec 2020
Posts: 103
Likes: 6
How about this one!

https://www.tinkercad.com/things/iK9JHSOOUcW-copy-of-arduino-lcd-game/editel?tenant=circuits

[Linked Image]

Code Below

Code
#include <LiquidCrystal.h>

#define PIN_BUTTON 2
#define PIN_AUTOPLAY 1
#define PIN_READWRITE 10
#define PIN_CONTRAST 12

#define SPRITE_RUN1 1
#define SPRITE_RUN2 2
#define SPRITE_JUMP 3
#define SPRITE_JUMP_UPPER '.'         // Use the '.' character for the head
#define SPRITE_JUMP_LOWER 4
#define SPRITE_TERRAIN_EMPTY ' '      // User the ' ' character
#define SPRITE_TERRAIN_SOLID 5
#define SPRITE_TERRAIN_SOLID_RIGHT 6
#define SPRITE_TERRAIN_SOLID_LEFT 7

#define HERO_HORIZONTAL_POSITION 1    // Horizontal position of hero on screen

#define TERRAIN_WIDTH 16
#define TERRAIN_EMPTY 0
#define TERRAIN_LOWER_BLOCK 1
#define TERRAIN_UPPER_BLOCK 2

#define HERO_POSITION_OFF 0          // Hero is invisible
#define HERO_POSITION_RUN_LOWER_1 1  // Hero is running on lower row (pose 1)
#define HERO_POSITION_RUN_LOWER_2 2  //                              (pose 2)

#define HERO_POSITION_JUMP_1 3       // Starting a jump
#define HERO_POSITION_JUMP_2 4       // Half-way up
#define HERO_POSITION_JUMP_3 5       // Jump is on upper row
#define HERO_POSITION_JUMP_4 6       // Jump is on upper row
#define HERO_POSITION_JUMP_5 7       // Jump is on upper row
#define HERO_POSITION_JUMP_6 8       // Jump is on upper row
#define HERO_POSITION_JUMP_7 9       // Half-way down
#define HERO_POSITION_JUMP_8 10      // About to land

#define HERO_POSITION_RUN_UPPER_1 11 // Hero is running on upper row (pose 1)
#define HERO_POSITION_RUN_UPPER_2 12 //                              (pose 2)

LiquidCrystal lcd(11, 9, 6, 5, 4, 3);
static char terrainUpper[TERRAIN_WIDTH + 1];
static char terrainLower[TERRAIN_WIDTH + 1];
static bool buttonPushed = false;

void initializeGraphics(){
  static byte graphics[] = {
    // Run position 1
    B01100,
    B01100,
    B00000,
    B01110,
    B11100,
    B01100,
    B11010,
    B10011,
    // Run position 2
    B01100,
    B01100,
    B00000,
    B01100,
    B01100,
    B01100,
    B01100,
    B01110,
    // Jump
    B01100,
    B01100,
    B00000,
    B11110,
    B01101,
    B11111,
    B10000,
    B00000,
    // Jump lower
    B11110,
    B01101,
    B11111,
    B10000,
    B00000,
    B00000,
    B00000,
    B00000,
    // Ground
    B11111,
    B11111,
    B11111,
    B11111,
    B11111,
    B11111,
    B11111,
    B11111,
    // Ground right
    B00011,
    B00011,
    B00011,
    B00011,
    B00011,
    B00011,
    B00011,
    B00011,
    // Ground left
    B11000,
    B11000,
    B11000,
    B11000,
    B11000,
    B11000,
    B11000,
    B11000,
  };
  int i;
  // Skip using character 0, this allows lcd.print() to be used to
  // quickly draw multiple characters
  for (i = 0; i < 7; ++i) {
	  lcd.createChar(i + 1, &graphics[i * 8]);
  }
  for (i = 0; i < TERRAIN_WIDTH; ++i) {
    terrainUpper[i] = SPRITE_TERRAIN_EMPTY;
    terrainLower[i] = SPRITE_TERRAIN_EMPTY;
  }
}

// Slide the terrain to the left in half-character increments
//
void advanceTerrain(char* terrain, byte newTerrain){
  for (int i = 0; i < TERRAIN_WIDTH; ++i) {
    char current = terrain[i];
    char next = (i == TERRAIN_WIDTH-1) ? newTerrain : terrain[i+1];
    switch (current){
      case SPRITE_TERRAIN_EMPTY:
        terrain[i] = (next == SPRITE_TERRAIN_SOLID) ? SPRITE_TERRAIN_SOLID_RIGHT : SPRITE_TERRAIN_EMPTY;
        break;
      case SPRITE_TERRAIN_SOLID:
        terrain[i] = (next == SPRITE_TERRAIN_EMPTY) ? SPRITE_TERRAIN_SOLID_LEFT : SPRITE_TERRAIN_SOLID;
        break;
      case SPRITE_TERRAIN_SOLID_RIGHT:
        terrain[i] = SPRITE_TERRAIN_SOLID;
        break;
      case SPRITE_TERRAIN_SOLID_LEFT:
        terrain[i] = SPRITE_TERRAIN_EMPTY;
        break;
    }
  }
}

bool drawHero(byte position, char* terrainUpper, char* terrainLower, unsigned int score) {
  bool collide = false;
  char upperSave = terrainUpper[HERO_HORIZONTAL_POSITION];
  char lowerSave = terrainLower[HERO_HORIZONTAL_POSITION];
  byte upper, lower;
  switch (position) {
    case HERO_POSITION_OFF:
      upper = lower = SPRITE_TERRAIN_EMPTY;
      break;
    case HERO_POSITION_RUN_LOWER_1:
      upper = SPRITE_TERRAIN_EMPTY;
      lower = SPRITE_RUN1;
      break;
    case HERO_POSITION_RUN_LOWER_2:
      upper = SPRITE_TERRAIN_EMPTY;
      lower = SPRITE_RUN2;
      break;
    case HERO_POSITION_JUMP_1:
    case HERO_POSITION_JUMP_8:
      upper = SPRITE_TERRAIN_EMPTY;
      lower = SPRITE_JUMP;
      break;
    case HERO_POSITION_JUMP_2:
    case HERO_POSITION_JUMP_7:
      upper = SPRITE_JUMP_UPPER;
      lower = SPRITE_JUMP_LOWER;
      break;
    case HERO_POSITION_JUMP_3:
    case HERO_POSITION_JUMP_4:
    case HERO_POSITION_JUMP_5:
    case HERO_POSITION_JUMP_6:
      upper = SPRITE_JUMP;
      lower = SPRITE_TERRAIN_EMPTY;
      break;
    case HERO_POSITION_RUN_UPPER_1:
      upper = SPRITE_RUN1;
      lower = SPRITE_TERRAIN_EMPTY;
      break;
    case HERO_POSITION_RUN_UPPER_2:
      upper = SPRITE_RUN2;
      lower = SPRITE_TERRAIN_EMPTY;
      break;
  }
  if (upper != ' ') {
    terrainUpper[HERO_HORIZONTAL_POSITION] = upper;
    collide = (upperSave == SPRITE_TERRAIN_EMPTY) ? false : true;
  }
  if (lower != ' ') {
    terrainLower[HERO_HORIZONTAL_POSITION] = lower;
    collide |= (lowerSave == SPRITE_TERRAIN_EMPTY) ? false : true;
  }
  
  byte digits = (score > 9999) ? 5 : (score > 999) ? 4 : (score > 99) ? 3 : (score > 9) ? 2 : 1;
  
  // Draw the scene
  terrainUpper[TERRAIN_WIDTH] = '\0';
  terrainLower[TERRAIN_WIDTH] = '\0';
  char temp = terrainUpper[16-digits];
  terrainUpper[16-digits] = '\0';
  lcd.setCursor(0,0);
  lcd.print(terrainUpper);
  terrainUpper[16-digits] = temp;  
  lcd.setCursor(0,1);
  lcd.print(terrainLower);
  
  lcd.setCursor(16 - digits,0);
  lcd.print(score);

  terrainUpper[HERO_HORIZONTAL_POSITION] = upperSave;
  terrainLower[HERO_HORIZONTAL_POSITION] = lowerSave;
  return collide;
}

// Handle the button push as an interrupt
void buttonPush() {
  buttonPushed = true;
}

void setup(){
  pinMode(PIN_READWRITE, OUTPUT);
  digitalWrite(PIN_READWRITE, LOW);
  pinMode(PIN_CONTRAST, OUTPUT);
  digitalWrite(PIN_CONTRAST, LOW);
  pinMode(PIN_BUTTON, INPUT);
  digitalWrite(PIN_BUTTON, HIGH);
  pinMode(PIN_AUTOPLAY, OUTPUT);
  digitalWrite(PIN_AUTOPLAY, HIGH);
  
  // Digital pin 2 maps to interrupt 0
  attachInterrupt(0/*PIN_BUTTON*/, buttonPush, FALLING);
  
  initializeGraphics();
  
  lcd.begin(16, 2);
}

void loop(){
  static byte heroPos = HERO_POSITION_RUN_LOWER_1;
  static byte newTerrainType = TERRAIN_EMPTY;
  static byte newTerrainDuration = 1;
  static bool playing = false;
  static bool blink = false;
  static unsigned int distance = 0;
  
  if (!playing) {
    drawHero((blink) ? HERO_POSITION_OFF : heroPos, terrainUpper, terrainLower, distance >> 3);
    if (blink) {
      lcd.setCursor(0,0);
      lcd.print("Press Start");
    }
    delay(250);
    blink = !blink;
    if (buttonPushed) {
      initializeGraphics();
      heroPos = HERO_POSITION_RUN_LOWER_1;
      playing = true;
      buttonPushed = false;
      distance = 0;
    }
    return;
  }

  // Shift the terrain to the left
  advanceTerrain(terrainLower, newTerrainType == TERRAIN_LOWER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
  advanceTerrain(terrainUpper, newTerrainType == TERRAIN_UPPER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
  
  // Make new terrain to enter on the right
  if (--newTerrainDuration == 0) {
    if (newTerrainType == TERRAIN_EMPTY) {
      newTerrainType = (random(3) == 0) ? TERRAIN_UPPER_BLOCK : TERRAIN_LOWER_BLOCK;
      newTerrainDuration = 2 + random(10);
    } else {
      newTerrainType = TERRAIN_EMPTY;
      newTerrainDuration = 10 + random(10);
    }
  }
    
  if (buttonPushed) {
    if (heroPos <= HERO_POSITION_RUN_LOWER_2) heroPos = HERO_POSITION_JUMP_1;
    buttonPushed = false;
  }  

  if (drawHero(heroPos, terrainUpper, terrainLower, distance >> 3)) {
    playing = false; // The hero collided with something. Too bad.
  } else {
    if (heroPos == HERO_POSITION_RUN_LOWER_2 || heroPos == HERO_POSITION_JUMP_8) {
      heroPos = HERO_POSITION_RUN_LOWER_1;
    } else if ((heroPos >= HERO_POSITION_JUMP_3 && heroPos <= HERO_POSITION_JUMP_5) && terrainLower[HERO_HORIZONTAL_POSITION] != SPRITE_TERRAIN_EMPTY) {
      heroPos = HERO_POSITION_RUN_UPPER_1;
    } else if (heroPos >= HERO_POSITION_RUN_UPPER_1 && terrainLower[HERO_HORIZONTAL_POSITION] == SPRITE_TERRAIN_EMPTY) {
      heroPos = HERO_POSITION_JUMP_5;
    } else if (heroPos == HERO_POSITION_RUN_UPPER_2) {
      heroPos = HERO_POSITION_RUN_UPPER_1;
    } else {
      ++heroPos;
    }
    ++distance;
    
    digitalWrite(PIN_AUTOPLAY, terrainLower[HERO_HORIZONTAL_POSITION + 2] == SPRITE_TERRAIN_EMPTY ? HIGH : LOW);
  }
  delay(50);
}

Last edited by matthews; 05/12/2021 9:47 AM. Reason: added spoiler tag to shorten the overall length of the post

"Kindness is the language which the deaf can hear and the blind can see." - Christian Nestell Bovee
Joined: Dec 2020
Posts: 103
Likes: 6
Ghast
OP Offline
Ghast
Joined: Dec 2020
Posts: 103
Likes: 6
[Linked Image]


Code Below
Code
#include <LiquidCrystal.h>
// initialize the LCD library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Distance Sensor declarations
const int trigger	=	8; 
const int echo		=	9; 
float dist, distIN, distCM;

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  
  // Distance Sensor setup
  Serial.begin(9600);		// Allows us to see results in the serial monitor
  pinMode(trigger,OUTPUT);
  pinMode(echo,INPUT);

}

void loop() {
  digitalWrite(trigger,LOW);
  delayMicroseconds(5);       
  digitalWrite(trigger,HIGH);   
  delayMicroseconds(10);     
  digitalWrite(trigger,LOW);    
  dist=pulseIn(echo,HIGH);      
  distCM = dist/58;			// calculate metric
  distIN = dist/148;		// calculate imperial
                    
  Serial.print("Distance: " + String(distCM) + " cm. :: " + String(distIN) + " in.");
  Serial.write (10);     
  
  lcd.setCursor(0, 0);	// column 0, row 0 (first row, first column)
  lcd.print("DIST: " + String(distCM) + " cm.");
  lcd.setCursor(0,1);
  lcd.print("DIST: " + String(distIN) + "  in.");

  delay (200);   
}
 

Last edited by matthews; 05/12/2021 9:45 AM.

"Kindness is the language which the deaf can hear and the blind can see." - Christian Nestell Bovee
Joined: Dec 2020
Posts: 103
Likes: 6
Ghast
OP Offline
Ghast
Joined: Dec 2020
Posts: 103
Likes: 6


"Kindness is the language which the deaf can hear and the blind can see." - Christian Nestell Bovee
Joined: Dec 2020
Posts: 103
Likes: 6
Ghast
OP Offline
Ghast
Joined: Dec 2020
Posts: 103
Likes: 6


Scroll Single LCD Line

To use:

Declare a variable near the top of your code:
Code
int delayTime2 = 350; // Delay between shifts

Then, there are two functions you can use:
Code
void scrollInFromRight (int line, char str1[]) 
{
    // Written by R. Jordan Kreindler June 2016
    i = strlen(str1);
    for (j = 16; j >= 0; j--) {
        lcd.setCursor(0, line);
            for (k = 0; k <= 15; k++) {
                lcd.print(" "); // Clear line
            }
        lcd.setCursor(j, line);
        lcd.print(str1);
        delay(delayTime2);
    }
}

AND

Code
void scrollInFromLeft (int line, char str1[]) 
{
    // Written by R. Jordan Kreindler June 2016
    i = 40 - strlen(str1);
    line = line - 1;
    for (j = i; j <= i + 16; j++) {
        for (k = 0; k <= 15; k++) {
            lcd.print(" "); // Clear line
        }
        lcd.setCursor(j, line);
        lcd.print(str1);
        delay(delayTime2);
    }
}

Then, lastly...to use these functions, you'd put something like this in your loop()

Code
lcd.clear();
scrollInFromRight(0, "Line1 From Right");
scrollInFromRight(1, "Line2 From Right");
lcd.clear();
scrollInFromLeft(0, "Line1 From Left.");
scrollInFromLeft(1, "Line2 From Left.");
lcd.clear();
scrollInFromRight(0, "Line1 From Right");
scrollInFromLeft(1, "Line2 From Left.");
lcd.clear();


"Kindness is the language which the deaf can hear and the blind can see." - Christian Nestell Bovee

Link Copied to Clipboard
Who's Online Now
0 members (), 17 guests, and 42 robots.
Key: Admin, Global Mod, Mod
Newest Members
Isaiah blackwell, Daniela, Emi Yamamoto, von, w rizz 22
202 Registered Users
March
S M T W T F S
1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31
Powered by UBB.threads™ PHP Forum Software 7.7.5