IO Devices

Data Structures
struct	oled_font
	Represents a font for OLED displays. More...
struct	io_avr_device
	Represents an SPI-connected AVR-I/O board. More...
struct	io_oled_device
	Represents an OLED display device controlled via SPI. More...
struct	io_joystick_device
	Represents a joystick input device. More...
struct	io_joystick_position
	Represents the position of a joystick relative to center. More...

Enumerations
enum	io_joystick_direction {   LEFT , RIGHT , UP , DOWN ,   NEUTRAL }
	Predefined joystick directions. More...

Functions
struct	__attribute__ ((packed)) io_avr_buttons
	Represents button states for I/O boards (from I/O board manual).
int	io_joystick_init (struct io_joystick_device *dev)
	Initialise and calibrate a joystick.
int	io_joystick_read_position (struct io_joystick_device *dev, struct io_joystick_position *buffer)
	Read the position of a joystick as a percentage from 0 in each axis.
int	io_joystick_read_direction (struct io_joystick_device *dev, enum io_joystick_direction *direction)
	Fetches the direction of a joystick.
int	io_joystick_calibrate (struct io_joystick_device *dev)
	Calibrate a joystick. Requires the joystick to be in its neutral position.
int	io_avr_init (struct io_avr_device *dev)
int	io_avr_buttons_read (struct io_avr_device *dev, struct io_avr_buttons *btn)
int	io_avr_led_set (struct io_avr_device *dev, unsigned char led, unsigned char brightness)
int	io_oled_init (struct io_oled_device *dev)
	Initialise OLED.
int	io_oled_reset (struct io_oled_device *dev)
	Sends command to OLED.
int	io_oled_home (struct io_oled_device *dev)
	Loads homescreen to OLED.
int	io_oled_goto_line (struct io_oled_device *dev, int line)
	Go to specific line in OLED.
int	io_oled_goto_column (struct io_oled_device *dev, int column)
	Go to specific column in OLED.
int	io_oled_clear_line (struct io_oled_device *dev, int line)
	Clear specific line in OLED.
volatile int	io_oled_writedata (struct io_oled_device *dev, int data)
	Writes data to OLED at current position.
int	io_oled_pos (struct io_oled_device *dev, int row, int column)
	Set specific position in OLED.
int	io_oled_print (struct io_oled_device *dev, char *text)
	Write string to OLED.
int	io_oled_set_brightness (struct io_oled_device *dev, uint8_t brightness)
	Set OLED brightness.
int	io_oled_reset_brightness (struct io_oled_device *dev)
	Reset OLED brightness.
int	io_oled_print_arrow (struct io_oled_device *dev, uint8_t row, uint8_t col)
	Prints an arrow at a specified postion.
uint8_t	io_oled_write_glyph (struct io_oled_device *dev, const struct oled_font *font, char character_id)
	Prints a single glyph in a specifiec font.
int	io_oled_print_with_font (struct io_oled_device *dev, const struct oled_font *font, char *text)
	Prints an arrow at a specified postion.
int	io_oled_test (struct io_oled_device *dev)
	Prints a known image to the OLED to confirm that it can print and navigate the screen.
int	io_oled_blink (struct io_oled_device *dev, uint8_t blinks)
	Alternates screen between black and white.
int	io_oled_write_data (struct io_oled_device *dev, uint8_t data)
int	io_oled_write_command (struct io_oled_device *dev, uint8_t command)
int	io_oled_clear_all (struct io_oled_device *dev)
	Clears all lines on the OLED (fills entire display with black).

Variables
static const struct oled_font	OLED_FONT_8x8 = {font8, 8, 8, 1}
	Predefined 8x8 font for OLED.
static const struct oled_font	OLED_FONT_5x7 = {font5, 5, 7, 1}
	Predefined 5x7 font for OLED.
static const struct oled_font	OLED_FONT_4x6 = {font4, 4, 6, 1}
	Predefined 4x6 font for OLED.

