Kacper/eink-linux-pda
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

first commit

Browse source
This commit is contained in:
KacperLa 2026-01-15 10:21:39 -05:00
commit 9005e49d82
3071 changed files with 1941927 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

392
e-Paper/Arduino/epd4in2b_V2/epd4in2b_V2.cpp Normal file
View file

@ -0,0 +1,392 @@
/**
* @filename : epd4in2b_V2.cpp
* @brief : Implements for Dual-color e-paper library
* @author : Yehui from Waveshare
*
* Copyright (C) Waveshare Nov 25 2020
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documnetation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdlib.h>
#include "epd4in2b_V2.h"
Epd::~Epd() {
};
Epd::Epd() {
flag=0;
reset_pin = RST_PIN;
dc_pin = DC_PIN;
cs_pin = CS_PIN;
busy_pin = BUSY_PIN;
width = EPD_WIDTH;
height = EPD_HEIGHT;
};
int Epd::Init_old(void) {
Reset();
SendCommand(0x04);
ReadBusy();
SendCommand(0x00);
SendData(0x0F); // LUT from OTP
// /* EPD hardware init end */
return 0;
}
int Epd::Init_new(void) {
Reset();
ReadBusy();
SendCommand(0x12);
ReadBusy();
SendCommand(0x3C); //BorderWavefrom
SendData(0x05);
SendCommand(0x18); //Read built-in temperature sensor
SendData(0x80);
SendCommand(0x11); //data entry mode
SendData(0x03);
SendCommand(0x44); //set Ram-X address start/end position
SendData(0x00);
SendData(width/8-1);
SendCommand(0x45); //set Ram-Y address start/end position
SendData(0x00);
SendData(0x00);
SendData((height-1)%256);
SendData((height-1)/256);
SendCommand(0x4E); // set RAM x address count to 0;
SendData(0x00);
SendCommand(0x4F); // set RAM y address count to 0X199;
SendData(0x00);
SendData(0x00);
ReadBusy();
return 0;
}
int Epd::Init(void) {
unsigned char i=0;
/* this calls the peripheral hardware interface, see epdif */
if (IfInit() != 0) {
return -1;
}
/* EPD hardware init start */
Reset();
EPD_GPIO_Init();
digitalWrite(dc_pin, 0);
EPD_SendData(0x2F);
DelayMs(50);
digitalWrite(dc_pin, 1);
i = EPD_ReadData();
printf("%02x\n",i);
EPD_SPI_Init();
if(i == 0x01)
{
flag = 0;
Init_new();
}
else
{
flag = 1;
Init_old();
}
// /* EPD hardware init end */
return 0;
}
/**
* @brief: basic function for sending commands
*/
void Epd::SendCommand(unsigned char command) {
DigitalWrite(dc_pin, LOW);
SpiTransfer(command);
}
/**
* @brief: basic function for sending data
*/
void Epd::SendData(unsigned char data) {
DigitalWrite(dc_pin, HIGH);
SpiTransfer(data);
}
/**
* @brief: Wait until the busy_pin goes HIGH
*/
void Epd::ReadBusy(void) {
if(flag == 0)
{
while(DigitalRead(busy_pin) == 1) {
DelayMs(100);
}
}
else
{
while(DigitalRead(busy_pin) == 0) {
DelayMs(100);
}
}
}
/**
* @brief: module reset.
* often used to awaken the module in deep sleep,
* see Epd::Sleep();
*/
void Epd::Reset(void) {
DigitalWrite(reset_pin, HIGH);
DelayMs(200);
DigitalWrite(reset_pin, LOW);
DelayMs(2);
DigitalWrite(reset_pin, HIGH);
DelayMs(200);
}
/**
* @brief: transmit partial data to the black part of SRAM
*/
void Epd::Display_Window_Black(const UBYTE *image, UBYTE count) {
UBYTE k;
if(count == 0 && flag == 0)
SendCommand(0x24);
else if(count == 0)
SendCommand(0x10);
for (UWORD j = 0; j < 100; j++) {
for (UWORD i = 0; i < 50; i++) {
if(i<16)
{
SendData(image[i + (j*16)]);
}
else
{
SendData(0xFF);
}
}
}
}
/**
* @brief: transmit partial data to the red part of SRAM
*/
void Epd::Display_Window_Red_new(const UBYTE *image, UBYTE count) {
UBYTE k;
if(count == 0)
SendCommand(0x26);
for (UWORD j = 0; j < 100; j++) {
for (UWORD i = 0; i < 50; i++) {
if(i<16)
{
SendData(~image[i + (j*16)]);
}
else
{
SendData(0x00);
}
}
}
}
void Epd::Display_Window_Red_old(const UBYTE *image, UBYTE count) {
UBYTE k;
if(count == 0)
SendCommand(0x13);
for (UWORD j = 0; j < 100; j++) {
for (UWORD i = 0; i < 50; i++) {
if(i<16)
{
SendData(image[i + (j*16)]);
}
else
{
SendData(0xFF);
}
}
}
}
void Epd::Display_Window_Red(const UBYTE *image, UBYTE count) {
if(flag == 0)
Display_Window_Red_new(image, count);
else
Display_Window_Red_old(image, count);
}
void Epd::DisplayFrame(void) {
if(flag == 0)
{
SendCommand(0x22);
SendData(0xF7);
SendCommand(0x20);
ReadBusy();
}
else
{
SendCommand(0x12);
DelayMs(100);
ReadBusy();
}
}
/**
* @brief: refresh and displays the frame
*/
void Epd::Display_old(const UBYTE *blackimage, const UBYTE *ryimage) {
UBYTE k;
SendCommand(0x10);
for (UWORD j = 0; j < height; j++) {
for (UWORD i = 0; i < width/8; i++) {
SendData(pgm_read_byte(&blackimage[i + (j*width/8)]));
}
}
SendCommand(0x13);
for (UWORD j = 0; j < height; j++) {
for (UWORD i = 0; i < width/8; i++) {
SendData(pgm_read_byte(&ryimage[i + (j*width/8)]));
}
}
SendCommand(0x12);
DelayMs(100);
ReadBusy();
}
void Epd::Display_new(const UBYTE *blackimage, const UBYTE *ryimage) {
UBYTE k;
SendCommand(0x24);
for (UWORD j = 0; j < height; j++) {
for (UWORD i = 0; i < width/8; i++) {
SendData(pgm_read_byte(&blackimage[i + (j*width/8)]));
}
}
SendCommand(0x26);
for (UWORD j = 0; j < height; j++) {
for (UWORD i = 0; i < width/8; i++) {
k = pgm_read_byte(&ryimage[i + (j*width/8)]);
SendData(~k);
}
}
SendCommand(0x22);
SendData(0xF7);
SendCommand(0x20);
ReadBusy();
}
void Epd::Display(const UBYTE *blackimage, const UBYTE *ryimage) {
if(flag == 0)
Display_new(blackimage, ryimage);
else
Display_old(blackimage, ryimage);
}
/**
* @brief: clear the frame data from the SRAM, this won't refresh the display
*/
void Epd::Clear_new() {
//send black data
SendCommand(0x24);
for (UWORD j = 0; j < height; j++) {
for (UWORD i = 0; i < width/8; i++) {
SendData(0xff);
}
}
//send red data
SendCommand(0x26);
for (UWORD j = 0; j < height; j++) {
for (UWORD i = 0; i < width/8; i++) {
SendData(0x00);
}
}
SendCommand(0x22);
SendData(0xF7);
SendCommand(0x20);
ReadBusy();
}
void Epd::Clear_old() {
//send black data
SendCommand(0x10);
for (UWORD j = 0; j < height; j++) {
for (UWORD i = 0; i < width/8; i++) {
SendData(0xff);
}
}
//send red data
SendCommand(0x13);
for (UWORD j = 0; j < height; j++) {
for (UWORD i = 0; i < width/8; i++) {
SendData(0xff);
}
}
SendCommand(0x12);
DelayMs(100);
ReadBusy();
}
void Epd::Clear() {
if(flag == 0)
Clear_new();
else
Clear_old();
}
/**
* @brief: After this command is transmitted, the chip would enter the deep-sleep mode to save power.
* The deep sleep mode would return to standby by hardware reset. The only one parameter is a
* check code, the command would be executed if check code = 0xA5.
* You can use Epd::Reset() to awaken and use Epd::Init() to initialize.
*/
void Epd::Sleep_new(void) {
SendCommand(0x10);
SendData(0x01);
}
void Epd::Sleep_old() {
SendCommand(0X50);
SendData(0xf7);
SendCommand(0x02);
ReadBusy();
SendCommand(0x07);
SendData(0XA5);
}
void Epd::Sleep(void) {
if(flag == 0)
Sleep_new();
else
Sleep_old();
}
/* END OF FILE */

