oled-control 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4c496a83d860309cdefd939cff54744d546ee3a9
+  data.tar.gz: 20260794cf74b80a183303d7ea79cf467082e86c
+SHA512:
+  metadata.gz: 5f99bf7fb85a8edb3badce29b6885ab3be3a96d52577e08207a39d8908246571b0b84c20c96d23d4c70579ad8e99636bf5bc331fb0661cd6240a04673b9919a2
+  data.tar.gz: e802e762c16ac8723e868a389e43874829ee05d8d537d5de1bd4fe540b7894495b420273481c1ba08ef6c61cc5cb01f9e4ad55f116918abbba966336db67146d

data/ext/oled-control/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+have_library('i2c-dev')
+
+create_makefile('oled-control/oled_control')

data/ext/oled-control/main.c

@@ -0,0 +1,74 @@
+//
+// Created by sokkalf on 3/6/16.
+//
+#include "oled-control.h"
+
+void test_display() {
+    set_cursor_position(2, 1);
+    i2c_write_bytes(DATA, "In A.D. 2101");
+    set_cursor_position(1, 2);
+    i2c_write_bytes(DATA, "War was beginning.");
+    sleep(5);
+    clear_display();
+    set_cursor_position(2, 1);
+    i2c_write_bytes(DATA, "Captain:");
+    set_cursor_position(4, 2);
+    i2c_write_bytes(DATA, "What happen?");
+    sleep(2);
+    clear_display();
+    set_cursor_position(2, 1);
+    i2c_write_bytes(DATA, "Mechanic:");
+    set_cursor_position(0, 2);
+    i2c_write_bytes(DATA, "Somebody set up us");
+    set_cursor_position(0, 3);
+    i2c_write_bytes(DATA, "the bomb");
+    sleep(2);
+    clear_display();
+    set_cursor_position(2, 1);
+    i2c_write_bytes(DATA, "Operator:");
+    set_cursor_position(0, 2);
+    i2c_write_bytes(DATA, "We get signal.");
+    sleep(2);
+    clear_display();
+    set_cursor_position(2, 1);
+    i2c_write_bytes(DATA, "Captain:");
+    set_cursor_position(0, 2);
+    i2c_write_bytes(DATA, "WHAT !");
+    sleep(2);
+    clear_display();
+    set_cursor_position(2, 1);
+    i2c_write_bytes(DATA, "Operator:");
+    set_cursor_position(1, 2);
+    i2c_write_bytes(DATA, "Main screen");
+    set_cursor_position(1, 3);
+    i2c_write_bytes(DATA, "turn on.");
+    sleep(2);
+    clear_display();
+    set_cursor_position(2, 1);
+    i2c_write_bytes(DATA, "Captain:");
+    set_cursor_position(0, 2);
+    i2c_write_bytes(DATA, "It's you !!");
+    sleep(2);
+    clear_display();
+    set_cursor_position(2, 1);
+    i2c_write_bytes(DATA, "Cats:");
+    set_cursor_position(0, 2);
+    i2c_write_bytes(DATA, "How are you");
+    set_cursor_position(1, 3);
+    i2c_write_bytes(DATA, "gentlemen !!");
+    sleep(2);
+    clear_display();
+    set_cursor_position(2, 1);
+    i2c_write_bytes(DATA, "Cats:");
+    set_cursor_position(0, 2);
+    i2c_write_bytes(DATA, "All your base are");
+    set_cursor_position(1, 3);
+    i2c_write_bytes(DATA, "belong to us.");
+}
+
+int main() {
+    configure_display("/dev/i2c-1", 0x3c);
+    init_display();
+    test_display();
+    return 0;
+}

data/ext/oled-control/oled-control-gem.c