Detailed Description

Enumeration Type Documentation

io_joystick_direction

enum io_joystick_direction

#include <io.h>

Predefined joystick directions.

Enumerator
LEFT	Joystick pushed left
RIGHT	Joystick pushed right
UP	Joystick pushed up
DOWN	Joystick pushed down
NEUTRAL	Joystick in neutral position

Definition at line 78 of file io.h.

                           {
  LEFT,   
  RIGHT,  
  UP,     
  DOWN,   
  NEUTRAL 
};

Function Documentation

__attribute__()

struct __attribute__

(

(packed)

)

#include <io.h>

Represents button states for I/O boards (from I/O board manual).

Buttons are packed as bits inside unions for convenient access.

< All right-side buttons as byte

< All left-side buttons as byte

< Navigation buttons as byte

< Bottom navigation button

< Right navigation button

< Down navigation button

< Left navigation button

< Up navigation button

Definition at line 34 of file io.h.

                                              {
  union {
    uint8_t right; 
    struct {
      uint8_t R1 : 1;
      uint8_t R2 : 1;
      uint8_t R3 : 1;
      uint8_t R4 : 1;
      uint8_t R5 : 1;
      uint8_t R6 : 1;
    };
  };
  union {
    uint8_t left; 
    struct {
      uint8_t L1 : 1;
      uint8_t L2 : 1;
      uint8_t L3 : 1;
      uint8_t L4 : 1;
      uint8_t L5 : 1;
      uint8_t L6 : 1;
      uint8_t L7 : 1;
    };
  };
  union {
    uint8_t nav; 
    struct {
      uint8_t NB : 1; 
      uint8_t NR : 1; 
      uint8_t ND : 1; 
      uint8_t NL : 1; 
      uint8_t NU : 1; 
    };
  };
};

io_avr_buttons_read()

int io_avr_buttons_read	(	struct io_avr_device *	dev,
		struct io_avr_buttons *	btn )

#include <io.h>

Definition at line 115 of file io.c.

                                                                               {
 
  unsigned char recbuf[3];
  spi_push(&dev->spi, IO_AVR_BUTTONS, TRASHCAN);
  spi_recieve_n(&dev->spi, recbuf, 3);
  spi_set_slave_select(&dev->spi, 1);
 
  btn->right = recbuf[0];
  btn->left = recbuf[1];
  btn->nav = recbuf[2];
 
  return 0;
}

Referenced by main(), and tx_joy_btn().

io_avr_init()

int io_avr_init

(

struct io_avr_device *

dev

)

#include <io.h>

Definition at line 106 of file io.c.

                                           {
 
  int status = 0;
 
  while (spi_ready()) {
    status = spi_init();
  }
  return status;
}

Referenced by main().

io_avr_led_set()

int io_avr_led_set	(	struct io_avr_device *	dev,
		unsigned char	led,
		unsigned char	brightness )

#include <io.h>

Definition at line 128 of file io.c.

                                             {
  unsigned char cmd[3] = {IO_AVR_LED_PWM, led, brightness};
  spi_send_n(&dev->spi, cmd, 3);
  return 0;
}

io_joystick_calibrate()

int io_joystick_calibrate

(

struct io_joystick_device *

dev

)

#include <io.h>

Calibrate a joystick. Requires the joystick to be in its neutral position.

Parameters

[in]

dev

The joystick to calibrate.

Returns

Errno.

io_joystick_init()

int io_joystick_init

(

struct io_joystick_device *

dev

)

#include <io.h>

Initialise and calibrate a joystick.

Parameters

[in]

dev

The joystick to be initlaised.

Returns

Errno.

Definition at line 30 of file io.c.

                                                     {
  int status = 0;
 
  ADC_init();
 
  return status;
}

io_joystick_read_direction()

int io_joystick_read_direction	(	struct io_joystick_device *	dev,
		enum io_joystick_direction *	direction )

#include <io.h>

Fetches the direction of a joystick.