79
e-Paper/Arduino/epd4in2b_V2/epd4in2b_V2.h Normal file
View file

@ -0,0 +1,79 @@
/**
* @filename : epd4in2_V2.h
* @brief : Header file for Dual-color e-paper library epd4in2.cpp
* @author : Yehui from Waveshare
*
* Copyright (C) Waveshare Nov 11 2020
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documnetation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef EPD4IN2_V2_H
#define EPD4IN2_V2_H
#include "epdif.h"
// Display resolution
#define EPD_WIDTH 400
#define EPD_HEIGHT 300
#define UWORD unsigned int
#define UBYTE unsigned char
class Epd : EpdIf {
public:
unsigned int width;
unsigned int height;
Epd();
~Epd();
int Init_new(void);
int Init_old(void);
int Init(void);
void SendCommand(unsigned char command);
void SendData(unsigned char data);
void ReadBusy(void);
void Reset(void);
void Display_Window_Black(const UBYTE *image, UBYTE count);
void Display_Window_Red_new(const UBYTE *image, UBYTE count);
void Display_Window_Red_old(const UBYTE *image, UBYTE count);
void Display_Window_Red(const UBYTE *image, UBYTE count);
void DisplayFrame(void);
void Display_old(const UBYTE *blackimage, const UBYTE *ryimage);
void Display_new(const UBYTE *blackimage, const UBYTE *ryimage);
void Display(const UBYTE *blackimage, const UBYTE *ryimage);
void Clear_new();
void Clear_old();
void Clear();
void Sleep_new(void);
void Sleep_old();
void Sleep(void);
private:
unsigned int reset_pin;
unsigned int dc_pin;
unsigned int cs_pin;
unsigned int busy_pin;
unsigned char flag;
};
#endif /* EPD4IN2_H */
/* END OF FILE */

