/*
  Servo and LCD 16x2 using Franzininho, Slide potentiometer and LCD 16x2 i2c
  by Anderson Costa with ❤ for the Wokwi community
  Visit https://wokwi.com to learn about the Wokwi Simulator
  Visit https://franzininho.com.br to learn about the Franzininho
*/
#include "LiquidCrystal_I2C.h"
#include "Servo8Bit.h"

#define SERVO_PIN          PB1           // Define o pino onde o servo está conectado
#define SLIDE_PIN          PB3           // Define o pino onde o potenciômetro está conectado

int main()
{
    Servo8Bit myServo;                   // Cria um objeto servo
    myServo.attach(SERVO_PIN);           // Conecta o servo ao pino PB1

    LiquidCrystal_I2C lcd(0x27, 16, 2);  // Define endereço e 16 caracteres/2 linhas

    lcd.init();                          // Inicializa o display
    lcd.backlight();                     // Acende a luz de fundo do display
    lcd.clear();                         // Limpa o display
    lcd.setCursor(0, 0);                 // Coloca o cursor na primeira linha
    lcd.print("ANGULO DO SERVO:");       // Imprime a mensagem no display
    lcd.setCursor(0, 1);                 // Coloca o cursor na segunda linha
    lcd.print("ADC:");                   // Imprime a mensagem no display

    // Faz a leitura do potenciometro, imprime no display e controla o servo
    while (1) {
        // Obtém o resultado do potenciômetro, ADC de 10 bits (0-1023)
        int pot = analogRead(SLIDE_PIN);

        // Coloca na posição do valor do ADC no display
        lcd.setCursor(5, 1);
        lcd.print(pot);
        lcd.print("   ");                // Limpa o valor anterior que ficou na frente

        // Converte para um valor entre 0 e 180 para ficar longe de overflows adjacentes
        int pos = map(pot, 0, 1023, 0, 180);

        // Coloca na posição do valor do ângulo do servo no display
        lcd.setCursor(12, 1);
        lcd.print(pos);
        lcd.print((char)223);
        lcd.print("  ");                 // Limpa o valor anterior que ficou na frente

        myServo.write(pos);              // Define o servo para ir para a posição na variável 'pos'
        myServo.delay(15);               // Espera 15ms para o servo alcançar a posição
    }
}


franzininho-servo.cpp

diagram.json

/*
  LiquidCrystal_I2C for ATtiny85
  Author: Frank de Brabander
  Version: 1.1.2 modified for ATtiny85
*/
#include "LiquidCrystal_I2C.h"

// When the display powers up, it is configured as follows:
//
// 1. Display clear
// 2. Function set:
//    DL = 1; 8-bit interface data
//    N = 0; 1-line display
//    F = 0; 5x8 dot character font
// 3. Display on/off control:
//    D = 0; Display off
//    C = 0; Cursor off
//    B = 0; Blinking off
// 4. Entry mode set:
//    I/D = 1; Increment by 1
//    S = 0; No shift
//
// Note, however, that resetting the Arduino doesn't reset the LCD, so we
// can't assume that its in that state when a sketch starts (and the
// LiquidCrystal constructor is called).

LiquidCrystal_I2C::LiquidCrystal_I2C(uint8_t lcd_addr, uint8_t lcd_cols, uint8_t lcd_rows, uint8_t charsize)
{
  _addr = lcd_addr;
  _cols = lcd_cols;
  _rows = lcd_rows;
  _charsize = charsize;
  _backlightval = LCD_BACKLIGHT;
}

void LiquidCrystal_I2C::init() {
  init_priv();
}

void LiquidCrystal_I2C::init_priv()
{
  TinyWireM.begin();             // Initialize I2C lib
  _displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
  LiquidCrystal_I2C::begin(_cols, _rows);
}

void LiquidCrystal_I2C::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {
  if (_rows > 1) {
    _displayfunction |= LCD_2LINE;
  }

  // For some 1 line displays you can select a 10 pixel high font
  if ((_charsize != 0) && (_rows == 1)) {
    _displayfunction |= LCD_5x10DOTS;
  }

  // According to datasheet, we need at least 40ms after power rises above 2.7V
  // before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
  delay(50);

  // Now we pull both RS and R/W low to begin commands
  expanderWrite(_backlightval);	// reset expanderand turn backlight off (Bit 8 =1)
  delay(1000);

  // Put the LCD into 4 bit mode
  // this is according to the hitachi HD44780 datasheet

  // We start in 8bit mode, try to set 4 bit mode
  write4bits(0x03 << 4);
  delayMicroseconds(4500); // wait min 4.1ms

  // Second try
  write4bits(0x03 << 4);
  delayMicroseconds(4500); // wait min 4.1ms

  // Third go!
  write4bits(0x03 << 4);
  delayMicroseconds(150);

  // Finally, set to 4-bit interface
  write4bits(0x02 << 4);

  // Set # lines, font size, etc.
  command(LCD_FUNCTIONSET | _displayfunction);

  // Turn the display on with no cursor or blinking default
  _displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
  display();

  // Clear it off
  clear();

  // Initialize to default text direction (for roman languages)
  _displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;

  // Set the entry mode
  command(LCD_ENTRYMODESET | _displaymode);

  home();
}