Parameters

[in]	dev	The joystick to read.
[in]	direction	A buffer for storing the read direction.

Returns

Errno.

Definition at line 66 of file io.c.

                                                                      {
  int status = 0;
 
  struct io_joystick_position pos;
  status = io_joystick_read_position(dev, &pos);
  if (status) {
    return status;
  }
 
  if (pos.x > (0 - JOYSTICK_THRESHOLD) && pos.x < (0 + JOYSTICK_THRESHOLD) &&
      pos.y > (0 - JOYSTICK_THRESHOLD) && pos.y < (0 + JOYSTICK_THRESHOLD)) {
    *direction = NEUTRAL;
    return status;
  }
 
  // Fill inn the remaining directions...
 
  return status;
}

io_joystick_read_position()

int io_joystick_read_position	(	struct io_joystick_device *	dev,
		struct io_joystick_position *	buffer )

#include <io.h>

Read the position of a joystick as a percentage from 0 in each axis.

Parameters

[in]	dev	The joystick to read.
[in]	buffer	A buffer for storing the position value.

Returns

Errno.

Definition at line 38 of file io.c.

                                                                   {
  struct ADC_meas data;
 
  ADC_read_all(&data);
 
  uint8_t raw_x = data.channel[dev->adc_channel_x];
  uint8_t raw_y = data.channel[dev->adc_channel_y];
 
  if (raw_x < dev->x_min)
    raw_x = dev->x_min;
  if (raw_x > dev->x_max)
    raw_x = dev->x_max;
  if (raw_y < dev->y_min)
    raw_y = dev->y_min;
  if (raw_y > dev->y_max)
    raw_y = dev->y_max;
 
  buffer->x = map(raw_x, dev->x_min, dev->x_max, -127, 127);
  buffer->y = map(raw_y, dev->y_min, dev->y_max, -127, 127);
 
  if (buffer->x > -5 && buffer->x < 5)
    buffer->x = 0;
  if (buffer->y > -5 && buffer->y < 5)
    buffer->y = 0;
 
  return 0;
}

Referenced by io_joystick_read_direction(), and tx_joy_btn().

io_oled_blink()

int io_oled_blink	(	struct io_oled_device *	dev,
		uint8_t	blinks )

#include <io.h>

Alternates screen between black and white.

Parameters

[in]	dev	the OLED device that should be blinked
[in]	blinks	number of blinks newline

Returns

.

Definition at line 450 of file io.c.

                                                              {
 
  io_oled_home(dev);
 
  for (uint8_t blink = 0; blink < 2 * blinks; blink++) {
    for (uint8_t row = 0; row < 8; row++) {
      io_oled_goto_line(dev, row);
      io_oled_goto_column(dev, 0);
      for (uint8_t col = 0; col < 128; col++) {
        if (blink % 2 == 0) {
          _io_oled_write(dev, 0xFF);
        } else {
          _io_oled_write(dev, 0x00);
        }
      }
    }
    _delay_ms(500);
  }
  return 0;
}

io_oled_clear_all()

int io_oled_clear_all

(

struct io_oled_device *

dev

)

#include <io.h>

Clears all lines on the OLED (fills entire display with black).

Parameters

[in]

dev

Pointer to the OLED device struct

Returns

Errno (0 = success, -1 = failure)

Definition at line 292 of file io.c.

                                                  {
  int status = 0;
 
  // There are 8 pages (0–7) on a 64-pixel-tall display
  for (uint8_t line = 0; line < 8; line++) {
    status = io_oled_clear_line(dev, line);
    if (status < 0) {
      return status; // early exit on failure
    }
  }
 
  return 0;
}

Referenced by brightness_display(), calibrate_joystick_display(), game_over_display(), high_scores_display(), play_game_display(), settings_display(), and welcome_display().

io_oled_clear_line()

int io_oled_clear_line	(	struct io_oled_device *	dev,
		int	line )

#include <io.h>