97
e-Paper/Arduino/epd4in2b_V2/epd4in2b_V2.ino Normal file
View file

@ -0,0 +1,97 @@
/**
* @filename : epd4in2b_V2.ino
* @brief : 4.2inch e-paper display (B_V2) demo
* @author : Yehui from Waveshare
*
* Copyright (C) Waveshare Nov 25 2020
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documnetation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <SPI.h>
#include "epd4in2b_V2.h"
#include "imagedata.h"
#include "epdpaint.h"
#define COLORED 0
#define UNCOLORED 1
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
Epd epd;
if (epd.Init() != 0) {
Serial.print("e-Paper init failed");
return;
}
/* This clears the SRAM of the e-paper display */
epd.Clear();
/**
* Due to RAM not enough in Arduino UNO, a frame buffer is not allowed.
* In this case, a smaller image buffer is allocated and you have to
* update a partial display several times.
* 1 byte = 8 pixels, therefore you have to set 8*N pixels at a time.
*/
unsigned char image[1600];
Paint paint(image, 128, 100); //width should be the multiple of 8
paint.SetWidth(128);
paint.SetHeight(100);
paint.Clear(UNCOLORED);
paint.DrawStringAt(0, 0, "ePaper Demo", &Font16, COLORED);
epd.Display_Window_Black(paint.GetImage(), 0);
paint.Clear(UNCOLORED);
paint.DrawRectangle(0, 0, 40, 50, COLORED);
paint.DrawLine(0, 0, 40, 50, COLORED);
paint.DrawLine(40, 0, 0, 50, COLORED);
epd.Display_Window_Black(paint.GetImage(), 1);
paint.Clear(UNCOLORED);
paint.DrawCircle(32, 32, 25, COLORED);
epd.Display_Window_Black(paint.GetImage(), 1);
paint.Clear(UNCOLORED);
paint.DrawStringAt(0, 20, "Hello world", &Font16, COLORED);
epd.Display_Window_Red(paint.GetImage(), 0);
paint.Clear(UNCOLORED);
paint.DrawFilledRectangle(60, 0, 100, 50, COLORED);
epd.Display_Window_Red(paint.GetImage(), 1);
paint.Clear(UNCOLORED);
paint.DrawFilledCircle(92, 32, 25, COLORED);
epd.Display_Window_Red(paint.GetImage(), 1);
epd.DisplayFrame();
delay(1000);
/* This displays an image */
// epd.DisplayFrame(IMAGE_BLACK, IMAGE_RED);
/* Deep sleep */
epd.Clear();
epd.Sleep();
}
void loop() {
// put your main code here, to run repeatedly:
}

