Å koble til en LCD på Arduino er forholdsvis enkelt. Man trenger kun LCD, brødbrett, testledninger, potensiometer, resistor, loddebolt, loddetinn og Arduino-brett med mikrokontroller.

Kretsen

Det første man bør gjøre er å lodde fast ei pinnerekke under LCD-kretskortet, for å få best mulig kontakt når displayet er tilkoblet:

Lar man være å gjøre dette, vil ikke skjermen virke. Det vil kun dukke opp firkantede svarte bokser, fordi noen pinner har for dårlig tilkobling.

Etterpå følger man så prosjektet «Liquid Crystal Displays (LCD) with Arduino» og får ca noe som ligner på følgende oppsett:

Alle disse koblingene kan virke komplekse og uoversiktlige, men det er de ikke. De gule ledningene er for data, de røde er for 5V og svart er minus/jord. Blå blir et slags unntak, da den er ingen av delene; den gir finjustert spenning inn på LCD for å regulere skjermkontrast. Høres kanskje innviklet ut, men det er det ikke.

Arduino-kode

For å vise tekst på displayet velges et av kodeeksemplene på prosjektnettsiden:

#include <LiquidCrystal.h>

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {
   lcd.begin(16, 2);
   lcd.print("Hello, world!");
}

void loop() {
   lcd.setCursor(0, 1);
   lcd.print(millis() / 1000);
}

Denne kodesnutten og de andre virker greit. Displayet viser tekst. Case closed.

Embedded C

Den reelle utfordringen er å skrive en fungerende løsning i Embedded C, så man kan tweake og gjøre med koden som man vil …

Pinner

Først trengs en oversikt over hvilke porter og pinner som er brukt. Med info fra prosjektnettsiden over og kart for hvilke Arduino-pinner som er koblet til hvilke ATmega328P-pinner, får man følgende oversikt:

LCD-pinne        Arduino-pinne          ATmega328P-pinne
--------------------------------------------------------
LCD RS           digital pin 12         PB4
LCD Enable (E)   digital pin 11         PB3

LCD D4           digital pin 5 	        PD5
LCD D5           digital pin 4	        PD4
LCD D6           digital pin 3	        PD3
LCD D7           digital pin 2	        PD2

De andre pinnene forandres ikke, de kan stå der de står. Heller ikke potensiometeret trenger å kobles om.

Kode

Jeg var (u)heldig og fant noe gammel kode som ordner LCD i C. I hvertfall mer eller mindre. Dermed slipper jeg å skrive alt fra scratch. Noe som sannsynligvis ville tatt flere uker.

Men en ting jeg ikke likte i denne koden var at porter og pinner var hardkodet med #define. Derfor måtte man ha oppdatert disse opplysningene hver gang noe var feil.

Dette valgte jeg å gjøre om, så all informasjon om porter og pinner mates fra main() eller der LCD-en styres fra. Dette gjøres via en struct. Da blir alt på en plass, dette er ryddigere. Syns i hvertfall jeg.

main.cpp

#define F_CPU 16000000UL

#include <avr/io.h>
#include <util/delay.h>

#include "LCD.hpp"

