Alfanumerisk LCD med I²C-anslutning

Alfanumeriska LCD-displayer är väldigt populära för att visa status och meddelande från Arduinos och andra mikrokontroller. Eftersom de är populära så finns det väldigt bra kodbibliotek tillgänliga och många kodexempel på hur dessa används. Om man kombinerar en sådan här display med en I²C-modul så har man en oslagbar kombination som är enkel att koppla in och använder minimalt med anslutningar på din mikrokontroller.

Här följer vårt enkla test-program för Arduino som visar hur man kan använda just en sådan här LCD kombinerad med I2C-modul:

#include <LiquidCrystal_I2C.h>
#include <string.h>

// Adressen är 0x27, 16 tecken och två rader
LiquidCrystal_I2C lcd(0x27, 16, 2);

char *txt = "Allt f\xEFr din robot-hobby!";  // åäö ligger på udda ställe i teckentabellen
unsigned char pos = 0;
unsigned char txtlen;

void setup() {
  txtlen = strlen(txt);
  lcd.init(); // start the library
  lcd.clear();
  lcd.home();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("ByggaRobot.se");
}

void loop() {
  lcd.setCursor(0, 1);
  lcd.print(txt + pos);
  if (pos > (txtlen - 15)) {
    lcd.setCursor(txtlen - pos + 1, 1);
    lcd.print(txt);
  }
  pos++;
  if (pos > txtlen) {
    pos = 0;
  }
  delay(500);
}

Här är en film som visar resultatet av koden när den körs:

LED Matris-modul 8x8

Tack vara det kraftfulla drivchippet MAX7219 så kan varje lysdiod i den här modulen styras individuellt och ljusstyrkan kan  ställas in för alla lysdioder i 16 steg. Det finns ett färdigt kodbibliotek tillgängligt för nerladdning direkt i Arduinos kod-editor vilket gör det mycket enkelt att skriva program för att styra modulen. Här nedan följer ett enkelt kodexempel för Arduino som visar texten "BYGGAROBOT.SE" bokstav för bokstav.

#include <avr/pgmspace.h>
#include <LedControl.h>

// Visa varje bildruta i 500ms
#define FRAME_TIME 500

LedControl ledmatrix = LedControl(2, 3, 4, 1); // Data = pin 2, Clock = pin 3, Load = pin 4, Bara en LED-modul är inkopplad

// Definiera alla bildrutor.
// De lagras direkt i programminnet för att spara utrymme i dataminnet.
const char frames[][8] PROGMEM = {
  {
    B11111100,
    B11000110,
    B11000110,
    B11111000,
    B11000110,
    B11000011,
    B11000011,
    B11111100
  },
  {
    B11000011,
    B11000011,
    B01100110,
    B00111100,
    B00011000,
    B00011000,
    B00011000,
    B00011000
  },
  {
    B00111100,
    B01100110,
    B11000000,
    B11000000,
    B11001111,
    B11000011,
    B01100110,
    B00111000
  },
  {
    B00111100,
    B01100110,
    B11000000,
    B11000000,
    B11001111,
    B11000011,
    B01100110,
    B00111000
  },
  {
    B00011000,
    B00111100,
    B01100110,
    B11000011,
    B11111111,
    B11000011,
    B11000011,
    B11000011
  },
  {
    B11111100,
    B11000110,
    B11000110,
    B11111000,
    B11001100,
    B11000110,
    B11000011,
    B11000011
  },
  {
    B00111100,
    B01100110,
    B11000011,
    B11000011,
    B11000011,
    B11000011,
    B01100110,
    B00111000
  },
  {
    B11111100,
    B11000110,
    B11000110,
    B11111000,
    B11000110,
    B11000011,
    B11000011,
    B11111100
  },
  {
    B00111100,
    B01100110,
    B11000011,
    B11000011,
    B11000011,
    B11000011,
    B01100110,
    B00111000
  },
  {
    B11111111,
    B00011000,
    B00011000,
    B00011000,
    B00011000,
    B00011000,
    B00011000,
    B00011000
  },
  {
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00011000,
    B00011000
  },
  {
    B01111110,
    B11000011,
    B11000000,
    B01111100,
    B00000110,
    B00000011,
    B11000011,
    B01111110
  },
  {
    B11111110,
    B11000000,
    B11000000,
    B11111000,
    B11000000,
    B11000000,
    B11000000,
    B11111111
  },
  {
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000
  }
};


void setup() {
  ledmatrix.shutdown(0, false);
  ledmatrix.setIntensity(0, 8);
  ledmatrix.clearDisplay(0);
}

void loop() {
  for (int i = 0; i < sizeof(frames) / sizeof(frames[0]); i++) {
    set_matrix(0, frames[i]);
    delay(FRAME_TIME);
  }
}

void set_matrix(int addr, const char *image) {
  for (int row = 0; row < 8; row++) {
    ledmatrix.setRow(addr, row, image[row]);
  }
}

Här är en film som visar resultatet av koden:

LED display-modul, 8 siffror och 8 knappar

Den flexibla display-modulen baserad på TM1638 är mycket enkel att använda tillsammans med Arduino tack vara det färdiga kodbiblioteket som finns tillgängligt för nerladdning.

Koden

#include <TM1638>

#define FRAME_TIME 500