137
e-Paper/Arduino/epd4in2b_V2/epdif.cpp Normal file
View file

@ -0,0 +1,137 @@
/**
* @filename : epdif.cpp
* @brief : Implements EPD interface functions
* Users have to implement all the functions in epdif.cpp
* @author : Yehui from Waveshare
*
* Copyright (C) Waveshare August 10 2017
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documnetation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "epdif.h"
#include <SPI.h>
EpdIf::EpdIf() {
};
EpdIf::~EpdIf() {
};
void EpdIf::DigitalWrite(int pin, int value) {
digitalWrite(pin, value);
}
int EpdIf::DigitalRead(int pin) {
return digitalRead(pin);
}
void EpdIf::DelayMs(unsigned int delaytime) {
delay(delaytime);
}
void EpdIf::SpiTransfer(unsigned char data) {
digitalWrite(CS_PIN, LOW);
SPI.transfer(data);
digitalWrite(CS_PIN, HIGH);
}
void EpdIf::EPD_GPIO_Init()
{
SPI.end();
}
void EpdIf::EPD_SPI_Init()
{
SPI.begin();
SPI.beginTransaction(SPISettings(2000000, MSBFIRST, SPI_MODE0));
}
void EpdIf::EPD_Mode(int pin, char mode) {
if(mode == 0)
pinMode(pin, INPUT);
else
pinMode(pin, OUTPUT);
}
void EpdIf::EPD_SendData(unsigned char data) {
unsigned char i,j=data;
EPD_Mode(MOSI_PIN, 1);
EPD_Mode(SCLK_PIN, 1);
digitalWrite(CS_PIN, 0);
for(i = 0; i<8; i++)
{
digitalWrite(SCLK_PIN, 0);
if (j & 0x80)
{
digitalWrite(MOSI_PIN, 1);
}
else
{
digitalWrite(MOSI_PIN, 0);
}
digitalWrite(SCLK_PIN, 1);
j = j << 1;
// DelayMs(1);
}
digitalWrite(SCLK_PIN, 0);
digitalWrite(CS_PIN, 1);
}
unsigned char EpdIf::EPD_ReadData()
{
unsigned char i,j=0xff;
EPD_Mode(MOSI_PIN, 0);
EPD_Mode(SCLK_PIN, 1);
digitalWrite(CS_PIN, 0);
for(i = 0; i<8; i++)
{
digitalWrite(SCLK_PIN, 0);
j = j << 1;
if (DigitalRead(MOSI_PIN))
{
j = j | 0x01;
}
else
{
j= j & 0xfe;
}
digitalWrite(SCLK_PIN, 1);
}
digitalWrite(SCLK_PIN, 0);
digitalWrite(CS_PIN, 1);
return j;
}
int EpdIf::IfInit(void) {
pinMode(CS_PIN, OUTPUT);
pinMode(RST_PIN, OUTPUT);
pinMode(DC_PIN, OUTPUT);
pinMode(BUSY_PIN, INPUT);
pinMode(PWR_PIN, OUTPUT);
DigitalWrite(PWR_PIN, 1);
SPI.begin();
SPI.beginTransaction(SPISettings(2000000, MSBFIRST, SPI_MODE0));
return 0;
}

59
e-Paper/Arduino/epd4in2b_V2/epdif.h Normal file
View file

@ -0,0 +1,59 @@
/**
* @filename : epdif.h
* @brief : Header file of epdif.cpp providing EPD interface functions
* Users have to implement all the functions in epdif.cpp
* @author : Yehui from Waveshare
*
* Copyright (C) Waveshare August 10 2017
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documnetation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef EPDIF_H
#define EPDIF_H
#include <Arduino.h>
// Pin definition
#define MOSI_PIN 11
#define SCLK_PIN 13
#define RST_PIN 8
#define DC_PIN 9
#define CS_PIN 10
#define BUSY_PIN 7
#define PWR_PIN 6
class EpdIf {
public:
EpdIf(void);
~EpdIf(void);
static int IfInit(void);
static void EPD_GPIO_Init();
static void EPD_SPI_Init();
static void EPD_Mode(int pin, char mode);
static void EPD_SendData(unsigned char data);
static unsigned char EPD_ReadData();
static void DigitalWrite(int pin, int value);
static int DigitalRead(int pin);
static void DelayMs(unsigned int delaytime);
static void SpiTransfer(unsigned char data);
};
#endif

342
e-Paper/Arduino/epd4in2b_V2/epdpaint.cpp Normal file
View file

@ -0,0 +1,342 @@
/**
* @filename : epdpaint.cpp
* @brief : Paint tools
* @author : Yehui from Waveshare
*
* Copyright (C) Waveshare September 9 2017
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documnetation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <avr/pgmspace.h>
#include "epdpaint.h"
Paint::Paint(unsigned char* image, int width, int height) {
this->rotate = ROTATE_0;
this->image = image;
/* 1 byte = 8 pixels, so the width should be the multiple of 8 */
this->width = width % 8 ? width + 8 - (width % 8) : width;
this->height = height;
}
Paint::~Paint() {
}
/**
* @brief: clear the image
*/
void Paint::Clear(int colored) {
for (int x = 0; x < this->width; x++) {
for (int y = 0; y < this->height; y++) {
DrawAbsolutePixel(x, y, colored);
}
}
}
/**
* @brief: this draws a pixel by absolute coordinates.
* this function won't be affected by the rotate parameter.
*/
void Paint::DrawAbsolutePixel(int x, int y, int colored) {
if (x < 0 || x >= this->width || y < 0 || y >= this->height) {
return;
}
if (IF_INVERT_COLOR) {
if (colored) {
image[(x + y * this->width) / 8] |= 0x80 >> (x % 8);
} else {
image[(x + y * this->width) / 8] &= ~(0x80 >> (x % 8));
}
} else {
if (colored) {
image[(x + y * this->width) / 8] &= ~(0x80 >> (x % 8));
} else {
image[(x + y * this->width) / 8] |= 0x80 >> (x % 8);
}
}
}
/**
* @brief: Getters and Setters
*/
unsigned char* Paint::GetImage(void) {
return this->image;
}
int Paint::GetWidth(void) {
return this->width;
}
void Paint::SetWidth(int width) {
this->width = width % 8 ? width + 8 - (width % 8) : width;
}
int Paint::GetHeight(void) {
return this->height;
}
void Paint::SetHeight(int height) {
this->height = height;
}
int Paint::GetRotate(void) {
return this->rotate;
}
void Paint::SetRotate(int rotate){
this->rotate = rotate;
}
/**
* @brief: this draws a pixel by the coordinates
*/
void Paint::DrawPixel(int x, int y, int colored) {
int point_temp;
if (this->rotate == ROTATE_0) {
if(x < 0 || x >= this->width || y < 0 || y >= this->height) {
return;
}
DrawAbsolutePixel(x, y, colored);
} else if (this->rotate == ROTATE_90) {
if(x < 0 || x >= this->height || y < 0 || y >= this->width) {
return;
}
point_temp = x;
x = this->width - y;
y = point_temp;
DrawAbsolutePixel(x, y, colored);
} else if (this->rotate == ROTATE_180) {
if(x < 0 || x >= this->width || y < 0 || y >= this->height) {
return;
}
x = this->width - x;
y = this->height - y;
DrawAbsolutePixel(x, y, colored);
} else if (this->rotate == ROTATE_270) {
if(x < 0 || x >= this->height || y < 0 || y >= this->width) {
return;
}
point_temp = x;
x = y;
y = this->height - point_temp;
DrawAbsolutePixel(x, y, colored);
}
}
/**
* @brief: this draws a charactor on the frame buffer but not refresh
*/
void Paint::DrawCharAt(int x, int y, char ascii_char, sFONT* font, int colored) {
int i, j;
unsigned int char_offset = (ascii_char - ' ') * font->Height * (font->Width / 8 + (font->Width % 8 ? 1 : 0));
const unsigned char* ptr = &font->table[char_offset];
for (j = 0; j < font->Height; j++) {
for (i = 0; i < font->Width; i++) {
if (pgm_read_byte(ptr) & (0x80 >> (i % 8))) {
DrawPixel(x + i, y + j, colored);
}
if (i % 8 == 7) {
ptr++;
}
}
if (font->Width % 8 != 0) {
ptr++;
}
}
}
/**
* @brief: this displays a string on the frame buffer but not refresh
*/
void Paint::DrawStringAt(int x, int y, const char* text, sFONT* font, int colored) {
const char* p_text = text;
unsigned int counter = 0;
int refcolumn = x;
/* Send the string character by character on EPD */
while (*p_text != 0) {
/* Display one character on EPD */
DrawCharAt(refcolumn, y, *p_text, font, colored);
/* Decrement the column position by 16 */
refcolumn += font->Width;
/* Point on the next character */
p_text++;
counter++;
}
}
/**
* @brief: this draws a line on the frame buffer
*/
void Paint::DrawLine(int x0, int y0, int x1, int y1, int colored) {
/* Bresenham algorithm */
int dx = x1 - x0 >= 0 ? x1 - x0 : x0 - x1;
int sx = x0 < x1 ? 1 : -1;
int dy = y1 - y0 <= 0 ? y1 - y0 : y0 - y1;
int sy = y0 < y1 ? 1 : -1;
int err = dx + dy;
while((x0 != x1) && (y0 != y1)) {
DrawPixel(x0, y0 , colored);
if (2 * err >= dy) {
err += dy;
x0 += sx;
}
if (2 * err <= dx) {
err += dx;
y0 += sy;
}
}
}
/**
* @brief: this draws a horizontal line on the frame buffer
*/
void Paint::DrawHorizontalLine(int x, int y, int line_width, int colored) {
int i;
for (i = x; i < x + line_width; i++) {
DrawPixel(i, y, colored);
}
}
/**
* @brief: this draws a vertical line on the frame buffer
*/
void Paint::DrawVerticalLine(int x, int y, int line_height, int colored) {
int i;
for (i = y; i < y + line_height; i++) {
DrawPixel(x, i, colored);
}
}
/**
* @brief: this draws a rectangle
*/
void Paint::DrawRectangle(int x0, int y0, int x1, int y1, int colored) {
int min_x, min_y, max_x, max_y;
min_x = x1 > x0 ? x0 : x1;
max_x = x1 > x0 ? x1 : x0;
min_y = y1 > y0 ? y0 : y1;
max_y = y1 > y0 ? y1 : y0;
DrawHorizontalLine(min_x, min_y, max_x - min_x + 1, colored);
DrawHorizontalLine(min_x, max_y, max_x - min_x + 1, colored);
DrawVerticalLine(min_x, min_y, max_y - min_y + 1, colored);
DrawVerticalLine(max_x, min_y, max_y - min_y + 1, colored);
}
/**
* @brief: this draws a filled rectangle
*/
void Paint::DrawFilledRectangle(int x0, int y0, int x1, int y1, int colored) {
int min_x, min_y, max_x, max_y;
int i;
min_x = x1 > x0 ? x0 : x1;
max_x = x1 > x0 ? x1 : x0;
min_y = y1 > y0 ? y0 : y1;
max_y = y1 > y0 ? y1 : y0;
for (i = min_x; i <= max_x; i++) {
DrawVerticalLine(i, min_y, max_y - min_y + 1, colored);
}
}
/**
* @brief: this draws a circle
*/
void Paint::DrawCircle(int x, int y, int radius, int colored) {
/* Bresenham algorithm */
int x_pos = -radius;
int y_pos = 0;
int err = 2 - 2 * radius;
int e2;
do {
DrawPixel(x - x_pos, y + y_pos, colored);
DrawPixel(x + x_pos, y + y_pos, colored);
DrawPixel(x + x_pos, y - y_pos, colored);
DrawPixel(x - x_pos, y - y_pos, colored);
e2 = err;
if (e2 <= y_pos) {
err += ++y_pos * 2 + 1;
if(-x_pos == y_pos && e2 <= x_pos) {
e2 = 0;
}
}
if (e2 > x_pos) {
err += ++x_pos * 2 + 1;
}
} while (x_pos <= 0);
}
/**
* @brief: this draws a filled circle
*/
void Paint::DrawFilledCircle(int x, int y, int radius, int colored) {
/* Bresenham algorithm */
int x_pos = -radius;
int y_pos = 0;
int err = 2 - 2 * radius;
int e2;
do {
DrawPixel(x - x_pos, y + y_pos, colored);
DrawPixel(x + x_pos, y + y_pos, colored);
DrawPixel(x + x_pos, y - y_pos, colored);
DrawPixel(x - x_pos, y - y_pos, colored);
DrawHorizontalLine(x + x_pos, y + y_pos, 2 * (-x_pos) + 1, colored);
DrawHorizontalLine(x + x_pos, y - y_pos, 2 * (-x_pos) + 1, colored);
e2 = err;
if (e2 <= y_pos) {
err += ++y_pos * 2 + 1;
if(-x_pos == y_pos && e2 <= x_pos) {
e2 = 0;
}
}
if(e2 > x_pos) {
err += ++x_pos * 2 + 1;
}
} while(x_pos <= 0);
}
/* END OF FILE */