int main(void)
{
   // ---------------
   // Setup:

   /*
      LCD pin         Arduino pin        ATmega328P pin
      -------------------------------------------------
      LCD RS          digital pin 12     PB4
      LCD Enable (E)  digital pin 11     PB3

      LCD D4          digital pin 5      PD5
      LCD D5          digital pin 4      PD4
      LCD D6          digital pin 3      PD3
      LCD D7          digital pin 2      PD2
   */

   struct PortsAndPinsSetupLCD setup;

   // Ports
   setup.RS_PORT = &PORTB;
   setup.E_PORT = &PORTB;
   setup.D7_PORT = &PORTD;
   setup.D6_PORT = &PORTD;
   setup.D5_PORT = &PORTD;
   setup.D4_PORT = &PORTD;

   // Pins
   setup.RS_PIN = PB4;
   setup.E_PIN = PB3;
   setup.D7_PIN = PD2;
   setup.D6_PIN = PD3;
   setup.D5_PIN = PD4;
   setup.D4_PIN = PD5;

   // Data direction
   DDRB |= (1<<setup.RS_PIN);
   DDRB |= (1<<setup.E_PIN);
   DDRD |= (1<<setup.D7_PIN);
   DDRD |= (1<<setup.D6_PIN);
   DDRD |= (1<<setup.D5_PIN);
   DDRD |= (1<<setup.D4_PIN);


   // ---------------
   // Text:

   uint8_t text1[] = "LCD-display for";
   uint8_t text2[] = "AVR, programmert";
   uint8_t text3[] = "i Embedded C og";
   uint8_t text4[] = "virker dritbra!!";


   // ---------------
   // Testing:

   // Write
   lcd_init_4p(setup);

   while (1) {

      lcd_clear(setup);
      lcd_goto_line(0, setup);
      lcd_goto_line(0, setup);
      lcd_write_string_4p(text1, setup);
      lcd_goto_line(1, setup);
      lcd_write_string_4p(text2, setup);
      _delay_ms(3000);

      lcd_clear(setup);
      lcd_goto_line(0, setup);
      lcd_goto_line(0, setup);
      lcd_write_string_4p(text3, setup);
      lcd_goto_line(1, setup);
      lcd_write_string_4p(text4, setup);
      _delay_ms(3000);
   }
}

LCD.hpp

#ifndef LCD_HPP_
#define LCD_HPP_

#include <avr/io.h>
#include <util/delay.h>

/*
   First author:  Donald Weiman
   Date:          September 16, 2013
   Summary:       4-bit data interface, busy flag not implemented.

   Second author: Ove Bakken
   Date:          March 20, 2023
   Summary:       Slightly modified implementation.
                  Every functions is fed the necessary ports and pins.
                  Does not rely upon hardcoded #defines that needs changing.
*/

// Config
struct PortsAndPinsSetupLCD {

   // Ports
   volatile uint8_t *RS_PORT;
   volatile uint8_t *E_PORT;
   volatile uint8_t *D7_PORT;
   volatile uint8_t *D6_PORT;
   volatile uint8_t *D5_PORT;
   volatile uint8_t *D4_PORT;

   // Pins
   volatile uint8_t RS_PIN;
   volatile uint8_t E_PIN;
   volatile uint8_t D7_PIN;
   volatile uint8_t D6_PIN;
   volatile uint8_t D5_PIN;
   volatile uint8_t D4_PIN;
};

// Screen locations
#define START_LOCATION_LINE_1     0x00           // start of line 1
#define START_LOCATION_LINE_2     0x40           // start of line 2

// Screen instructions
#define INSTRUCTION_SET_4BIT      0b00101000     // 4-bit data, 2-line display, 5 x 7 font
#define INSTRUCTION_ON            0b00001100     // display on, cursor off, don't blink character
#define INSTRUCTION_OFF           0b00001000     // turn display off
#define INSTRUCTION_RESET         0b00110000     // reset the LCD
#define INSTRUCTION_CLEAR         0b00000001     // replace all characters with ASCII 'space'
#define INSTRUCTION_ENTRY_MODE    0b00000110     // shift cursor from left to right on read/write
#define INSTRUCTION_SET_CURSOR    0b10000000     // set cursor position
#define INSTRUCTION_RESET_CURSOR  0b00000010     // return cursor to first position on first line

// Function prototypes
void lcd_init_4p(PortsAndPinsSetupLCD);
void lcd_write_4p(uint8_t, PortsAndPinsSetupLCD);
void lcd_write_instruction_4p(uint8_t, PortsAndPinsSetupLCD);
void lcd_write_character_4p(uint8_t, PortsAndPinsSetupLCD);
void lcd_write_string_4p(uint8_t *, PortsAndPinsSetupLCD);
void lcd_clear(PortsAndPinsSetupLCD);
void lcd_goto_line(int, PortsAndPinsSetupLCD);

#endif /* LCD_HPP_ */

LCD.cpp

#include "LCD.hpp"

