alex/SSD1306
1
0
Fork 0
mirror of https://github.com/Matiasus/SSD1306.git synced 2024-09-19 17:45:59 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix confilicts

Browse Source
This commit is contained in:
matiasus 2022-11-22 20:51:50 +01:00
commit 68ce61bfcc
9 changed files with 347 additions and 547 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
README.md
View File

@ -4,7 +4,14 @@
Detailed information are described in [Datasheet SSD1306](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf). Detailed information are described in [Datasheet SSD1306](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf).
## Library ## Library
C library is aimed for driving [SSD1306 0.96" OLED display](#demonstration) 128x64 through TWI's Atmega16. C library is aimed for driving [0.96" OLED display with SSD1306 driver](#demonstration) 128x64 through TWI's Atmega328p.
### Versions
- 1.0 - basic functions. The first publication.
- 2.0 - more changes:
- rebuild to cacheMemLcd array. It means that every request is stored in cache array and then is depicted on the display by function [SSD1306_UpdateScreen (uint8_t)](#ssd1306_updatescreen).
- Added new function -> [SSD1306_DrawLine (uint8_t, uint8_t, uint8_t, uint8_t)](#ssd1306_drawline). Possible depicted any line (horizontal, vertical, with slope).
- Possible to use for more than 1 display (not tested, cause displays that I have avialable had the same addresses).
## Dependencies ## Dependencies
- [font.c](https://github.com/Matiasus/SSD1306/blob/readme-edits/lib/font.c) - [font.c](https://github.com/Matiasus/SSD1306/blob/readme-edits/lib/font.c)
@ -15,15 +22,15 @@ C library is aimed for driving [SSD1306 0.96" OLED display](#demonstration) 128x
Font.c can be modified according to application requirements with form defined in font.c. Maximal permissible horizontal dimension is 8 bits. Font.c can be modified according to application requirements with form defined in font.c. Maximal permissible horizontal dimension is 8 bits.
### Usage ### Usage
Prior defined for MCU Atmega16 / Atmega8. Need to be carefull with TWI ports definition. Prior defined for MCU Atmega328p / Atmega8 / Atmega16. Need to be carefull with TWI ports definition.
| PORT | [Atmega16](http://ww1.microchip.com/downloads/en/devicedoc/doc2466.pdf) | [Atmega8](https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-2486-8-bit-AVR-microcontroller-ATmega8_L_datasheet.pdf) | | PORT | [Atmega16](http://ww1.microchip.com/downloads/en/devicedoc/doc2466.pdf) | [Atmega8](https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-2486-8-bit-AVR-microcontroller-ATmega8_L_datasheet.pdf) / [Atmega328](https://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48A-PA-88A-PA-168A-PA-328-P-DS-DS40002061B.pdf) |
| :---: | :---: | :---: | | :---: | :---: | :---: |
| SCL | PC0 | PC5 | | SCL | PC0 | PC5 |
| SDA | PC1 | PC4 | | SDA | PC1 | PC4 |
### Tested ### Tested
Library was tested and proved on a **_SSD1306 0.96″ OLED Dispay_** with **_Atmega16_**. Library was tested and proved on **_0.96″ OLED Display with SSD1306 driver_** and **_Atmega328p_**.
## Init OLED Sequence ## Init OLED Sequence
Init sequence OLED display was defined according to page 64 (next to last page) of [Datasheet SSD1306](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf). Init sequence OLED display was defined according to page 64 (next to last page) of [Datasheet SSD1306](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf).
@ -105,17 +112,19 @@ Init sequence OLED display was defined according to page 64 (next to last page)
// +---------------------------+ // +---------------------------+
``` ```
## Functions ## Functions
- [SSD1306_Init (void)](#ssd1306_init) - Init display - [SSD1306_Init (uint8_t)](#ssd1306_init) - Init display
- [SSD1306_ClearScreen (char)](#ssd1306_clearscreen) - Clear screen - [SSD1306_ClearScreen (void)](#ssd1306_clearscreen) - Clear screen
- [SSD1306_InverseScreen (void)](#ssd1306_inversescreen) - Inverse screen - [SSD1306_NormalScreen (uint8_t)](#ssd1306_normalscreen) - Normal screen
- [SSD1306_SetPosition (char, char)](#ssd1306_setposition) - Set position - [SSD1306_InverseScreen (uint8_t)](#ssd1306_inversescreen) - Inverse screen
- [SSD1306_SetPosition (uint8_t, uint8_t)](#ssd1306_setposition) - Set position
- [SSD1306_DrawChar (char)](#ssd1306_drawchar) - Draw specific character - [SSD1306_DrawChar (char)](#ssd1306_drawchar) - Draw specific character
- [SSD1306_DrawString (char*)](#ssd1306_drawstring) - Draw specific string - [SSD1306_DrawString (char*)](#ssd1306_drawstring) - Draw specific string
- [SSD1306_UpdateScreen (void)](#ssd1306_updatescreen) - Display on - [SSD1306_UpdateScreen (uint8_t)](#ssd1306_updatescreen) - Update content on display
- [SSD1306_DrawLineHorizontal (char, char, char)](#ssd1306_drawlinehorizontal) - Draw horizontal line - [SSD1306_DrawLine (uint8_t, uint8_t, uint8_t, uint8_t)](#ssd1306_drawline) - Draw line
## Demonstration ## Demonstration
<img src="img/demonstration_ssd1306.jpg" /> <img src="img/ssd1306_v20.png" />
## Links ## Links
- [Datasheet SSD1306](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf) - [Datasheet SSD1306](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf)
- [Atmega328](https://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48A-PA-88A-PA-168A-PA-328-P-DS-DS40002061B.pdf)

BIN
img/ssd1306_v20.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.7 MiB

4
lib/font.c
View File

@ -8,7 +8,7 @@
* @author Marian Hrinko * @author Marian Hrinko
* @datum 07.10.2020 * @datum 07.10.2020
* @file font.c * @file font.c
* @tested AVR Atmega16 * @tested AVR Atmega16, Atmega8, Atmega328
* *
* @depend * @depend
* ---------------------------------------------------------------+ * ---------------------------------------------------------------+
@ -16,7 +16,7 @@
#include "font.h" #include "font.h"
/** @array Charset */ /** @array Charset */
const uint8_t FONTS[][5] PROGMEM = { const uint8_t FONTS[][CHARS_COLS_LENGTH] PROGMEM = {
{ 0x00, 0x00, 0x00, 0x00, 0x00 }, // 20 space { 0x00, 0x00, 0x00, 0x00, 0x00 }, // 20 space
{ 0x81, 0x81, 0x18, 0x81, 0x81 }, // 21 ! { 0x81, 0x81, 0x18, 0x81, 0x81 }, // 21 !
{ 0x00, 0x07, 0x00, 0x07, 0x00 }, // 22 " { 0x00, 0x07, 0x00, 0x07, 0x00 }, // 22 "

2
lib/font.h
View File

@ -8,7 +8,7 @@
* @author Marian Hrinko * @author Marian Hrinko
* @datum 07.10.2020 * @datum 07.10.2020
* @file font.h * @file font.h
* @tested AVR Atmega16 * @tested AVR Atmega16, Atmega8, Atmega328
* *
* @depend * @depend
* ---------------------------------------------------------------+ * ---------------------------------------------------------------+

564
lib/ssd1306.c
View File

@ -1,25 +1,26 @@
/** /**
* ---------------------------------------------------------------+ * ---------------------------------------------------------------+
* @desc SSD1306 OLED Driver * @desc SSD1306 OLED Driver
* ---------------------------------------------------------------+ * ---------------------------------------------------------------+
* Copyright (C) 2020 Marian Hrinko. * Copyright (C) 2020 Marian Hrinko.
* Written by Marian Hrinko (mato.hrinko@gmail.com) * Written by Marian Hrinko (mato.hrinko@gmail.com)
* *
* @author Marian Hrinko * @author Marian Hrinko
* @datum 06.10.2020 * @datum 06.10.2020
* @update 19.07.2021 * @update 21.11.2022
* @file ssd1306.c * @file ssd1306.c
* @version 2.0 * @version 3.0
* @tested AVR Atmega328 * @tested AVR Atmega328
* *
* @depend font.h, twi.h * @depend font.h, twi.h
* ---------------------------------------------------------------+ * ---------------------------------------------------------------+
* @descr Version 1.0 -> applicable for 1 display * @descr Version 1.0 -> applicable for 1 display
* Version 2.0 -> rebuild to 'cacheMemLcd' array * Version 2.0 -> rebuild to 'cacheMemLcd' array
* Version 3.0 -> remove 'cacheMemLcd' approach
* ---------------------------------------------------------------+ * ---------------------------------------------------------------+
* @usage Basic Setup for OLED Display * @usage Basic Setup for OLED Display
*/ */
#include "ssd1306.h" #include "ssd1306.h"
// +---------------------------+ // +---------------------------+
@ -97,56 +98,30 @@
// | 0xAF | // | 0xAF |
// +---------------------------+ // +---------------------------+
/** @array Init command */ // @array Init command
const uint8_t INIT_SSD1306[] PROGMEM = { const uint8_t INIT_SSD1306[] PROGMEM = {
// number of initializers 18, // number of initializers
18, 0, SSD1306_DISPLAY_OFF, // 0xAE = Set Display OFF
// 0xAE = Set Display OFF 1, SSD1306_SET_MUX_RATIO, 0x3F, // 0xA8
0, SSD1306_DISPLAY_OFF, 1, SSD1306_MEMORY_ADDR_MODE, 0x00, // 0x20 = Set Memory Addressing Mode
// 0xA8 // 0x00 - Horizontal Addressing Mode
1, SSD1306_SET_MUX_RATIO, 0x3F, // 0x01 - Vertical Addressing Mode
// 0x20 = Set Memory Addressing Mode // 0x02 - Page Addressing Mode (RESET)
// ----------------------------------- 2, SSD1306_SET_COLUMN_ADDR, START_COLUMN_ADDR, END_COLUMN_ADDR, // 0x21 = Set Column Address
// 0x00 - Horizontal Addressing Mode 2, SSD1306_SET_PAGE_ADDR, START_PAGE_ADDR, END_PAGE_ADDR, // 0x22 = Set Page Address
// 0x01 - Vertical Addressing Mode 0, SSD1306_SET_START_LINE, // 0x40
// 0x02 - Page Addressing Mode (RESET) 1, SSD1306_DISPLAY_OFFSET, 0x00, // 0xD3
1, SSD1306_MEMORY_ADDR_MODE, 0x00, 0, SSD1306_SEG_REMAP_OP, // 0xA0 / remap 0xA1
// 0x21 = Set Column Address 0, SSD1306_COM_SCAN_DIR_OP, // 0xC0 / remap 0xC8
// ----------------------------------- 1, SSD1306_COM_PIN_CONF, 0x12, // 0xDA
// 0x00 - Start Column Address 1, SSD1306_SET_CONTRAST, 0x7F, // 0x81
// 0xFF - End Column Address 0, SSD1306_DIS_ENT_DISP_ON, // 0xA4
2, SSD1306_SET_COLUMN_ADDR, START_COLUMN_ADDR, END_COLUMN_ADDR, 0, SSD1306_DIS_NORMAL, // 0xA6
// 0x22 = Set Page Address 1, SSD1306_SET_OSC_FREQ, 0x80, // 0xD5
// ----------------------------------- 1, SSD1306_SET_PRECHARGE, 0xc2, // 0xD9, 1st Period = higher value less blinking
// 0x00 - Start Column Address 1, SSD1306_VCOM_DESELECT, 0x20, // Set V COMH Deselect, reset value 0x22 = 0,77xUcc
// 0x07 - End Column Address 1, SSD1306_SET_CHAR_REG, 0x14, // 0x8D
2, SSD1306_SET_PAGE_ADDR, START_PAGE_ADDR, END_PAGE_ADDR, 0, SSD1306_DISPLAY_ON // 0xAF = Set Display ON
// 0x40
0, SSD1306_SET_START_LINE,
// 0xD3
1, SSD1306_DISPLAY_OFFSET, 0x00,
// 0xA0 / remap 0xA1
0, SSD1306_SEG_REMAP_OP,
// 0xC0 / remap 0xC8
0, SSD1306_COM_SCAN_DIR_OP,
// 0xDA
1, SSD1306_COM_PIN_CONF, 0x12,
// 0x81
1, SSD1306_SET_CONTRAST, 0x7F,
// 0xA4
0, SSD1306_DIS_ENT_DISP_ON,
// 0xA6
0, SSD1306_DIS_NORMAL,
// 0xD5
1, SSD1306_SET_OSC_FREQ, 0x80,
// 0xD9, 1st Period = higher value less blinking
1, SSD1306_SET_PRECHARGE, 0xc2,
// Set V COMH Deselect, reset value 0x22 = 0,77xUcc
1, SSD1306_VCOM_DESELECT, 0x20,
// 0x8D
1, SSD1306_SET_CHAR_REG, 0x14,
// 0xAF = Set Display ON
0, SSD1306_DISPLAY_ON
}; };
// @var array Chache memory Lcd 8 * 128 = 1024 // @var array Chache memory Lcd 8 * 128 = 1024
@ -160,69 +135,50 @@ static char cacheMemLcd[CACHE_SIZE_MEM];
* @return uint8_t * @return uint8_t
*/ */
uint8_t SSD1306_Init (uint8_t address) uint8_t SSD1306_Init (uint8_t address)
{ {
// variables const uint8_t *commands = INIT_SSD1306; // variables
const uint8_t *commands = INIT_SSD1306; unsigned short int no_of_commands = pgm_read_byte(commands++); // number of commands
// number of commands uint8_t no_of_arguments; // number od arguments
unsigned short int no_of_commands = pgm_read_byte(commands++); uint8_t command; // command
// argument uint8_t status = INIT_STATUS; // TWI init status 0xFF
uint8_t no_of_arguments;
// command
uint8_t command;
// init status
uint8_t status = INIT_STATUS;
// TWI: Init // TWI INIT
// ------------------------- // -------------------------------------------------------------------------------------
TWI_Init (); TWI_Init ();
// TWI: start & SLAW // TWI Start & SLAW
// ------------------------- // -------------------------------------------------------------------------------------
status = SSD1306_Send_StartAndSLAW (address); status = SSD1306_Send_StartAndSLAW (address); // start & SLAW
// request - start TWI if (SSD1306_SUCCESS != status) { // check status
if (SSD1306_SUCCESS != status) { return status; // error
// error
return status;
} }
// MAIN LOOP
// loop through commands // -------------------------------------------------------------------------------------
while (no_of_commands) { while (no_of_commands) { // commands loop
no_of_arguments = pgm_read_byte (commands++); // number of arguments
// number of arguments command = pgm_read_byte (commands++); // command
no_of_arguments = pgm_read_byte (commands++); // SEND COMMAND
// command // -----------------------------------------------------------------------------------
command = pgm_read_byte (commands++); status = SSD1306_Send_Command (command); // send command
if (SSD1306_SUCCESS != status) { // check status
// send command return status; // error
// -------------------------
status = SSD1306_Send_Command (command);
// request - start TWI
if (SSD1306_SUCCESS != status) {
// error
return status;
} }
// SEND ARGUMENTS
// send arguments // -----------------------------------------------------------------------------------
// -------------------------
while (no_of_arguments--) { while (no_of_arguments--) {
// send command status = SSD1306_Send_Command (pgm_read_byte(commands++)); // send argument
status = SSD1306_Send_Command (pgm_read_byte(commands++)); if (SSD1306_SUCCESS != status) { // check status
// request - start TWI return status; // error
if (SSD1306_SUCCESS != status) {
// error
return status;
} }
} }
// decrement
no_of_commands--;
}
// TWI: Stop no_of_commands--; // next command
// ------------------------- }
// TWI STOP
// -------------------------------------------------------------------------------------
TWI_Stop (); TWI_Stop ();
// success return SSD1306_SUCCESS; // success
return SSD1306_SUCCESS;
} }
/** /**
@ -234,29 +190,22 @@ uint8_t SSD1306_Init (uint8_t address)
*/ */
uint8_t SSD1306_Send_StartAndSLAW (uint8_t address) uint8_t SSD1306_Send_StartAndSLAW (uint8_t address)
{ {
// init status uint8_t status = INIT_STATUS; // TWI init status 0xFF
uint8_t status = INIT_STATUS;
// TWI: start // TWI START
// ------------------------- // -------------------------------------------------------------------------------------
status = TWI_MT_Start (); status = TWI_MT_Start (); // start
// request - start TWI if (SSD1306_SUCCESS != status) { // check status
if (SSD1306_SUCCESS != status) { return status; // error
// error
return status;
} }
// TWI start & SLAW
// TWI: send SLAW // -------------------------------------------------------------------------------------
// ------------------------- status = TWI_MT_Send_SLAW (address); // start & SLAW
status = TWI_MT_Send_SLAW (address); if (SSD1306_SUCCESS != status) { // check status
// request - send SLAW return status; // error
if (SSD1306_SUCCESS != status) {
// error
return status;
} }
// success return SSD1306_SUCCESS; // success
return SSD1306_SUCCESS;
} }
/** /**
@ -268,29 +217,22 @@ uint8_t SSD1306_Send_StartAndSLAW (uint8_t address)
*/ */
uint8_t SSD1306_Send_Command (uint8_t command) uint8_t SSD1306_Send_Command (uint8_t command)
{ {
// init status uint8_t status = INIT_STATUS; // TWI init status 0xFF
uint8_t status = INIT_STATUS;
// send control byte // TWI send control byte
// ------------------------- // -------------------------------------------------------------------------------------
status = TWI_MT_Send_Data (SSD1306_COMMAND); status = TWI_MT_Send_Data (SSD1306_COMMAND); // send control byte
// request - start TWI if (SSD1306_SUCCESS != status) { // check status
if (SSD1306_SUCCESS != status) { return status; // error
// error }
return status; // TWI send command
// -------------------------------------------------------------------------------------
status = TWI_MT_Send_Data (command); // send command
if (SSD1306_SUCCESS != status) { // check status
return status; // error
} }
// send command return SSD1306_SUCCESS; // success
// -------------------------
status = TWI_MT_Send_Data (command);
// request - start TWI
if (SSD1306_SUCCESS != status) {
// error
return status;
}
// success
return SSD1306_SUCCESS;
} }
/** /**
@ -302,29 +244,22 @@ uint8_t SSD1306_Send_Command (uint8_t command)
*/ */
uint8_t SSD1306_NormalScreen (uint8_t address) uint8_t SSD1306_NormalScreen (uint8_t address)
{ {
// init status uint8_t status = INIT_STATUS; // TWI init status 0xFF
uint8_t status = INIT_STATUS;
// TWI: start & SLAW // TWI start & SLAW
// ------------------------- // -------------------------------------------------------------------------------------
status = SSD1306_Send_StartAndSLAW (address); status = SSD1306_Send_StartAndSLAW (address); // start & SLAW
// request succesfull if (SSD1306_SUCCESS != status) { // check status
if (SSD1306_SUCCESS != status) { return status; // error
// error }
return status; // TWI send command
// -------------------------------------------------------------------------------------
status = SSD1306_Send_Command (SSD1306_DIS_NORMAL); // command 0xA6
if (SSD1306_SUCCESS != status) { // check status
return status; // error
} }
// send command return SSD1306_SUCCESS; // success
// -------------------------
status = SSD1306_Send_Command (SSD1306_DIS_NORMAL);
// request succesfull
if (SSD1306_SUCCESS != status) {
// error
return status;
}
// success
return SSD1306_SUCCESS;
} }
/** /**
@ -336,29 +271,22 @@ uint8_t SSD1306_NormalScreen (uint8_t address)
*/ */
uint8_t SSD1306_InverseScreen (uint8_t address) uint8_t SSD1306_InverseScreen (uint8_t address)
{ {
// init status
uint8_t status = INIT_STATUS; uint8_t status = INIT_STATUS;
// TWI: start & SLAW // TWI start & SLAW
// ------------------------- // -------------------------------------------------------------------------------------
status = SSD1306_Send_StartAndSLAW (address); status = SSD1306_Send_StartAndSLAW (address); // start & SLAW
// request succesfull if (SSD1306_SUCCESS != status) { // check status
if (SSD1306_SUCCESS != status) { return status; // error
// error }
return status; // TWI send command
// -------------------------------------------------------------------------------------
status = SSD1306_Send_Command (SSD1306_DIS_INVERSE); // command 0xA7
if (SSD1306_SUCCESS != status) { // check status
return status; // error
} }
// send command return SSD1306_SUCCESS; // success
// -------------------------
status = SSD1306_Send_Command (SSD1306_DIS_INVERSE);
// request succesfull
if (SSD1306_SUCCESS != status) {
// error
return status;
}
// success
return SSD1306_SUCCESS;
} }
/** /**
@ -370,48 +298,35 @@ uint8_t SSD1306_InverseScreen (uint8_t address)
*/ */
uint8_t SSD1306_UpdateScreen (uint8_t address) uint8_t SSD1306_UpdateScreen (uint8_t address)
{ {
// init status uint8_t status = INIT_STATUS; // TWI init status 0xFF
uint8_t status = INIT_STATUS; uint16_t i = 0; // counter
// init i
uint16_t i = 0; // TWI start & SLAW
// -------------------------------------------------------------------------------------
// TWI: start & SLAW status = SSD1306_Send_StartAndSLAW (address); // start & SLAW
// ------------------------- if (SSD1306_SUCCESS != status) { // check status
status = SSD1306_Send_StartAndSLAW (address); return status; // error
// request succesfull
if (SSD1306_SUCCESS != status) {
// error
return status;
} }
// TWI control byte data stream
// control byte data stream // -------------------------------------------------------------------------------------
// ------------------------- status = TWI_MT_Send_Data (SSD1306_DATA_STREAM); // send data 0x40
status = TWI_MT_Send_Data (SSD1306_DATA_STREAM); if (SSD1306_SUCCESS != status) { // check status
// request succesfull return status; // error
if (SSD1306_SUCCESS != status) {
// error
return status;
} }
// TWI send cache memory lcd
// send cache memory lcd // -------------------------------------------------------------------------------------
// -------------------------
while (i < CACHE_SIZE_MEM) { while (i < CACHE_SIZE_MEM) {
// send data status = TWI_MT_Send_Data (cacheMemLcd[i]); // send data
status = TWI_MT_Send_Data (cacheMemLcd[i]); if (SSD1306_SUCCESS != status) { // check status
// request succesfull return status; // error
if (SSD1306_SUCCESS != status) {
// error
return status;
} }
// increment i++; // next value
i++;
} }
// TWI stop
// stop TWI // -------------------------------------------------------------------------------------
TWI_Stop (); TWI_Stop ();
// success return SSD1306_SUCCESS; // success
return SSD1306_SUCCESS;
} }
/** /**
@ -423,55 +338,45 @@ uint8_t SSD1306_UpdateScreen (uint8_t address)
*/ */
void SSD1306_ClearScreen (void) void SSD1306_ClearScreen (void)
{ {
// null cache memory lcd memset (cacheMemLcd, 0x00, CACHE_SIZE_MEM); // null cache memory lcd
memset (cacheMemLcd, 0x00, CACHE_SIZE_MEM);
} }
/** /**
* @desc SSD1306 Set position * @desc SSD1306 Set position
* *
* @param uint8_t column -> 0 ... 127 * @param uint8_t column -> 0 ... 127
* @param uint8_t page -> 0 ... 7 * @param uint8_t page -> 0 ... 7
* *
* @return void * @return void
*/ */
void SSD1306_SetPosition (uint8_t x, uint8_t y) void SSD1306_SetPosition (uint8_t x, uint8_t y)
{ {
// calculate counter _counter = x + (y << 7); // calculate counter
_counter = x + (y << 7);
} }
/** /**
* @desc SSD1306 Update text poisition - this ensure that character will not be divided at the end of row, the whole character will be depicted on the new row * @desc SSD1306 Update text poisition - this ensure that character will not be
* divided at the end of row, the whole character will be depicted on the new row
* *
* @param void * @param void
* *
* @return uint8_t * @return uint8_t
*/ */
uint8_t SSD1306_UpdTxtPosition (void) uint8_t SSD1306_UpdTxtPosition (void)
{ {
// y / 8 uint8_t y = _counter >> 7; // y / 8
uint8_t y = _counter >> 7; uint8_t x = _counter - (y << 7); // y % 8
// y % 8 uint8_t x_new = x + CHARS_COLS_LENGTH + 1; // x + character length + 1
uint8_t x = _counter - (y << 7);
// x + character length + 1 if (x_new > END_COLUMN_ADDR) { // check position
uint8_t x_new = x + CHARS_COLS_LENGTH + 1; if (y > END_PAGE_ADDR) { // if more than allowable number of pages
return SSD1306_ERROR; // return out of range
// check position } else if (y < (END_PAGE_ADDR-1)) { // if x reach the end but page in range
if (x_new > END_COLUMN_ADDR) { _counter = ((++y) << 7); // update
// if more than allowable number of pages
if (y > END_PAGE_ADDR) {
// return out of range
return SSD1306_ERROR;
// if x reach the end but page in range
} else if (y < (END_PAGE_ADDR-1)) {
// update
_counter = ((++y) << 7);
} }
} }
// success return SSD1306_SUCCESS; // success
return SSD1306_SUCCESS;
} }
/** /**
@ -481,29 +386,21 @@ uint8_t SSD1306_UpdTxtPosition (void)
* *
* @return uint8_t * @return uint8_t
*/ */
uint8_t SSD1306_DrawChar (char character) uint8_t SSD1306_DrawChar (char ch)
{ {
// variables
uint8_t i = 0; uint8_t i = 0;
// update text position // update text position
// this ensure that character will not be divided at the end of row, the whole character will be depicted on the new row // this ensure that character will not be divided at the end of row, the whole character will be depicted on the new row
if (SSD1306_UpdTxtPosition () == SSD1306_ERROR) { if (SSD1306_UpdTxtPosition () == SSD1306_ERROR) {
// error return SSD1306_ERROR; // error
return SSD1306_ERROR;
} }
while (i < CHARS_COLS_LENGTH) { // loop through 5 bits
// loop through 5 bits cacheMemLcd[_counter++] = pgm_read_byte(&FONTS[ch-32][i++]); // read byte
while (i < CHARS_COLS_LENGTH) {
// read byte
cacheMemLcd[_counter++] = pgm_read_byte(&FONTS[character-32][i++]);
} }
_counter++; // update position
// update position
_counter++; return SSD1306_SUCCESS; // success
// success
return SSD1306_SUCCESS;
} }
/** /**
@ -511,16 +408,14 @@ uint8_t SSD1306_DrawChar (char character)
* *
* @param char * string * @param char * string
* *
* @return void * @return uint8_t
*/ */
void SSD1306_DrawString (char *str) void SSD1306_DrawString (char *str)
{ {
// init int i = 0; // init
int i = 0;
// loop through character of string while (str[i] != '\0') { // loop through character of string
while (str[i] != '\0') { SSD1306_DrawChar (str[i++]); // draw string
// draw string
SSD1306_DrawChar (str[i++]);
} }
} }
@ -537,109 +432,74 @@ uint8_t SSD1306_DrawPixel (uint8_t x, uint8_t y)
uint8_t page = 0; uint8_t page = 0;
uint8_t pixel = 0; uint8_t pixel = 0;
// if out of range if ((x > MAX_X) && (y > MAX_Y)) { // if out of range
if ((x > MAX_X) && (y > MAX_Y)) { return SSD1306_ERROR; // out of range
// out of range
return SSD1306_ERROR;
} }
// find page (y / 8) page = y >> 3; // find page (y / 8)
page = y >> 3; pixel = 1 << (y - (page << 3)); // which pixel (y % 8)
// which pixel (y % 8) _counter = x + (page << 7); // update counter
pixel = 1 << (y - (page << 3)); cacheMemLcd[_counter++] |= pixel; // save pixel
// update counter
_counter = x + (page << 7); return SSD1306_SUCCESS; // success
// save pixel
cacheMemLcd[_counter++] |= pixel;
// success
return SSD1306_SUCCESS;
} }
/** /**
* @desc Draw line by Bresenham algoritm * @desc Draw line by Bresenham algoritm
* *
* @param uint8_t x start position / 0 <= cols <= MAX_X-1 * @param uint8_t x start position / 0 <= cols <= MAX_X-1
* @param uint8_t x end position / 0 <= cols <= MAX_X-1 * @param uint8_t x end position / 0 <= cols <= MAX_X-1
* @param uint8_t y start position / 0 <= rows <= MAX_Y-1 * @param uint8_t y start position / 0 <= rows <= MAX_Y-1
* @param uint8_t y end position / 0 <= rows <= MAX_Y-1 * @param uint8_t y end position / 0 <= rows <= MAX_Y-1
* *
* @return uint8_t * @return uint8_t
*/ */
uint8_t SSD1306_DrawLine (uint8_t x1, uint8_t x2, uint8_t y1, uint8_t y2) uint8_t SSD1306_DrawLine (uint8_t x1, uint8_t x2, uint8_t y1, uint8_t y2)
{ {
// determinant int16_t D; // determinant
int16_t D; int16_t delta_x, delta_y; // deltas
// deltas int16_t trace_x = 1, trace_y = 1; // steps
int16_t delta_x, delta_y;
// steps
int16_t trace_x = 1, trace_y = 1;
// delta x delta_x = x2 - x1; // delta x
delta_x = x2 - x1; delta_y = y2 - y1; // delta y
// delta y
delta_y = y2 - y1;
// check if x2 > x1 if (delta_x < 0) { // check if x2 > x1
if (delta_x < 0) { delta_x = -delta_x; // negate delta x
// negate delta x trace_x = -trace_x; // negate step x
delta_x = -delta_x;
// negate step x
trace_x = -trace_x;
} }
// check if y2 > y1 if (delta_y < 0) { // check if y2 > y1
if (delta_y < 0) { delta_y = -delta_y; // negate delta y
// negate detla y trace_y = -trace_y; // negate step y
delta_y = -delta_y;
// negate step y
trace_y = -trace_y;
} }
// condition for m < 1 (dy < dx)
// Bresenham condition for m < 1 (dy < dx) // -------------------------------------------------------------------------------------
if (delta_y < delta_x) { if (delta_y < delta_x) { //
// calculate determinant D = (delta_y << 1) - delta_x; // calculate determinant
D = (delta_y << 1) - delta_x; SSD1306_DrawPixel (x1, y1); // draw first pixel
// draw first pixel while (x1 != x2) { // check if x1 equal x2
SSD1306_DrawPixel (x1, y1); x1 += trace_x; // update x1
// check if x1 equal x2 if (D >= 0) { // positive?
while (x1 != x2) { y1 += trace_y; // update y1
// update x1 D -= 2*delta_x; // update determinant
x1 += trace_x;
// check if determinant is positive
if (D >= 0) {
// update y1
y1 += trace_y;
// update determinant
D -= 2*delta_x;
} }
// update deteminant D += 2*delta_y; // update deteminant
D += 2*delta_y; SSD1306_DrawPixel (x1, y1); // draw next pixel
// draw next pixel
SSD1306_DrawPixel (x1, y1);
} }
// for m > 1 (dy > dx) // condition for m >= 1 (dy >= dx)
// -------------------------------------------------------------------------------------
} else { } else {
// calculate determinant D = delta_y - (delta_x << 1); // calculate determinant
D = delta_y - (delta_x << 1); SSD1306_DrawPixel (x1, y1); // draw first pixel
// draw first pixel while (y1 != y2) { // check if y2 equal y1
SSD1306_DrawPixel (x1, y1); y1 += trace_y; // update y1
// check if y2 equal y1 if (D <= 0) { // positive?
while (y1 != y2) { x1 += trace_x; // update y1
// update y1 D += 2*delta_y; // update determinant
y1 += trace_y;
// check if determinant is positive
if (D <= 0) {
// update y1
x1 += trace_x;
// update determinant
D += 2*delta_y;
} }
// update deteminant D -= 2*delta_x; // update deteminant
D -= 2*delta_x; SSD1306_DrawPixel (x1, y1); // draw next pixel
// draw next pixel
SSD1306_DrawPixel (x1, y1);
} }
} }
// success return
return SSD1306_SUCCESS; return SSD1306_SUCCESS; // success return
} }

25
lib/ssd1306.h
View File

@ -23,11 +23,14 @@
#ifndef __SSD1306_H__ #ifndef __SSD1306_H__
#define __SSD1306_H__ #define __SSD1306_H__
<<<<<<< HEAD
// include libraries // include libraries
#include <string.h> #include <string.h>
#include "font.h" #include "font.h"
#include "twi.h" #include "twi.h"
=======
>>>>>>> origin/develop
// Success // Success
// ------------------------------------------- // -------------------------------------------
#define SSD1306_SUCCESS 0 #define SSD1306_SUCCESS 0
@ -108,6 +111,7 @@
* @desc SSD1306 Send Start and SLAW request * @desc SSD1306 Send Start and SLAW request
* *
* @param uint8_t * @param uint8_t
<<<<<<< HEAD
* *
* @return uint8_t * @return uint8_t
*/ */
@ -127,6 +131,27 @@
* *
* @param void * @param void
* *
=======
*
* @return uint8_t
*/
uint8_t SSD1306_Send_StartAndSLAW (uint8_t);
/**
* @desc SSD1306 Send command
*
* @param uint8_t
*
* @return uint8_t
*/
uint8_t SSD1306_Send_Command (uint8_t);
/**
* @desc SSD1306 Clear screen
*
* @param void
*
>>>>>>> origin/develop
* @return void * @return void
*/ */
void SSD1306_ClearScreen (void); void SSD1306_ClearScreen (void);

44
lib/twi.c
View File

@ -1,18 +1,22 @@
/** /**
* ---------------------------------------------------+ * ---------------------------------------------------------------+
* @desc Two Wire Interface / I2C Communication * @desc Two Wire Interface / I2C Communication
* ---------------------------------------------------+ * ---------------------------------------------------------------+
* Copyright (C) 2020 Marian Hrinko. * Copyright (C) 2020 Marian Hrinko.
* Written by Marian Hrinko (mato.hrinko@gmail.com) * Written by Marian Hrinko (mato.hrinko@gmail.com)
* *
* @author Marian Hrinko * @author Marian Hrinko
* @datum 06.09.2020 * @datum 06.09.2020
* @file twi.c * @file twi.c
* @tested AVR Atmega16 * @tested AVR Atmega16, ATmega8, Atmega328
* --------------------------------------------------- *
* @depend
* ---------------------------------------------------------------+
* @usage Master Transmit Operation
*/ */
// include libraries // include libraries
#include <avr/io.h>
#include "twi.h" #include "twi.h"
/** /**
@ -22,7 +26,7 @@
* *
* @return void * @return void
*/ */
void TWI_Init(void) void TWI_Init (void)
{ {
// +++++++++++++++++++++++++++++++++++++++++++++ // +++++++++++++++++++++++++++++++++++++++++++++
// Calculation fclk: // Calculation fclk:
@ -34,10 +38,10 @@ void TWI_Init(void)
// TWBR = {(fcpu/fclk) - 16 } / (2*4^Prescaler) // TWBR = {(fcpu/fclk) - 16 } / (2*4^Prescaler)
// +++++++++++++++++++++++++++++++++++++++++++++ // +++++++++++++++++++++++++++++++++++++++++++++
// @param1 value of TWBR, // @param1 value of TWBR,
// fclk = 400 kHz; TWBR = 3 // fclk = 400kHz (m16); TWBR = 3
// fclk = 100 kHz; TWBR = 20 // fclk = 100kHz (m16); TWBR = 20
// @param2 value of Prescaler = 1 // @param2 value of Prescaler = 1
TWI_FREQ(20, 1); TWI_FREQ (3, 1);
} }
/** /**
@ -47,7 +51,7 @@ void TWI_Init(void)
* *
* @return char * @return char
*/ */
char TWI_MT_Start(void) char TWI_MT_Start (void)
{ {
// null status flag // null status flag
TWI_TWSR &= ~0xA8; TWI_TWSR &= ~0xA8;
@ -73,7 +77,7 @@ char TWI_MT_Start(void)
* *
* @return char * @return char
*/ */
char TWI_MT_Send_SLAW(char address) char TWI_MT_Send_SLAW (char address)
{ {
// SLA+W // SLA+W
// ---------------------------------------------- // ----------------------------------------------
@ -83,12 +87,12 @@ char TWI_MT_Send_SLAW(char address)
// wait till flag set // wait till flag set
TWI_WAIT_TILL_TWINT_IS_SET(); TWI_WAIT_TILL_TWINT_IS_SET();
// find // test if SLA with WRITE acknowledged
if (TWI_STATUS != TWI_MT_SLAW_ACK) { if (TWI_STATUS != TWI_MT_SLAW_ACK) {
// return status // return status
return TWI_STATUS; return TWI_STATUS;
} }
// return found device address // success
return SUCCESS; return SUCCESS;
} }
@ -99,7 +103,7 @@ char TWI_MT_Send_SLAW(char address)
* *
* @return char * @return char
*/ */
char TWI_MT_Send_Data(char data) char TWI_MT_Send_Data (char data)
{ {
// DATA // DATA
// ---------------------------------------------- // ----------------------------------------------
@ -109,12 +113,12 @@ char TWI_MT_Send_Data(char data)
// wait till flag set // wait till flag set
TWI_WAIT_TILL_TWINT_IS_SET(); TWI_WAIT_TILL_TWINT_IS_SET();
// find // test if data acknowledged
if (TWI_STATUS != TWI_MT_DATA_ACK) { if (TWI_STATUS != TWI_MT_DATA_ACK) {
// return status // return status
return TWI_STATUS; return TWI_STATUS;
} }
// return found device address // success
return SUCCESS; return SUCCESS;
} }
@ -125,7 +129,7 @@ char TWI_MT_Send_Data(char data)
* *
* @return char * @return char
*/ */
char TWI_MR_Send_SLAR(char address) char TWI_MR_Send_SLAR (char address)
{ {
// SLA+R // SLA+R
// ---------------------------------------------- // ----------------------------------------------
@ -135,12 +139,12 @@ char TWI_MR_Send_SLAR(char address)
// wait till flag set // wait till flag set
TWI_WAIT_TILL_TWINT_IS_SET(); TWI_WAIT_TILL_TWINT_IS_SET();
// find // test if SLA with READ acknowledged
if (TWI_STATUS != TWI_MR_SLAR_ACK) { if (TWI_STATUS != TWI_MR_SLAR_ACK) {
// return status // return status
return TWI_STATUS; return TWI_STATUS;
} }
// return found device address // success
return SUCCESS; return SUCCESS;
} }
@ -151,12 +155,12 @@ char TWI_MR_Send_SLAR(char address)
* *
* @return void * @return void
*/ */
void TWI_Stop(void) void TWI_Stop (void)
{ {
// End TWI // End TWI
// ------------------------------------------------- // -------------------------------------------------
// send stop sequence // send stop sequence
TWI_STOP(); TWI_STOP ();
// wait for TWINT flag is set // wait for TWINT flag is set
// TWI_WAIT_TILL_TWINT_IS_SET(); // TWI_WAIT_TILL_TWINT_IS_SET();
} }

112
lib/twi.h
View File

@ -1,69 +1,46 @@
/** /**
* ---------------------------------------------------+ * ---------------------------------------------------------------+
* @desc Two Wire Interface / I2C Communication * @desc Two Wire Interface / I2C Communication
* ---------------------------------------------------+ * ---------------------------------------------------------------+
* Copyright (C) 2020 Marian Hrinko. * Copyright (C) 2020 Marian Hrinko.
* Written by Marian Hrinko (mato.hrinko@gmail.com) * Written by Marian Hrinko (mato.hrinko@gmail.com)
* *
* @author Marian Hrinko * @author Marian Hrinko
* @datum 06.09.2020 * @datum 06.09.2020
* @file twi.h * @file twi.h
* @tested AVR Atmega16 * @tested AVR Atmega16, ATmega8, Atmega328
* --------------------------------------------------- *
* @depend
* ---------------------------------------------------------------+
* @usage Basic Master Transmit Operation
*/ */
#include <stdio.h>
#include <avr/io.h>
#ifndef __TWI_H__ #ifndef __TWI_H__
#define __TWI_H__ #define __TWI_H__
// define register for TWI communication // define register for TWI communication
// -------------------------------------------
#if defined(__AVR_ATmega16__) || defined(__AVR_ATmega8__) || defined(__AVR_ATmega328P__) #if defined(__AVR_ATmega16__) || defined(__AVR_ATmega8__) || defined(__AVR_ATmega328P__)
#define TWI_TWAR TWAR // TWI (Slave) Address Register
#define TWI_TWBR TWBR // TWI Bit Rate Register #define TWI_TWAR TWAR // TWI (Slave) Address Register
#define TWI_TWDR TWDR // TWI Data Register #define TWI_TWBR TWBR // TWI Bit Rate Register
#define TWI_TWCR TWCR // TWI Control Register #define TWI_TWDR TWDR // TWI Data Register
#define TWI_TWSR TWSR // TWI Status Register #define TWI_TWCR TWCR // TWI Control Register
#define TWI_TWSR TWSR // TWI Status Register
#endif #endif
// TWI CLK frequency // Success
// @param TWBR // -------------------------------------------
// @param Prescaler #ifndef SUCCESS
// TWPS1 TWPS0 - PRESCALER #define SUCCESS 0
// 0 0 - 1 #endif
// 0 1 - 4
// 1 0 - 16
// 1 1 - 64
#define TWI_FREQ(BIT_RATE, PRESCALER) { TWI_TWBR = BIT_RATE; TWI_TWSR |= (TWI_TWSR & 0x03) | PRESCALER; }
// TWI start condition // Error
// (1 << TWEN) - TWI Enable // -------------------------------------------
// (1 << TWINT) - TWI Interrupt Flag - must be cleared by set #ifndef ERROR
// (1 << TWSTA) - TWI Start #define ERROR 1
#define TWI_START() { TWI_TWCR = (1 << TWEN) | (1 << TWINT) | (1 << TWSTA); } #endif
// TWI enable
// (1 << TWEN) - TWI Enable
// (1 << TWINT) - TWI Interrupt Flag - must be cleared by set
#define TWI_ENABLE() { TWI_TWCR = (1 << TWEN) | (1 << TWINT); }
// TWI stop condition
// (1 << TWEN) - TWI Enable
// (1 << TWINT) - TWI Interrupt Flag - must be cleared by set
// (1 << TWSTO) - TWI Stop
#define TWI_STOP() { TWI_TWCR = (1 << TWEN) | (1 << TWINT) | (1 << TWSTO); }
// TWI test if TWINT Flag is set
#define TWI_WAIT_TILL_TWINT_IS_SET() { while (!(TWI_TWCR & (1 << TWINT))); }
// TWI status mask
#define TWI_STATUS (TWI_TWSR & 0xF8)
// success return value
#define SUCCESS 0
// success return value
#define ERROR 1
// ++++++++++++++++++++++++++++++++++++++++++ // ++++++++++++++++++++++++++++++++++++++++++
// //
@ -106,9 +83,46 @@
#define TWI_ST_DATA_ACK 0xB8 // Data byte in TWDR has been transmitted; ACK has been received #define TWI_ST_DATA_ACK 0xB8 // Data byte in TWDR has been transmitted; ACK has been received
#define TWI_ST_DATA_NACK 0xC0 // Data byte in TWDR has been transmitted; NOT ACK has been received #define TWI_ST_DATA_NACK 0xC0 // Data byte in TWDR has been transmitted; NOT ACK has been received
#define TWI_ST_DATA_LOST_ACK 0xC8 // Last data byte in TWDR has been transmitted (TWEA = '0'); ACK has been received #define TWI_ST_DATA_LOST_ACK 0xC8 // Last data byte in TWDR has been transmitted (TWEA = '0'); ACK has been received
// TWI CLK frequency
// -------------------------------------------
// @param TWBR
// @param Prescaler
// TWPS1 TWPS0 - PRESCALER
// 0 0 - 1
// 0 1 - 4
// 1 0 - 16
// 1 1 - 64
#define TWI_FREQ(BIT_RATE, PRESCALER) { TWI_TWBR = BIT_RATE; TWI_TWSR |= (TWI_TWSR & 0x03) | PRESCALER; }
// TWI start condition
// -------------------------------------------
// (1 << TWEN) - TWI Enable
// (1 << TWINT) - TWI Interrupt Flag - must be cleared by set
// (1 << TWSTA) - TWI Start
#define TWI_START() { TWI_TWCR = (1 << TWEN) | (1 << TWINT) | (1 << TWSTA); }
// TWI stop condition
// -------------------------------------------
// (1 << TWEN) - TWI Enable
// (1 << TWINT) - TWI Interrupt Flag - must be cleared by set
// (1 << TWSTO) - TWI Stop
#define TWI_STOP() { TWI_TWCR = (1 << TWEN) | (1 << TWINT) | (1 << TWSTO); }
// TWI enable
// -------------------------------------------
// (1 << TWEN) - TWI Enable
// (1 << TWINT) - TWI Interrupt Flag - must be cleared by set
#define TWI_ENABLE() { TWI_TWCR = (1 << TWEN) | (1 << TWINT); }
// TWI test if TWINT Flag is set
#define TWI_WAIT_TILL_TWINT_IS_SET() { while (!(TWI_TWCR & (1 << TWINT))); }
// TWI status mask
#define TWI_STATUS ( TWI_TWSR & 0xF8 )
/** /**
* @desc TWI init - initialise communication * @desc TWI init
* *
* @param void * @param void
* *

112
main.hex
View File

@ -1,112 +0,0 @@
:100000000C943D010C945A010C945A010C945A0121
:100010000C945A010C945A010C945A010C945A01F4
:100020000C945A010C945A010C945A010C945A01E4
:100030000C945A010C945A010C945A010C945A01D4
:100040000C945A010C945A010C945A010C945A01C4
:100050000C945A010C945A010C945A010C945A01B4
:100060000C945A010C945A01000000000081811880
:1000700081810007000700147F147F14242A7F2A3F
:10008000122313086462364955225000050300000C
:10009000001C2241000041221C0014083E081408E4
:1000A000083E0808005030000008080808080060F2
:1000B00060000020100804023E5149453E00427F86
:1000C000400042615149462141454B311814127F8D
:1000D0001027454545393C4A494930017109050316
:1000E0003649494936064949291E0036360000007E
:1000F0005636000008142241001414141414004150
:100100002214080201510906324979413E7E11113B
:10011000117E7F494949363E414141227F4141227A
:100120001C7F494949417F090909013E4149497AF2
:100130007F0808087F00417F41002040413F017F48
:10014000081422417F404040407F020C027F7F0420
:1001500008107F3E4141413E7F090909063E415159
:10016000215E7F09192946464949493101017F012C
:10017000013F4040403F1F2040201F3F4038403F4C
:100180006314081463070870080761514945430068
:100190007F41410002040810200041417F00040219
:1001A0000102044040404040000102040020545439
:1001B00054787F48444438384444442038444448C0
:1001C0007F3854545418087E0901020C5252523E92
:1001D0007F0804047800447D40002040443D007FB7
:1001E0001028440000417F40007C041804787C08FB
:1001F00004047838444444387C1414140808141453
:10020000147C7C080404084854545420043F44409F
:10021000203C4040207C1C2040201C3C4030403C86
:1002200044281028440C5050503C4464544C440022
:100230000836410000007F00000041360800100829
:1002400008100800000000001200AE01A83F0120C5
:10025000000221007F02220007004001D30000A11C
:1002600000C801DA1201817F00A400A601D5800137
:10027000D9C201DB20018D1400AF11241FBECFEFC6
:10028000D8E0DEBFCDBF11E0A0E0B1E0EEECF6E0DB
:1002900002C005900D92A431B107D9F725E0A4E181
:1002A000B1E001C01D92A631B207E1F70E944203FE
:1002B0000C9465030C94000084E18093B800E9EB92
:1002C000F0E08081908182708160892B8083089525
:1002D0008091B90087758093B90084EA8093BC004F
:1002E0008091BC0087FFFCCF8091B900887F883067
:1002F00049F08091B900887F803121F08091B90068
:10030000887F089580E00895880F8093BB0084E87B
:100310008093BC008091BC0087FFFCCF8091B90026
:10032000887F883121F08091B900887F089580E02E
:1003300008958093BB0084E88093BC008091BC004A
:1003400087FFFCCF8091B900887F883221F08091AF
:10035000B900887F089580E00895880F990B816027
:100360008093BB0084E88093BC008091BC0087FF31
:10037000FCCF8091B900887F803421F08091B90052
:10038000887F089580E0089584E98093BC000895F3
:10039000CF93C82F0E946801811104C08C2FCF9188
:1003A0000C948401CF910895CF93C82F80E80E94C8
:1003B0009901811104C08C2FCF910C949901CF9198
:1003C0000895FF920F931F93CF93DF93D82FE8E404
:1003D000F2E0C4910E945C018D2F0E94C80181113E
:1003E0001FC0D0E0E9E4F2E02097B9F0F4908F016B
:1003F0000E5F1F4F319684910E94D401811110C06D
:10040000F801FF2041F0F80184910E94D401FA9490
:100410000F5F1F4FF3CF2197E7CF0E94C40180E009
:10042000DF91CF911F910F91FF9008950E94C80115
:10043000811103C086EA0C94D40108950E94C8017A
:10044000811103C087EA0C94D4010895CF93DF9300
:100450000E94C801811113C080E40E94990181119A
:100460000EC0C4E1D1E089910E949901811107C0B9
:1004700085E0C431D807B9F70E94C40180E0DF915C
:10048000CF91089580E094E0E4E1F1E0DF019C0188
:100490001D9221503040E1F7089590E020E8629FDE
:1004A000800D911D112490931505809314050895D6
:1004B0002091140530911505C901880F892F881FD7
:1004C000990B91952A5F482F479544274795241B00
:1004D00027FF10C0883060F4863060F48F5F20E81A
:1004E000829FC0011124909315058093140502C0CA
:1004F00081E0089580E00895CF93C82F0E945802AC
:10050000813011F12091140530911505D901AC5EAF
:10051000BE4F45E0C402C001112440E050E0805AC3
:100520009109FC01E40FF51FE859FF4FE491ED93A9
:100530004F5F5F4F45305105A1F72A5F3F4F309322
:1005400015052093140580E0CF910895CF93DF9394
:10055000EC018991882319F00E947C02FACFDF9187
:10056000CF91089587FF02C0613420F5262F26958C
:100570002695269530E0F901F695FE2FEE27F795A2
:10058000E795E80FF11DCF01019690931505809333
:100590001405EC5EFE4F88E0289F6019112481E06D
:1005A00090E001C0880F6A95EAF79081892B8083DB
:1005B00080E0089581E008958F929F92AF92BF925C
:1005C000CF92DF92EF92FF920F931F93CF93DF931F
:1005D000082FA62E142FB22E262F30E0281B31090B
:1005E0008B2D90E0841B910937FF06C03195219532
:1005F000310999249A9402C09924939497FF06C0D4
:1006000091958195910988248A9402C088248394C5
:100610007C01EE0CFF1C6901CC0CDD1C82179307DA
:1006200094F4E701C21BD30B612F802F0E94B2020A
:100630000A15D1F0090DD7FD03C0180DCC19DD093D
:10064000CE0DDF1DF1CFEC01CC19DD09612F802F1C
:100650000E94B2021B1541F0180D1C161D06A4F3D2
:10066000090DCE0DDF1DF0CF80E0DF91CF911F91FE
:100670000F91FF90EF90DF90CF90BF90AF909F9041
:100680008F9008958CE30E94E1010E94420224E0D1
:1006900044E06FE780E00E94DC0261E087E00E94B6
:1006A0004D0280E091E00E94A60222E142E16FE764
:1006B00080E00E94DC0263E088E20E944D028CE34D
:0E06C0000E94260280E090E00895F894FFCF9B
:1006CE0053534431333036204F4C45442044524925
:0406DE00564552002B
:00000001FF