/********** high level commands, for the user! */
void LiquidCrystal_I2C::clear() {
  command(LCD_CLEARDISPLAY);// Clear display, set cursor position to zero
  delayMicroseconds(2000);  // This command takes a long time!
}

void LiquidCrystal_I2C::home() {
  command(LCD_RETURNHOME);  // Set cursor position to zero
  delayMicroseconds(2000);  // This command takes a long time!
}

void LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row) {
  int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
  if (row > _rows) {
    row = _rows - 1;  // We count rows starting w/0
  }
  command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}

// Turn the display on/off (quickly)
void LiquidCrystal_I2C::noDisplay() {
  _displaycontrol &= ~LCD_DISPLAYON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::display() {
  _displaycontrol |= LCD_DISPLAYON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turns the underline cursor on/off
void LiquidCrystal_I2C::noCursor() {
  _displaycontrol &= ~LCD_CURSORON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::cursor() {
  _displaycontrol |= LCD_CURSORON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turn on and off the blinking cursor
void LiquidCrystal_I2C::noBlink() {
  _displaycontrol &= ~LCD_BLINKON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::blink() {
  _displaycontrol |= LCD_BLINKON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// These commands scroll the display without changing the RAM
void LiquidCrystal_I2C::scrollDisplayLeft(void) {
  command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void LiquidCrystal_I2C::scrollDisplayRight(void) {
  command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}

// This is for text that flows Left to Right
void LiquidCrystal_I2C::leftToRight(void) {
  _displaymode |= LCD_ENTRYLEFT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// This is for text that flows Right to Left
void LiquidCrystal_I2C::rightToLeft(void) {
  _displaymode &= ~LCD_ENTRYLEFT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'right justify' text from the cursor
void LiquidCrystal_I2C::autoscroll(void) {
  _displaymode |= LCD_ENTRYSHIFTINCREMENT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'left justify' text from the cursor
void LiquidCrystal_I2C::noAutoscroll(void) {
  _displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// Allows us to fill the first 8 CGRAM locations
// with custom characters
void LiquidCrystal_I2C::createChar(uint8_t location, uint8_t charmap[]) {
  location &= 0x7; // we only have 8 locations 0-7
  command(LCD_SETCGRAMADDR | (location << 3));
  for (int i = 0; i < 8; i++) {
    write(charmap[i]);
  }
}

// Turn the (optional) backlight off/on
void LiquidCrystal_I2C::noBacklight(void) {
  _backlightval = LCD_NOBACKLIGHT;
  expanderWrite(0);
}

void LiquidCrystal_I2C::backlight(void) {
  _backlightval = LCD_BACKLIGHT;
  expanderWrite(0);
}

/*********** mid level commands, for sending data/cmds */

inline void LiquidCrystal_I2C::command(uint8_t value) {
  send(value, 0);
}

inline size_t LiquidCrystal_I2C::write(uint8_t value) {
  send(value, Rs);
  return 1;
}

/************ low level data pushing commands **********/

// Write either command or data
void LiquidCrystal_I2C::send(uint8_t value, uint8_t mode) {
  uint8_t highnib = value & 0xf0;
  uint8_t lownib = (value << 4) & 0xf0;
  write4bits((highnib) | mode);
  write4bits((lownib) | mode);
}

void LiquidCrystal_I2C::write4bits(uint8_t value) {
  expanderWrite(value);
  pulseEnable(value);
}

void LiquidCrystal_I2C::expanderWrite(uint8_t _data) {
  TinyWireM.beginTransmission(_addr);
  TinyWireM.send(((int)(_data) | _backlightval));
  TinyWireM.endTransmission();
}

void LiquidCrystal_I2C::pulseEnable(uint8_t _data) {
  expanderWrite(_data | En);	// En high
  delayMicroseconds(1);		    // Enable pulse must be >450ns

  expanderWrite(_data & ~En);	// En low
  delayMicroseconds(50);		  // Commands need > 37us to settle
}

void LiquidCrystal_I2C::load_custom_character(uint8_t char_num, uint8_t *rows) {
  createChar(char_num, rows);
}

void LiquidCrystal_I2C::setBacklight(uint8_t new_val) {
  if (new_val) {
    backlight();		          // Turn backlight on
  } else {
    noBacklight();		        // Turn backlight off
  }
}

void LiquidCrystal_I2C::printstr(const char c[]) {
  // This function is not identical to the function used for "real" I2C displays
  // It's here so the user sketch doesn't have to be changed
  print(c);
}

// Unsupported API functions
void LiquidCrystal_I2C::off() {}
void LiquidCrystal_I2C::on() {}
void LiquidCrystal_I2C::setDelay (int cmdDelay, int charDelay) {}
uint8_t LiquidCrystal_I2C::status() {
  return 0;
}
uint8_t LiquidCrystal_I2C::keypad () {
  return 0;
}
uint8_t LiquidCrystal_I2C::init_bargraph(uint8_t graphtype) {
  return 0;
}
void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end) {}
void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_row_end) {}
void LiquidCrystal_I2C::setContrast(uint8_t new_val) {}


LiquidCrystal_I2C.cpp

/*
  LiquidCrystal_I2C for ATtiny85
  Author: Frank de Brabander
  Version: 1.1.2 modified for ATtiny85
*/
#ifndef LiquidCrystal_I2C_h
#define LiquidCrystal_I2C_h

#include <TinyWireM.h> // Include this if ATtiny85

// Commands
#define LCD_CLEARDISPLAY 0x01
#define LCD_RETURNHOME 0x02
#define LCD_ENTRYMODESET 0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT 0x10
#define LCD_FUNCTIONSET 0x20
#define LCD_SETCGRAMADDR 0x40
#define LCD_SETDDRAMADDR 0x80

// Flags for display entry mode
#define LCD_ENTRYRIGHT 0x00
#define LCD_ENTRYLEFT 0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00

// Flags for display on/off control
#define LCD_DISPLAYON 0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON 0x02
#define LCD_CURSOROFF 0x00
#define LCD_BLINKON 0x01
#define LCD_BLINKOFF 0x00

// Flags for display/cursor shift
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE 0x00
#define LCD_MOVERIGHT 0x04
#define LCD_MOVELEFT 0x00

// Flags for function set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00

// Flags for backlight control
#define LCD_BACKLIGHT 0x08
#define LCD_NOBACKLIGHT 0x00

#define En B00000100  // Enable bit
#define Rw B00000010  // Read/Write bit
#define Rs B00000001  // Register select bit

/**
   This is the driver for the Liquid Crystal LCD displays that use the I2C bus.

   After creating an instance of this class, first call begin() before anything else.
   The backlight is on by default, since that is the most likely operating mode in
   most cases.
*/
class LiquidCrystal_I2C : public Print {
  public:
    /**
       Constructor

       @param lcd_addr	I2C slave address of the LCD display. Most likely printed on the
     					LCD circuit board, or look in the supplied LCD documentation.
       @param lcd_cols	Number of columns your LCD display has.
       @param lcd_rows	Number of rows your LCD display has.
       @param charsize	The size in dots that the display has, use LCD_5x10DOTS or LCD_5x8DOTS.
    */
    LiquidCrystal_I2C(uint8_t lcd_addr, uint8_t lcd_cols, uint8_t lcd_rows, uint8_t charsize = LCD_5x8DOTS);

    // LiquidCrystal_I2C(uint8_t lcd_Addr, uint8_t lcd_cols, uint8_t lcd_rows);
    void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS );
    /**
       Set the LCD display in the correct begin state, must be called before anything else is done.
    */
    void begin();

    /**
       Remove all the characters currently shown. Next print/write operation will start
       from the first position on LCD display.
    */
    void clear();

    /**
       Next print/write operation will will start from the first position on the LCD display.
    */
    void home();

    /**
       Do not show any characters on the LCD display. Backlight state will remain unchanged.
       Also all characters written on the display will return, when the display in enabled again.
    */
    void noDisplay();

    /**
       Show the characters on the LCD display, this is the normal behaviour. This method should
       only be used after noDisplay() has been used.
    */
    void display();

    /**
       Do not blink the cursor indicator.
    */
    void noBlink();

    /**
       Start blinking the cursor indicator.
    */
    void blink();

    /**
       Do not show a cursor indicator.
    */
    void noCursor();

    /**
       Show a cursor indicator, cursor can blink on not blink. Use the
       methods blink() and noBlink() for changing cursor blink.
    */
    void cursor();
    void scrollDisplayLeft();
    void scrollDisplayRight();
    void printLeft();
    void printRight();
    void leftToRight();
    void rightToLeft();
    void shiftIncrement();
    void shiftDecrement();
    void noBacklight();
    void backlight();
    void autoscroll();
    void noAutoscroll();
    void createChar(uint8_t, uint8_t[]);
    void setCursor(uint8_t, uint8_t);
    virtual size_t write(uint8_t);
    void command(uint8_t);
    void init();

    inline void blink_on() {
      blink();
    }
    inline void blink_off() {
      noBlink();
    }
    inline void cursor_on() {
      cursor();
    }
    inline void cursor_off() {
      noCursor();
    }

    // Compatibility API function aliases
    void setBacklight(uint8_t new_val);				// alias for backlight() and nobacklight()
    void load_custom_character(uint8_t char_num, uint8_t *rows);	// alias for createChar()
    void printstr(const char[]);

    // Unsupported API functions (not implemented in this library)
    uint8_t status();
    void setContrast(uint8_t new_val);
    uint8_t keypad();
    void setDelay(int, int);
    void on();
    void off();
    uint8_t init_bargraph(uint8_t graphtype);
    void draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end);
    void draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end);

  private:
    void init_priv();
    void send(uint8_t, uint8_t);
    void write4bits(uint8_t);
    void expanderWrite(uint8_t);
    void pulseEnable(uint8_t);
    uint8_t _addr;
    uint8_t _displayfunction;
    uint8_t _displaycontrol;
    uint8_t _displaymode;
    uint8_t _cols;
    uint8_t _rows;
    uint8_t _charsize;
    uint8_t _backlightval;
};

#endif


LiquidCrystal_I2C.h

Servo8Bit.cpp

/*
  Servo8Bit.cpp - Interrupt driven Servo library for the Attiny85 that uses an 8 bit timer.
  Version 0.7.1
  Copyright (c) 2011 Ilya Brutman.  All right reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

  A servo is activated by creating an instance of the Servo8Bit class passing the
  desired pin to the attach() method.
  The servos are pulsed in the background using the value most recently written using
  the write() method

  The methods are:

   Servo8Bit - Class for manipulating servo motors connected to Attiny pins.

   attach(pin)           - Attaches a servo motor to an i/o pin.
   attach(pin, min, max) - Attaches to a pin setting min and max values in microseconds
                           default min is 544, max is 2400

   write()               - Sets the servo angle in degrees.  (invalid angle that is valid as pulse in microseconds is treated as microseconds)
   writeMicroseconds()   - Sets the servo pulse width in microseconds
   read()                - Gets the last written servo pulse width as an angle between 0 and 180.
   readMicroseconds()    - Gets the last written servo pulse width in microseconds.
   attached()            - Returns true if there is a servo attached.
   detach()              - Stops an attached servos from pulsing its i/o pin.
   delayMicroseconds()   - Microseconds delay for the 16 MHz clock on most Arduino boards.
   delay()               - M illiseconds delay for the 16 MHz clock on most Arduino boards.
*/

#ifndef Servo8Bit_h
#define Servo8Bit_h

#include <inttypes.h>

// Options
#define USE_TIMER0
// #define USE_TIMER1

class Servo8Bit {
  public:
    Servo8Bit();
    ~Servo8Bit();
    uint8_t attach(uint8_t pin);                                   // Attach the given pin to the next free channel, returns channel number or 0 if failure
    uint8_t attach(uint8_t pin, uint16_t newMin, uint16_t newMax); // as above but also sets min and max values for writes.
    void detach();

    void write(uint16_t value);             // If value is < 200 its treated as an angle, otherwise as pulse width in microseconds
    void writeMicroseconds(uint16_t value); // Write pulse width in microseconds
    uint16_t read();                        // Returns current pulse width as an angle between 0 and 180 degrees
    uint16_t readMicroseconds();            // Returns current pulse width in microseconds for this servo
    bool attached();                        // Return true if this servo is attached, otherwise false

    // Our own delay function, so that we don't have to get it from some library
    void delay(uint16_t ms);
    void delayMicroseconds(uint16_t us);

  private:
    // Private constants
    static const uint16_t kDefaultMinimalPulse = 544;
    static const uint16_t kDefaultMaximumPulse = 2400;

    // Private variables
    uint8_t myServoNumber;      // Our ID number that we get from the ServoSequencer after we register with it
    uint8_t invalidServoNumber; // Value that represents and invalid servo number. This is set only once.
    uint16_t myMin;             // Minimum pulse length that corresponds to the angle of 0 degrees
    uint16_t myMax;             // Maximum pulse length that corresponds to the angle of 180 degrees

    // Our own map function, so that we don't have to get it from some library
    long map(long x, long in_min, long in_max, long out_min, long out_max);
};

#endif


Servo8Bit.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

TinyWireM