void lcd_init_4p(PortsAndPinsSetupLCD setup)
{
   // Power-up delay
   _delay_ms(100);

   // IMPORTANT - At this point the LCD module is in the 8-bit mode and it is expecting to receive
   //   8 bits of data, one bit on each of its 8 data lines, each time the 'E' line is pulsed.
   //
   // Since the LCD module is wired for the 4-bit mode, only the upper four data lines are connected to
   //   the microprocessor and the lower four data lines are typically left open.  Therefore, when
   //   the 'E' line is pulsed, the LCD controller will read whatever data has been set up on the upper
   //   four data lines and the lower four data lines will be high (due to internal pull-up circuitry).
   //
   // Fortunately the 'FunctionReset' instruction does not care about what is on the lower four bits so
   //   this instruction can be sent on just the four available data lines and it will be interpreted
   //   properly by the LCD controller.  The 'lcd_write_4p' subroutine will accomplish this if the
   //   control lines have previously been configured properly.

   *setup.RS_PORT &= ~(1<<setup.RS_PIN);         // select the Instruction Register (RS low)
   *setup.E_PORT &= ~(1<<setup.E_PIN);         // make sure E is initially low

   // Reset the LCD controller
   lcd_write_4p(INSTRUCTION_RESET, setup);        // first part of reset sequence
   _delay_ms(10);

   lcd_write_4p(INSTRUCTION_RESET, setup);        // second part of reset sequence
   _delay_us(200);

   lcd_write_4p(INSTRUCTION_RESET, setup);        // third part of reset sequence
   _delay_us(200);                         // this delay is omitted in the data sheet

   // Preliminary Function Set instruction - used only to set the 4-bit mode.
   // The number of lines or the font cannot be set at this time since the controller is still in the
   //  8-bit mode, but the data transfer mode can be changed since this parameter is determined by one
   //  of the upper four bits of the instruction.

   lcd_write_4p(INSTRUCTION_SET_4BIT, setup);      // set 4-bit mode
   _delay_us(80);

   lcd_write_instruction_4p(INSTRUCTION_SET_4BIT, setup);       // set mode, lines, and font
   _delay_us(80);

   // The next three instructions are specified in the data sheet as part of the initialization routine,
   //  so it is a good idea (but probably not necessary) to do them just as specified and then redo them
   //  later if the application requires a different configuration.

   lcd_write_instruction_4p(INSTRUCTION_OFF, setup);         // turn display OFF
   _delay_us(80);

   lcd_write_instruction_4p(INSTRUCTION_CLEAR, setup);         // clear display RAM
   _delay_ms(4);

   lcd_write_instruction_4p(INSTRUCTION_ENTRY_MODE, setup);   // set desired shift characteristics
   _delay_us(80);

   // This is the end of the LCD controller initialization as specified in the data sheet, but the display
   //  has been left in the OFF condition.  This is a good time to turn the display back ON.

   lcd_write_instruction_4p(INSTRUCTION_ON, setup);         // turn the display ON
   _delay_us(80);
}

void lcd_write_string_4p(uint8_t textString[], PortsAndPinsSetupLCD setup)
{
   volatile int i = 0;                                 // character counter*/
   while (textString[i] != 0)
   {
      lcd_write_character_4p(textString[i], setup);
      i++;

      _delay_us(80);
   }
}

void lcd_write_character_4p(uint8_t data, PortsAndPinsSetupLCD setup)
{
   *setup.RS_PORT |= (1<<setup.RS_PIN);               // select the Data Register (RS high)
   *setup.E_PORT &= ~(1<<setup.E_PIN);               // make sure E is initially low

   lcd_write_4p(data, setup);                        // write the upper 4-bits of the data
   lcd_write_4p(data << 4, setup);                     // write the lower 4-bits of the data

   _delay_us(80);
}

void lcd_goto_line(int num, PortsAndPinsSetupLCD setup)                        // 0 or 1
{
   lcd_write_instruction_4p(
      INSTRUCTION_SET_CURSOR | (num == 0 ? START_LOCATION_LINE_1 : START_LOCATION_LINE_2),
      setup
   );

   _delay_us(80);
}