75
e-Paper/Arduino/epd4in2b_V2/epdpaint.h Normal file
View file

@ -0,0 +1,75 @@
/**
* @filename : epdpaint.h
* @brief : Header file for epdpaint.cpp
* @author : Yehui from Waveshare
*
* Copyright (C) Waveshare July 28 2017
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documnetation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef EPDPAINT_H
#define EPDPAINT_H
// Display orientation
#define ROTATE_0 0
#define ROTATE_90 1
#define ROTATE_180 2
#define ROTATE_270 3
// Color inverse. 1 or 0 = set or reset a bit if set a colored pixel
#define IF_INVERT_COLOR 1
#include "fonts.h"
class Paint {
public:
Paint(unsigned char* image, int width, int height);
~Paint();
void Clear(int colored);
int GetWidth(void);
void SetWidth(int width);
int GetHeight(void);
void SetHeight(int height);
int GetRotate(void);
void SetRotate(int rotate);
unsigned char* GetImage(void);
void DrawAbsolutePixel(int x, int y, int colored);
void DrawPixel(int x, int y, int colored);
void DrawCharAt(int x, int y, char ascii_char, sFONT* font, int colored);
void DrawStringAt(int x, int y, const char* text, sFONT* font, int colored);
void DrawLine(int x0, int y0, int x1, int y1, int colored);
void DrawHorizontalLine(int x, int y, int width, int colored);
void DrawVerticalLine(int x, int y, int height, int colored);
void DrawRectangle(int x0, int y0, int x1, int y1, int colored);
void DrawFilledRectangle(int x0, int y0, int x1, int y1, int colored);
void DrawCircle(int x, int y, int radius, int colored);
void DrawFilledCircle(int x, int y, int radius, int colored);
private:
unsigned char* image;
int width;
int height;
int rotate;
};
#endif
/* END OF FILE */