@@ -0,0 +1,101 @@
+//
+// Created by sokkalf on 3/6/16.
+//
+
+#include "oled-control.h"
+#include <ruby.h>
+
+
+static VALUE set_cursor(VALUE self, VALUE col, VALUE row) {
+    uint8_t c = NUM2UINT(col);
+    uint8_t r = NUM2UINT(row);
+
+    if(!set_cursor_position(c, r))
+        rb_raise(rb_eRuntimeError, "unable to set cursor position");
+
+    return Qtrue;
+}
+
+static VALUE write_string(VALUE self, VALUE str) {
+    const char *s = RSTRING_PTR(str);
+    if(!i2c_write_bytes(DATA, s))
+        rb_raise(rb_eRuntimeError, "unable to write string to display");
+
+    return Qtrue;
+}
+
+static VALUE init(VALUE self, VALUE i2cbus, VALUE i2caddress) {
+    const char *bus = RSTRING_PTR(i2cbus);
+    uint8_t a = NUM2UINT(i2caddress);
+
+    if(!configure_display(bus, a))
+        rb_raise(rb_eRuntimeError, "can't detect display! Bus/address wrong?");
+
+    if(!init_display())
+        rb_raise(rb_eRuntimeError, "failure initializing display");
+
+    return Qtrue;
+}
+
+static VALUE clear(VALUE self) {
+    if(!clear_display())
+        rb_raise(rb_eRuntimeError, "failure clearing display");
+
+    return Qtrue;
+}
+
+static VALUE enable(VALUE self) {
+    if(!display_enable()) {
+        rb_raise(rb_eRuntimeError, "error enabling display");
+    }
+
+    return Qtrue;
+}
+
+static VALUE disable(VALUE self) {
+    if(!display_disable()) {
+        rb_raise(rb_eRuntimeError, "error disabling display");
+    }
+
+    return Qtrue;
+}
+
+static VALUE send_command(VALUE self, VALUE command) {
+    uint8_t  cmd = NUM2UINT(command);
+    if(!send_cmd(cmd)) {
+        rb_raise(rb_eRuntimeError, "error sending command");
+    }
+
+    return Qtrue;
+}
+
+static VALUE send_raw_command(VALUE self, VALUE command) {
+    uint8_t  cmd = NUM2UINT(command);
+    if(!send_raw_cmd(cmd)) {
+        rb_raise(rb_eRuntimeError, "error sending raw command");
+    }
+
+    return Qtrue;
+}
+
+static VALUE set_contrast(VALUE self, VALUE level) {
+    uint8_t val = NUM2UINT(level);
+    if(!set_contrast_level(val)) {
+        rb_raise(rb_eRuntimeError, "error setting contrast");
+    }
+    return Qtrue;
+}
+
+void Init_oled_control(void) {
+    VALUE klass = rb_define_class("OLED", rb_cObject);
+
+    rb_define_method(klass, "set_cursor", set_cursor, 2);
+    rb_define_method(klass, "clear", clear, 0);
+    rb_define_method(klass, "set_contrast", set_contrast, 1);
+    rb_define_method(klass, "enable", enable, 0);
+    rb_define_method(klass, "disable", disable, 0);
+    rb_define_protected_method(klass, "send_command", send_command, 1);
+    rb_define_protected_method(klass, "send_raw_command", send_raw_command, 1);
+    rb_define_protected_method(klass, "write_string", write_string, 1);
+    rb_define_protected_method(klass, "init", init, 2);
+}

data/ext/oled-control/oled-control.c