void lcd_clear(PortsAndPinsSetupLCD setup)
{
   lcd_write_instruction_4p(INSTRUCTION_CLEAR, setup);         // clear display RAM
   _delay_ms(4);

   lcd_write_instruction_4p(INSTRUCTION_ENTRY_MODE, setup);   // set desired shift characteristics
   _delay_us(80);
}

void lcd_write_instruction_4p(uint8_t instruction, PortsAndPinsSetupLCD setup)
{
   *setup.RS_PORT &= ~(1<<setup.RS_PIN);               // select the Instruction Register (RS low)
   *setup.E_PORT &= ~(1<<setup.E_PIN);                  // make sure E is initially low

   lcd_write_4p(instruction, setup);                  // write the upper 4-bits of the data
   lcd_write_4p(instruction << 4, setup);               // write the lower 4-bits of the data

   _delay_us(80);
}

void lcd_write_4p(uint8_t byteData, PortsAndPinsSetupLCD setup)
{
   *setup.D7_PORT &= ~(1<<setup.D7_PIN);                  // assume that data is '0'
   if (byteData & 1<<7) *setup.D7_PORT |= (1<<setup.D7_PIN);   // make data = '1' if necessary

   *setup.D6_PORT &= ~(1<<setup.D6_PIN);                  // repeat for each data bit
   if (byteData & 1<<6) *setup.D6_PORT |= (1<<setup.D6_PIN);

   *setup.D5_PORT &= ~(1<<setup.D5_PIN);
   if (byteData & 1<<5) *setup.D5_PORT |= (1<<setup.D5_PIN);

   *setup.D4_PORT &= ~(1<<setup.D4_PIN);
   if (byteData & 1<<4) *setup.D4_PORT |= (1<<setup.D4_PIN);

   // write the data                                 // 'Address set-up time' (40 nS)
   *setup.E_PORT |= (1<<setup.E_PIN);                     // Enable pin high
   _delay_us(1);                                      // implement 'Data set-up time' (80 nS) and 'Enable pulse width' (230 nS)
   *setup.E_PORT &= ~(1<<setup.E_PIN);                    // Enable pin low
   _delay_us(1);                                      // implement 'Data hold time' (10 nS) and 'Enable cycle time' (500 nS)
}

Resultat

Jeg er veldig fornøyd med hvordan dette ble:

Krets, display og kode fungerer fin-fint. Så når jeg en gang i fremtiden trenger LCD i et mer reelt prosjekt er det lett å ordne dette.

TBC

Etter å ha prokrastinert altfor lenge, var det idag endelig på tide å komme i gang med Embedded C for ATmega328p. Dette er valgt databrikke på Arduino UNO og derfor et trygt valg når man skal lære seg mikrokontrollerprogrammering.

ATmega328p er del av AVR-familien av mikrokontrollere som Atmel (kjøpt opp av Microchip i 2016) begynte å utvikle i 1996. Hvem som helst kan skaffe seg den. Enten ved å kjøpe løst eller i stedet skaffe seg f.eks. Arduino-startpakke. Jeg valgte Arduino-startpakke siden jeg også trengte brødbrett, testledninger, enkle komponenter, osv.

Arduino-brettet med mikrokontroller er enkelt å programmere via Arduino IDE. Dette er et neddummet programmeringsverktøy som gjør programmeringen lett. Og siden det finnes mange dokumenterte Arduino-prosjekter, med ulike vanskelighetsgrader, kan hvem som helst prøve seg. Derfor er det også et smart valg når man skal lære seg mikrokontrollerprogrammering.

Den reelle utfordringen blir å skrive ren embedded C-kode som kan erstatte jallakode skrevet i Arduino IDE. Dette krever forståelse av C, registermanipulering, osv.

Første prosjekt: Lysdiode + bryter

Som første prosjekt valgte jeg å kombinere Arduino-prosjektene Blink og How to Wire and Program a Button. Forklaringen er åpenbar; å kontrollere innsignal og utsignal på mikrokontrolleren er første viktige skritt.

Pinnene PB0 og PB1 (markert med rød understreking) er de jeg valgte å bruke. Jeg kunne også brukt mange av de andre, så lenge de støtter ønsket funksjonalitet.

Her må man lese databladet for å være sikker ….

Kretsen