1385
e-Paper/Arduino/epd4in2b_V2/font12.cpp Normal file
View file

File diff suppressed because it is too large Load diff

1765
e-Paper/Arduino/epd4in2b_V2/font16.cpp Normal file
View file

File diff suppressed because it is too large Load diff

2143
e-Paper/Arduino/epd4in2b_V2/font20.cpp Normal file
View file

File diff suppressed because it is too large Load diff

2521
e-Paper/Arduino/epd4in2b_V2/font24.cpp Normal file
View file

File diff suppressed because it is too large Load diff

1005
e-Paper/Arduino/epd4in2b_V2/font8.cpp Normal file
View file

File diff suppressed because it is too large Load diff

65
e-Paper/Arduino/epd4in2b_V2/fonts.h Normal file
View file

@ -0,0 +1,65 @@
/**
******************************************************************************
* @file fonts.h
* @author MCD Application Team
* @version V1.0.0
* @date 18-February-2014
* @brief Header for fonts.c file
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __FONTS_H
#define __FONTS_H
/* Max size of bitmap will based on a font24 (17x24) */
#define MAX_HEIGHT_FONT 24
#define MAX_WIDTH_FONT 17
#define OFFSET_BITMAP 54
/* Includes ------------------------------------------------------------------*/
#include <stdint.h>
struct sFONT {
const uint8_t *table;
uint16_t Width;
uint16_t Height;
};
extern sFONT Font24;
extern sFONT Font20;
extern sFONT Font16;
extern sFONT Font12;
extern sFONT Font8;
#endif /* __FONTS_H */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

1911
e-Paper/Arduino/epd4in2b_V2/imagedata.cpp Normal file
View file

File diff suppressed because it is too large Load diff

31
e-Paper/Arduino/epd4in2b_V2/imagedata.h Normal file
View file

@ -0,0 +1,31 @@
/**
* @filename : imagedata.h
* @brief : head file for imagedata.cpp
*
* Copyright (C) Waveshare July 4 2017
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documnetation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
extern const unsigned char IMAGE_BLACK[];
extern const unsigned char IMAGE_RED[];
/* FILE END */