TM1638 ledkey(2,3,4);  // Data = pin 2, Clock = pin 3, Load = pin 4
char *str = "        BYGGAROBOT.SE         ";

void setup() {
}

void loop() {
  byte leds = 0x0F;
  for (char *ptr = str; ptr < str + strlen(str) - 8; ptr++) {
    ledkey.setDisplayToString(ptr);
    for (int i = 0; i < 8; i++) {
      ledkey.setLEDs(~(0xFF >> i));
      delay(FRAME_TIME / 8);
    }
  }
}

Här är en film som visar resultatet när koden körs:

Ultraljudssensorer

Ultraljudssensorer används för att känna av hinder och mäta avstånd. De fungerar genom att skicka ut en kort ljudpuls (ej hörbar för människor) och om ljudet träffar en vägg eller annat hårt objekt så reflekteras det tillbaka som ett eko. Sensorn tar emot ekot och avståndet till objektet kan sedan räknas ut genom att mäta tiden från att man skickade pulsen till att man får tillbaka ekot. Detta gör man genom följande formel:

d = vljud × t / 2

Där d är avståndet till objektet, vljud är ljudets hastighet i luft vilket är cirka 340 m/s och t är tiden mellan pulsen och ekot.

Exempel: du skickar ut en puls och sensorn signalerar att den fått tillbaka ett eko efter 0,014 sekunder. Detta betyder att avståndet till objektet som gav ekot är:

d = 340 × 0.014 / 2 = 2,38 meter

Som du ser så handlar det om väldigt korta tider, men en mikrokontroller är, som tur är, väldigt bra på att mäta korta tider.

Nedan följer ett kodexempel för Arduino som använder en ultraljudssensor kopplad till pinnarna 2 och 3 och skriver ut avståndet till närmaste detekterade objekt på seriaporten. Ladda upp sketchen till Arduino-kortet och starta sedan "serial monitor" med kommunikationshastighet 9600 baud för att se resultatet.

Koden

const int usTriggerPin = 2;
const int usEchoPin = 3;

void setup() {
  pinMode(usTriggerPin, OUTPUT);
  pinMode(usEchoPin, INPUT);
  Serial.begin(9600);
}

void loop() {
  long t;
  int dist;
  // Skicka ut en 10us lång puls
  digitalWrite(usTriggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(usTriggerPin, LOW);
  // Vänta på att ljudet passerat mottagaren innan vi börjar mäta
  delayMicroseconds(400);
  // Vänta på eko i högst 24ms (24000us) vilket motsvarar
  // ett detekteringsavstånd på drygt 4 meter.
  t = pulseIn(usEchoPin, HIGH, 24000);
  Serial.print("Avstånd: ");
  if (t == 0) {
    // inget eko
    Serial.println("---");
  }
  else {
    // Lägg till de första 400us
    t += 400;
    // Totala avståndet fram och tillbaka är tiden gånger ljudets hastighet.
    // Avståndet till hindret är således hälften.
    // Dividera med 1000 för att få mm istället för m.
    // L efter konstanterna garanterar att long (32 bitar) används i beräkningen.
    dist = (int)(t * 340L / 1000L / 2L);
    Serial.print(dist);
    Serial.println("mm");
  }
  delay(500);
}

Lysdioder

En lysdiod fungerar ungefär som en lampa, men till skillnad från en lampa som lyser starkare ju högre spänning den får så beror en lysdiods ljusstyrka på strömmen istället. Man kan alltså inte bara koppla in en lysdiod direkt till ett batteri eller strömadapter för då kommer den sannolikt gå sönder. Man måste begränsa dess ström genom ett motstånd. Exakt värde på motståndet beror på spänning, lysdiodtyp och vilken ljusstyrka man önskar, men för vanliga lysdioder som kopplas till 5 volt är 220 ohm ett bra riktvärde.

Exakt vilket motståndsvärde man ska använda kan man få från följande formel:

R = (VCC - VLED) / ILED

Där R är motståndet, VCC spänningen som dioden ska kopplas till, VLED är diodens spänningsfall och ILED är önskad ström genom dioden. De flesta lysdioder klarar en maximal ström på 20 mA och lyser då som absolute starkast, men moderna lysdioder är väldigt effektiva och klarar sig med långt mindre ström, ofta under 1 mA. För hög ström kan däremot skada dioden, så det är bättre att använda låg ström än för hög. Diodens spänningsfall varierar från ca 1,7 volt för vanliga röda lysdioder och upp till över 4,8 volt för högintensiva vita och blåa lysdioder.

Exempel: Du vill koppla in en grön lysdiod till ett 6-volts-batteri. Lysdioden har enligt uppgift ett spänningsfall på 2,1 volt och dess maximala ström är 20mA. Du bryr dig inte om att få ut fulla ljusstyrkan utan vill spara lite ström så du väljer att använda 10mA istället. Motståndet du ska koppla in i serie med lysdioden räknas då ut enligt följande:

R = (6,0 V - 2,1 V) / 0,010 A = 390 ohm

 

Hur man kopplar in en lysdiod till en strömkälla på ett säkert sätt.

Hur man kopplar in en lysdiod till en strömkälla på ett säkert sätt. Man måste alltid använda ett ett strömbegränsande motstånd annars riskerar man ha sönder lysdioden.

 

Kundvagn