Clear specific line in OLED.

Parameters

[in]	dev	The OLED who's line is to be cleared
[in]	line	the line that to be cleared

Returns

Errno.

Definition at line 275 of file io.c.

                                                             {
 
  if (line < 0 || line > 7)
    return -1;
  io_oled_goto_line(dev, line);
  io_oled_goto_column(dev, 0);
  for (uint8_t x = 0; x < 128; x++) {
    _io_oled_write(dev, 0x00);
  }
  return 0;
}

Referenced by io_oled_clear_all(), settings_display(), and welcome_display().

io_oled_goto_column()

int io_oled_goto_column	(	struct io_oled_device *	dev,
		int	column )

#include <io.h>

Go to specific column in OLED.

Parameters

[in]	dev	The OLED who's column is to be set
[in]	column	the column which should be set

Returns

Errno.

Definition at line 265 of file io.c.

                                                                {
 
  // Columns are split into low/high area commands 0x00-0x0F and 0x10-0x1F
  _io_oled_cmd(dev, 0x00 | (column & 0x0F));        // lower
  _io_oled_cmd(dev, 0x10 | ((column >> 4) & 0x0F)); // higher
  dev->current_column = column; // Update index of current column
 
  return 0;
}

Referenced by io_oled_blink(), io_oled_clear_line(), io_oled_home(), io_oled_init(), io_oled_pos(), and io_oled_test().

io_oled_goto_line()

int io_oled_goto_line	(	struct io_oled_device *	dev,
		int	line )

#include <io.h>

Go to specific line in OLED.

Parameters

[in]	dev	The OLED who's line is to be set
[in]	line	the line to be set

Returns

Errno.

Definition at line 255 of file io.c.

                                                            {
 
  if (line > 7)
    line = 7;                              // Out of bounds
  _io_oled_cmd(dev, 0xB0 | (line & 0x07)); // 0xB0-0xB7
  dev->current_page = line;                // Update index of current page
 
  return 0;
}

Referenced by io_oled_blink(), io_oled_clear_line(), io_oled_home(), io_oled_init(), io_oled_pos(), and io_oled_test().

io_oled_home()

int io_oled_home

(

struct io_oled_device *

dev

)

#include <io.h>

Loads homescreen to OLED.

Parameters

[in]

dev

The OLED to be set

Returns

Errno.

Definition at line 247 of file io.c.

                                             {
 
  io_oled_goto_line(dev, 0);
  io_oled_goto_column(dev, 0);
 
  return 0;
}

Referenced by brightness_display(), calibrate_joystick_display(), game_over_display(), high_scores_display(), io_oled_blink(), io_oled_test(), play_game_display(), settings_display(), and welcome_display().

io_oled_init()

int io_oled_init

(

struct io_oled_device *

dev

)

#include <io.h>

Initialise OLED.

Parameters

[in]

dev

The OLED to be initlaised.

Returns

Errno.