Først måtte bryter og lysdiode kobles riktig på brødbrettet (easy peasy):

Når bryter ikke er innkoblet skal innsignalet (via hvit ledning) være lavt, dvs. 0V. Når bryteres trykkes ned, vil derimot signalet endre seg til 5V.

Utsignalet (rød ledning) er også 5V, men dette er for høyt for vanlige lysdioder, derav resistoren. Etter spenningsfallet over resistoren, blir gjenværende spenning over lysdioden mer passe.

Dette er samme konfigurasjon som i Arduino-prosjektene lenket til over. Forskjellen er at pinne 8 og 9 ble brukt i stedet.

Arduino-kode

Deretter gjenstod det kun litt enkel kodeskriving i Arduino IDE:

const int PIN_FOR_BUTTON = 8;
const int PIN_FOR_LED = 9;
const int LONG_DELAY = 5000;
const int SHORT_DELAY = 10;

void setup() {
   pinMode(PIN_FOR_BUTTON, INPUT);
   pinMode(PIN_FOR_LED, OUTPUT);
}

void loop() {
   if (digitalRead(PIN_FOR_BUTTON) == HIGH) {
      digitalWrite(PIN_FOR_LED, HIGH);
      delay(LONG_DELAY);
   } else {
      digitalWrite(PIN_FOR_LED, LOW);
      delay(SHORT_DELAY);
   }
}

Valgte pinner deklareres øverst, sammen med ventetidene. I setup() settes inn- og utmodus. Og i loop() sjekker man innsignalet og agerer når dette endres. Ganske selvforklarende.

Testing

Etter programmet var ferdig og lastet opp, ble det testet. Og det fungerte fint.

Ved å trykke på knappen tennes dioda. Også slukkes den 5 sekunder (5000 ms) etter knappen ble sluppet igjen:

Lyset kan virke skarpt, men resistoren var på , slik som i det lenkede Arduino-prosjektet. Neste gang vil jeg muligens øke resistansen enda mer.

Embedded C

Kodeskrivingen over kan knapt kalles utfordrende, da den ferdige koden virket omtrent på første forsøk. Embedded C ble derimot litt mer krevende. Først og fremst pga. registermanipuleringen som tar litt tid å bli vant til.

Men etter litt knoting, lesing og testing ble det en løsning:

#undef F_CPU
#define F_CPU 16000000 // CPU frequency to be considered by the delay macros

#include <avr/io.h>
#include <util/delay.h>

int main (void)
{
   /*
      ATmega328P on Arduino board
      1x switch on pin 0 on port B
      1x LED on pin 1 on port B
   */

   // Data direction register for port B, input = 0 and output = 1
   DDRB &= ~(1<<PB0); // Set pin 0 to input on port B
   DDRB |= 1<<PB1; // Set pin 1 to output on port B

   // Delay in ms
   const int LONG_DELAY = 5000;
   const int SHORT_DELAY = 10;

   while (1) {

      // Button down (active) = high
      if (PINB & 1<<PB0) { // If pin 0 set high on port B
         PORTB |= 1<<PB1; // Set pin 1 to high on port B
         _delay_ms(LONG_DELAY);

      // Button up (inactive) = low
      } else {
         PORTB &= ~(1<<PB1); // Set pin 1 to low on port B
         _delay_ms(SHORT_DELAY);
      }
   }
}

Her brukes makroer (DDRB, PB0, osv.), dette forenkler arbeidet og gjør koden lesbar.

Samme kode ville riktignok også fungert i Arduino IDE, men å bli vant til å kun bruke denne IDE-en er ikke særlig smart. Den er altfor simpel. Det er sunt å fikle med andre IDE-er, sette opp avrdude manuelt, osv. for å bli mest mulig stødig.

Min valgte IDE for Embedded C er inntil videre Eclipse Classic 3.7.0, med AVR-plugin installert. Dette er da på Linux-distro Zorin OS. For å laste opp til mikrokontrolleren benyttes avrdude, men dette gjøres sømløst fra Eclipse. Det er ikke knoting i terminal.

Tanken var å gå over til MPLAB X IDE fra Microchip, men førsteinntrykket skuffet.