8X8 Digital display board

 /*  

      8x8 LED Matrix MAX7219 Scrolling Text Example

   Based on the following library:

   GitHub | riyas-org/max7219  https://github.com/riyas-org/max7219

*/

#include <MaxMatrix.h>

#include <avr/pgmspace.h>

PROGMEM const unsigned char CH[] = {

  3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space

  1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !

  3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "

  5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #

  4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $

  5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %

  5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &

  1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '

  3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (

  3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )

  5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *

  5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +

  2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,

  4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -

  2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .

  4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /

  4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0

  3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1

  4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2

  4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3

  4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4

  4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5

  4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6

  4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7

  4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8

  4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9

  2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :

  2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;

  3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <

  3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =

  3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >

  4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?

  5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @

  4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A

  4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B

  4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C

  4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D

  4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E

  4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F

  4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G

  4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H

  3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I

  4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J

  4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K

  4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L

  5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M

  5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N

  4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O

  4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P

  4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q

  4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R

  4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S

  5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T

  4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U

  5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V

  5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W

  5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X

  5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y

  4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z

  2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [

  4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash

  2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]

  3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat

  4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _

  2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `

  4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a

  4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b

  4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c

  4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d

  4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e

  3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f

  4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g

  4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h

  3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i

  4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j

  4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k

  3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l

  5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m

  4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n

  4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o

  4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p

  4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q

  4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r

  4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s

  3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t

  4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u

  5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v

  5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w

  5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x

  4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y

  3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z

  3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {

  1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |

  3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }

  4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~

};

int DIN = 7;   // DIN pin of MAX7219 module

int CLK = 6;   // CLK pin of MAX7219 module

int CS = 5;    // CS pin of MAX7219 module

int maxInUse = 5;

MaxMatrix m(DIN, CS, CLK, maxInUse);

byte buffer[10];

char text[]= " WELCOME TO STEM " ; // Scrolling text

void setup() {

  m.init(); // module initialize

  m.setIntensity(15); // dot matix intensity 0-15

}

 

void loop() {

  printStringWithShift(text, 100); // (text, scrolling speed)

}

// Display=the extracted characters with scrolling

void printCharWithShift(char c, int shift_speed) {

  if (c < 32) return;

  c -= 32;

  memcpy_P(buffer, CH + 7 * c, 7);

  m.writeSprite(32, 0, buffer);

  m.setColumn(32 + buffer[0], 0);

  for (int i = 0; i < buffer[0] + 1; i++)

  {

    delay(shift_speed);

    m.shiftLeft(false, false);

  }

}

// Extract the characters from the text string

void printStringWithShift(char* s, int shift_speed) {

  while (*s != 0) {

    printCharWithShift(*s, shift_speed);

    s++;

  }

}

I2C LCD Scrolling Display

 #include <Wire.h>

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2); // Set the LCD address to 0x27 for a 16 chars and 2 line display

void setup() {

  lcd.init();         // Initialize the LCD

  lcd.backlight();    // Turn on the LCD screen backlight

}

void loop() {

  // Message to scroll

  String message = "Hello World.! Sunil Singh ";

  int messageLength = message.length();

  // Scroll the message across the LCD

  for (int pos = 0; pos < messageLength; pos++) {

    lcd.clear(); // Clear the LCD for each new position

    lcd.setCursor(0, 0); // Set cursor to the first line

    lcd.print(message.substring(pos, pos + 16)); // Print 16 characters

    delay(300); // Delay for a smoother scroll

  }

  // Short delay before next message

  delay(1000);

  // Now display another message

  lcd.clear();

  lcd.setCursor(0, 0);

  lcd.print("This is a LCD");   // First line

  lcd.setCursor(0, 1);

  lcd.print("Screen Test");      // Second line

  delay(3000); // Display for 3 seconds

}

LCD I2C Module Test

/*

 Sunil_Singh_STEM

*/

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2); // set the LCD address to 0x27 for a 16 chars and 2 line display

void setup() {

  lcd.init();         // initialize the lcd

  lcd.backlight();    // Turn on the LCD screen backlight

}

void loop() {

  lcd.setCursor(2, 0);

  lcd.print("Hello World.! ");

  delay(3000);

  lcd.clear();

  lcd.setCursor(2, 0);

  lcd.print("This is Sunil ");

  lcd.setCursor(2, 1);

  lcd.print("Screen Test");

  delay(3000);

  lcd.clear();

}

LED Control using Camera (Sunil)

 #include <Firmata.h>

byte ledPinMap[5] = {2, 3, 4, 5, 6};  // Map each LED to specific pins

byte ledState[5] = {0, 0, 0, 0, 0};   // Keep track of LED states (ON/OFF)

void analogWriteCallback(byte pin, int value)

{

  if (IS_PIN_DIGITAL(pin)) {

    // Check if the value is greater than a threshold to turn the LED on/off

    if (value > 127) {

      digitalWrite(ledPinMap[pin], HIGH);  // Turn on the LED

    } else {

      digitalWrite(ledPinMap[pin], LOW);   // Turn off the LED

    }

  }

}

void systemResetCallback()

{

  // Reset all LEDs to off

  for (byte i = 0; i < 5; i++) {

    ledState[i] = LOW;

    digitalWrite(ledPinMap[i], LOW);

  }

}

void setup()

{

  Firmata.setFirmwareVersion(FIRMATA_FIRMWARE_MAJOR_VERSION, FIRMATA_FIRMWARE_MINOR_VERSION);

  Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);

  Firmata.attach(SYSTEM_RESET, systemResetCallback);

  Firmata.begin(57600);

  systemResetCallback();

  // Set up LED pins as OUTPUT and turn them off initially

  for (byte i = 0; i < 5; i++) {

    pinMode(ledPinMap[i], OUTPUT);

    digitalWrite(ledPinMap[i], LOW);

  }

}

void loop()

{

  while (Firmata.available())

    Firmata.processInput();

}