@@ -0,0 +1,136 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "oled-control.h"
+
+const char* i2c_bus;
+int i2c_bus_handle;
+uint8_t oled_address;
+int configured = FALSE;
+
+int i2c_write_byte(uint8_t reg, uint8_t data) {
+    char buf[2];
+    buf[0] = reg;
+    buf[1] = data;
+    if(write(i2c_bus_handle, buf, 2) != 2) {
+        fprintf(stderr, "Write to device failed\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+int i2c_write_bytes(uint8_t reg, const char* data) {
+    size_t len = sizeof(uint8_t) + strlen(data);
+    // allocate room for reg + data + trailing null character:
+    char *buf = calloc(1, len+1);
+    memcpy(&buf[0], &reg, 1);
+    memcpy(&buf[1], data, strlen(data));
+    // write the reg + data, minus the trailing null character
+    if(write(i2c_bus_handle, buf, len) != len) {
+        fprintf(stderr, "Write to device failed\n");
+        free(buf);
+        return FALSE;
+    }
+    free(buf);
+    return TRUE;
+}
+
+int set_cursor_position(uint8_t col, uint8_t row) {
+    if((col >= DISPLAY_MAX_COLS) || (row >= DISPLAY_MAX_ROWS))
+        return FALSE;
+
+    int line_offsets[] = {
+            0x00,  // start of line 1
+            0x20,
+            0x40,
+            0x60   // start of line 4
+    };
+    return i2c_write_byte(CMD, 0x80 | (col + line_offsets[row]));
+}
+
+int clear_display() {
+    return i2c_write_byte(CMD, 0x01);
+}
+
+int set_contrast_level(uint8_t level) {
+    return i2c_write_byte(CMD, 0x2A) &&
+           i2c_write_byte(CMD, 0x79) &&
+           i2c_write_byte(CMD, 0x81) &&
+           i2c_write_byte(CMD, level) &&
+           i2c_write_byte(CMD, 0x78) &&
+           i2c_write_byte(CMD, 0x28);
+}
+
+int display_enable() {
+    return i2c_write_byte(CMD, 0x0C);
+}
+
+int display_disable() {
+    return i2c_write_byte(CMD, 0x08);
+}
+
+int send_cmd(uint8_t cmd) {
+    return i2c_write_byte(CMD, 0x2A) &&
+           i2c_write_byte(CMD, cmd) &&
+           i2c_write_byte(CMD, 0x28);
+}
+
+int send_raw_cmd(uint8_t cmd) {
+    return i2c_write_byte(CMD, cmd);
+}
+
+int configure_display(const char* bus, uint8_t address) {
+    i2c_bus = bus;
+    oled_address = address;
+    if((i2c_bus_handle = open(i2c_bus, O_RDWR)) < 0) {
+        return FALSE;
+    }
+    if (ioctl(i2c_bus_handle, I2C_SLAVE, oled_address) < 0) {
+        return FALSE;
+    }
+    configured = TRUE;
+    return configured;
+}
+
+int init_display() {
+    if(!configured)
+        return FALSE;
+
+    return i2c_write_byte(CMD, 0x2a) && // **** Set "RE"=1<--->00101010B
+    i2c_write_byte(CMD, 0x71) &&
+    i2c_write_byte(CMD, 0x5c) &&
+    i2c_write_byte(CMD, 0x28) &&
+    i2c_write_byte(CMD, 0x08) && // display off
+    i2c_write_byte(CMD, 0x2a) &&
+    i2c_write_byte(CMD, 0x79) &&
+    i2c_write_byte(CMD, 0xd5) &&
+    i2c_write_byte(CMD, 0x70) &&
+    i2c_write_byte(CMD, 0x78) &&
+    i2c_write_byte(CMD, 0x09) && // this is a 4 line display. Set to 0x08 for a 2 line display.
+    i2c_write_byte(CMD, 0x06) &&
+    i2c_write_byte(CMD, 0x72) &&
+    i2c_write_byte(DATA, 0x00) &&
+    i2c_write_byte(CMD, 0x2a) &&
+    i2c_write_byte(CMD, 0x79) &&
+    i2c_write_byte(CMD, 0xda) &&
+    i2c_write_byte(CMD, 0x10) &&
+    i2c_write_byte(CMD, 0xdc) &&
+    i2c_write_byte(CMD, 0x00) &&
+    i2c_write_byte(CMD, 0x81) && // set contrast
+    i2c_write_byte(CMD, 0x50) && // contrast level
+    i2c_write_byte(CMD, 0xdb) &&
+    i2c_write_byte(CMD, 0x30) &&
+    i2c_write_byte(CMD, 0xdc) &&
+    i2c_write_byte(CMD, 0x03) &&
+    i2c_write_byte(CMD, 0x78) &&
+    i2c_write_byte(CMD, 0x28) &&
+    i2c_write_byte(CMD, 0x2a) &&
+    i2c_write_byte(CMD, 0x06) && // entry mode (move cursor right, don’t shift display)
+    i2c_write_byte(CMD, 0x28) &&
+    i2c_write_byte(CMD, 0x01) &&
+    i2c_write_byte(CMD, 0x80) &&
+    display_enable() &&
+    !usleep(1000); // spec says to hold on for 0.1 secs before data
+    // usleep returns 0, ergo FALSE, on success, so invert it
+}
+
+

data/ext/oled-control/oled-control.h

@@ -0,0 +1,37 @@
+//
+// Created by sokkalf on 3/6/16.
+//
+
+#ifndef OLED_CONTROL_OLED_CONTROL_H
+#define OLED_CONTROL_OLED_CONTROL_H
+
+#include <stddef.h>
+#include <linux/i2c-dev.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdint.h>
+
+#define TRUE 1
+#define FALSE 0
+
+#define CMD 0x80
+#define DATA 0x40
+
+#define DISPLAY_MAX_ROWS 4
+#define DISPLAY_MAX_COLS 20
+
+int i2c_write_byte(uint8_t reg, uint8_t data);
+int i2c_write_bytes(uint8_t reg, const char* data);
+int set_cursor_position(uint8_t col, uint8_t row);
+int clear_display();
+int set_contrast_level(uint8_t level);
+int display_enable();
+int display_disable();
+int send_cmd(uint8_t cmd);
+int send_raw_cmd(uint8_t cmd);
+int configure_display(const char* bus, uint8_t address);
+int init_display();
+
+#endif //OLED_CONTROL_OLED_CONTROL_H

data/lib/oled-control/oled.rb

@@ -0,0 +1,83 @@
+require 'oled-control/oled_control'
+
+class OLED
+  NORMAL=0x06
+  FLIPPED=0x05
+
+  def initialize(i2c_bus = '/dev/i2c-1', i2c_address = 0x3c, flipped = false)
+    @flipped = flipped
+
+    # the OLED display defines its own weird character set
+    @character_conversion = {
+        0xE5 => 0xAF, # å
+        0xC5 => 0xAE, # Å
+        0xF8 => 0xAC, # ø
+        0xD8 => 0xAB, # Ø
+        0xE6 => 0xBD, # æ
+        0xC6 => 0xBC, # Æ
+        0xD6 => 0x5C, # Ö
+        0xF6 => 0x7C, # ö
+        0xF1 => 0x7D, # ñ
+        0xD1 => 0x5D, # Ñ
+        0xE4 => 0x7B, # ä
+        0xC4 => 0x5B, # Ä
+        0xFC => 0x7E, # ü
+        0xDC => 0x5E, # Ü
+        0xE9 => 0xA5, # é
+        0xC9 => 0xBF, # É
+        0xED => 0xE8, # í
+        0xCD => 0xE3, # Í
+        0xDF => 0xBE, # ß
+        0xE1 => 0xE7, # á
+        0xC1 => 0xE2, # Á
+        0xEA => 0xC7, # ê
+        0xCA => 0xC6, # Ê
+        0x40 => 0xA0, # @
+        0xA4 => 0x24, # ¤
+        0x24 => 0xA2, # $
+        0xA3 => 0xA1, # £
+        0xFA => 0xEA, # ú
+        0xDA => 0xE5, # Ú
+        # unsupported characters are mapped to closest match
+        0xEF => 0x69, # ï -> i
+        0xCF => 0x49, # Ï -> I
+        0xEB => 0x65, # ë -> e
+        0xCB => 0x45, # Ë -> E
+        0xE3 => 0x61, # ã -> a
+        0xC3 => 0x41, # Ã -> A
+    }
+    self.init(i2c_bus, i2c_address)
+  end
+
+  def clear_row(row)
+    set_cursor(0, row)
+    write(" "*20)
+  end
+
+  def command(cmd)
+    self.send_command(cmd)
+  end
+
+  def raw_command(cmd)
+    self.send_raw_command(cmd)
+  end
+
+  def flip
+    @flipped = !@flipped
+    if @flipped
+      command(NORMAL)
+    else
+      command(FLIPPED)
+    end
+  end
+
+  def write(str)
+    unless str.is_a?(String)
+      str = str.to_s
+    end
+    iso_string = str.encode('iso-8859-1')
+    encoded_string = []
+    iso_string.each_byte{|b| encoded_string << (@character_conversion[b.ord].nil? ? b.ord : @character_conversion[b.ord]) }
+    self.write_string(encoded_string.pack("c*"))
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: oled-control
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Christian Lønaas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-10 00:00:00.000000000 Z
+dependencies: []
+description: Ruby Gem for SSD1311 based 20x4 OLED display
+email: christian.lonaas@discombobulator.org
+executables: []
+extensions:
+- ext/oled-control/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/oled-control/extconf.rb
+- ext/oled-control/main.c
+- ext/oled-control/oled-control-gem.c
+- ext/oled-control/oled-control.c
+- ext/oled-control/oled-control.h
+- lib/oled-control/oled.rb
+homepage: https://github.com/sokkalf/oled-control
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Control OLED i2c display
+test_files: []