Definition at line 161 of file io.c.

                                             {
  int status = 0;
 
  while (spi_ready()) {
    status = spi_init();
  }
 
  // --- Configure OLED control pins --- //
  // Set directions *after* setting desired logic states to avoid glitching
  DDRB |= (1 << PB4) | (1 << PB1) | (1 << PB2); // Set PB0,PB1,PB2 to outputs
 
  // --- Hardware reset sequence --- //
  PORTB &= ~(1 << PB4);
  _delay_us(5);
  PORTB |= (1 << PB4);
  _delay_ms(1);
 
  // Display OFF
  _io_oled_cmd(dev, 0xAE);
 
  // Recommended config for 128x64 OLED, page 19 OLED datasheet
  _io_oled_cmd(dev, 0xA1); // Segment remap: column address 127->0
  _io_oled_cmd(dev, 0xC8); // Scan direction: remapped C8 or C0
 
  _io_oled_cmd(dev, 0xDA); // Common pads hardware
  _io_oled_cmd(dev, 0x12); // Required parameter for 128x64
 
  _io_oled_cmd(dev, 0xC8); // Common output scan direciton
 
  _io_oled_cmd(dev, 0xA8); // Set multiplex ratio
  _io_oled_cmd(dev, 0x3F); // Multiplex ratio: 63 (64MUX)
 
  _io_oled_cmd(dev, 0xD5); // set display clock devider ratio
  _io_oled_cmd(dev, 0x80); // freq.mode
 
  _io_oled_cmd(dev, 0x81); // Contrast control
  _io_oled_cmd(dev, 0xFF);
 
  _io_oled_cmd(dev, 0xD9); // Set precharged period
  _io_oled_cmd(dev, 0x21);
 
  _io_oled_cmd(dev, 0x20); // Set memory adressing mode
  _io_oled_cmd(dev, 0x02); // 0x02 = Page (alternativly 0x00 = Horizontal)
 
  _io_oled_cmd(dev, 0xDB); // VCOM deselect level mode
  _io_oled_cmd(dev, 0x30);
 
  _io_oled_cmd(dev, 0xAD); // Master config
  _io_oled_cmd(dev, 0x00); // Slave config
 
  _io_oled_cmd(dev, 0xA4); // Resume to RAM content
 
  _io_oled_cmd(dev, 0xA6); // Normal display
 
  // Clear GDDRAM once at init
  for (uint8_t page = 0; page < 8; page++) {
    io_oled_goto_line(dev, page);
    io_oled_goto_column(dev, 0);
    for (uint8_t x = 0; x < 128; x++) {
      _io_oled_write(dev, 0x00);
    }
  }
 
  // Display ON
  _io_oled_cmd(dev, 0xAF);
 
  return status;
}

Referenced by menu_init().

io_oled_pos()

int io_oled_pos	(	struct io_oled_device *	dev,
		int	row,
		int	column )

#include <io.h>

Set specific position in OLED.

Parameters

[in]	dev	The OLED who's position is to be set
[in]	row	The row of the position to be set
[in]	collumn	the collumn of the position the be set

Returns

Errno.

Definition at line 306 of file io.c.

                                                                  {
 
  io_oled_goto_line(dev, line);
  io_oled_goto_column(dev, column);
 
  return 0;
}

Referenced by draw_cursor(), game_over_display(), io_oled_print_arrow(), settings_display(), and welcome_display().

io_oled_print()

int io_oled_print	(	struct io_oled_device *	dev,
		char *	text )

#include <io.h>

Write string to OLED.

Parameters

[in]	dev	The OLED who should print the line
[in]	text	the string that should be written to the OLED

Returns

Errno.

io_oled_print_arrow()

int io_oled_print_arrow	(	struct io_oled_device *	dev,
		uint8_t	row,
		uint8_t	col )

#include <io.h>

Prints an arrow at a specified postion.

Parameters

[in]	dev	The OLED who's britness should be set
[in]	row	select row where the arrow should be placed
[in]	column	select column where the arrow should be placed

Returns

Errno.

Definition at line 330 of file io.c.

                                                                              {
 
  io_oled_pos(dev, row, col);
  _io_oled_write(dev, 0b00011000);
  _io_oled_write(dev, 0b00011000);
  _io_oled_write(dev, 0b01111110);
  _io_oled_write(dev, 0b00111100);
  _io_oled_write(dev, 0b00011000);
 
  return 0;
}

io_oled_print_with_font()

int io_oled_print_with_font	(	struct io_oled_device *	dev,
		const struct oled_font *	font,
		char *	text )

#include <io.h>

Prints an arrow at a specified postion.

Parameters

[in]	dev	the OLED device that should be written to
[in]	font	the specified font, see font.h
[in]	text	the string that should be printed to the OLED, has to end in newline

Returns

.

Definition at line 377 of file io.c.

                                                                      {
  if (!dev || !font || !text)
    return -1;
 
  for (char *p = text; *p; ++p) {
    if (*p == '\n') {
      continue;
    }
    io_oled_write_glyph(dev, font, *p);
  }
  return 0;
}

Referenced by brightness_display(), calibrate_joystick_display(), draw_cursor(), game_over_display(), high_scores_display(), io_oled_test(), play_game_display(), settings_display(), and welcome_display().

io_oled_reset()

int io_oled_reset

(

struct io_oled_device *

dev

)

#include <io.h>

Sends command to OLED.

Parameters

[in]	dev	The commanded OLED.
[in]	command	the hex command (see p27. SSD1309 datasheet)

Returns

Errno.

Sends data to OLED

Parameters

[in]	dev	The OLED that should receive the data.
[in]	data	the data that the OLED should recive

Returns

Errno.

Resets OLED to blank page

Parameters

[in]

dev

The OLED to be reset.

Returns

Errno.

Definition at line 230 of file io.c.

                                              {
 
  // Display off
  _io_oled_cmd(dev, 0xAE);
 
  // --- Hardware reset sequence --- //
  PORTB &= ~(1 << PB4); // Set PB4 low
  _delay_us(5);         // Wait 5us
  PORTB |= (1 << PB4);  // Set PB4 high
  _delay_ms(1); // Making sure its restarted before we start sending commands
 
  // Turn display on
  _io_oled_cmd(dev, 0xAF);
 
  return 0;
}

io_oled_reset_brightness()

int io_oled_reset_brightness

(

struct io_oled_device *

dev

)

#include <io.h>

Reset OLED brightness.

Parameters

[in]

dev

The OLED who's britness should be set

Returns

Errno.

Definition at line 322 of file io.c.

                                                         {
 
  _io_oled_cmd(dev, 0x81);
  _io_oled_cmd(dev, 0x7F);
 
  return 0;
}

io_oled_set_brightness()

int io_oled_set_brightness	(	struct io_oled_device *	dev,
		uint8_t	brightness )

#include <io.h>

Set OLED brightness.

Parameters

[in]	dev	The OLED who's britness should be set
[in]	brightness	the brightness level to be set

Returns

Errno.

Definition at line 314 of file io.c.

                                                                           {
 
  _io_oled_cmd(dev, 0x81);
  _io_oled_cmd(dev, brightness);
 
  return 0;
}

io_oled_test()

int io_oled_test

(

struct io_oled_device *

dev

)

#include <io.h>

Prints a known image to the OLED to confirm that it can print and navigate the screen.

Parameters

[in]

dev

the OLED device that should be tested newline

Returns

.

Definition at line 391 of file io.c.

                                             {
 
  io_oled_home(dev);
 
  // print half a line
  for (uint8_t i = 0; i < 64; i++) {
    _io_oled_write(dev, 0xff);
  }
 
  io_oled_goto_line(dev, 1); // new line
 
  // print half a line
  for (uint8_t i = 0; i < 64; i++) {
    _io_oled_write(dev, 0xff);
  }
 
  io_oled_goto_line(dev, 2);   // new line
  io_oled_goto_column(dev, 0); // new carrige return
 
  // fill every other column in a row
  for (uint8_t i = 0; i < 128; i++) {
    if (i % 2 == 0) {
      _io_oled_write(dev, 0xff);
    } else {
      _io_oled_write(dev, 0x00);
    }
  }
 
  io_oled_goto_line(dev, 3);   // new line
  io_oled_goto_column(dev, 0); // new carrige return
 
  // fill a row with chess pattern
  for (uint8_t i = 0; i < 128; i++) {
    if (i % 2 == 0) {
      _io_oled_write(dev, 0b01010101);
    } else {
      _io_oled_write(dev, 0b10101010);
    }
  }
 
  io_oled_goto_line(dev, 4);   // new line
  io_oled_goto_column(dev, 0); // new carrige return
  io_oled_print_with_font(dev, &OLED_FONT_8x8, "Text 8x8");
 
  io_oled_goto_line(dev, 5);   // new line
  io_oled_goto_column(dev, 0); // new carrige return
  io_oled_print_with_font(dev, &OLED_FONT_5x7, "Text 5x7");
 
  io_oled_goto_line(dev, 6);   // new line
  io_oled_goto_column(dev, 0); // new carrige return
  io_oled_print_with_font(dev, &OLED_FONT_4x6, "Text 4x6");
 
  io_oled_goto_line(dev, 7);   // new line
  io_oled_goto_column(dev, 0); // new carrige return
  io_oled_print_with_font(dev, &OLED_FONT_8x8, "Test:Complete");
 
  return 0;
}

io_oled_write_command()

int io_oled_write_command	(	struct io_oled_device *	dev,
		uint8_t	command )

#include <io.h>

Definition at line 475 of file io.c.

                                                                       {
  return _io_oled_cmd(dev, command);
}

io_oled_write_data()

int io_oled_write_data	(	struct io_oled_device *	dev,
		uint8_t	data )

#include <io.h>

Definition at line 471 of file io.c.

                                                                 {
  return _io_oled_write(dev, data);
}

Referenced by draw_cursor().

io_oled_write_glyph()

uint8_t io_oled_write_glyph	(	struct io_oled_device *	dev,
		const struct oled_font *	font,
		char	character_id )

#include <io.h>

Prints a single glyph in a specifiec font.

Parameters

[in]	dev	the OLED that should be written to
[in]	font	the specified font, see font.h
[in]	character_id	the character that should be written

Returns

Errno.

Definition at line 343 of file io.c.

                                                                             {
 
  uint8_t start_page = dev->current_page;
  uint8_t start_column = dev->current_column;
 
  // --- Draw the glyph on the current page --- //
  uint8_t glyph_id = 0; // Space as default value
 
  // Make sure char_id in range
  if ((uint8_t)character_id >= 32 && (uint8_t)character_id <= 126) {
    glyph_id = (uint8_t)character_id - 32;
  }
 
  // Find glyph in fonts.h
  uint8_t *base = (uint8_t *)font->table + (glyph_id * font->bytes_per_glyph);
 
  // Print glyph to oled
  for (uint8_t c = 0; c < font->bytes_per_glyph; ++c) {
    // function from <avr/pgmspace.h> that reads from PROGMEM
    uint8_t col = pgm_read_byte(base + c);
    _io_oled_write(dev, col);
  }
 
  // Add spacing after glyph
  for (uint8_t s = 0; s < font->spacing; ++s) {
    _io_oled_write(dev, 0x00);
  }
 
  uint8_t total_cols = (uint8_t)(font->bytes_per_glyph + font->spacing);
 
  return total_cols;
}

Referenced by io_oled_print_with_font().

io_oled_writedata()

volatile int io_oled_writedata	(	struct io_oled_device *	dev,
		int	data )

#include <io.h>

Writes data to OLED at current position.

Parameters

[in]	dev	The OLED where the data should be sent
[in]	data	The data to be sendt to the OLED

Returns

Errno.

Variable Documentation

OLED_FONT_4x6

const struct oled_font OLED_FONT_4x6 = {font4, 4, 6, 1}

static

#include <io.h>

Predefined 4x6 font for OLED.

Definition at line 34 of file io.h.

{font4, 4, 6, 1};

Referenced by __attribute__(), and io_oled_test().

OLED_FONT_5x7

const struct oled_font OLED_FONT_5x7 = {font5, 5, 7, 1}

static

#include <io.h>

Predefined 5x7 font for OLED.

Definition at line 32 of file io.h.

{font5, 5, 7, 1};

Referenced by io_oled_test().

OLED_FONT_8x8

const struct oled_font OLED_FONT_8x8 = {font8, 8, 8, 1}

static

#include <io.h>

Predefined 8x8 font for OLED.

Definition at line 30 of file io.h.

{font8, 8, 8, 1};

Referenced by io_oled_test().