Hello, I'm having a problem with a 1.5" LCD RGB OLED module. I tried connecting it to my Arduino Uno to understand how it worked using this sketch:[link]
(I used the sketch OLED_1in5) but even using the same sketch and output pins(that work with Arduino Uno) it won't work with Arduino Mega. I tried changing the pins 11 and 13, used for Arduino Uno with pin 20 and 21 and even 50 and 51. Should I modify the sketch and the pins to make the LCD work on Arduino Mega?
p.s. i used this link for the sketch https://www.waveshare.com/wiki/1.5inch_RGB_OLED_Module
it's a SPI module, so you need to use the MEGA SPI pins
UNO:
- MISO (Master In Slave Out) - Pin 12
- MOSI (Master Out Slave In) - Pin 11
- SCK (Serial Clock) - Pin 13
- SS (Slave Select) - Pin 10
MEGA:
- MISO - Pin 50
- MOSI - Pin 51
- SCK - Pin 52
- SS - Pin 53
the Slave select pin is the hardware one, you can use other pins
but for arduino one it's worked without using pin 12
Welcome to the forum
You need to change the connections between the Arduino and the display to use the SPI pins on the Mega as they are not the same as the SPI pins on the Uno, which you say that you have done (pin 50 = MOSI and pin 52 = SCK) If you have also used a different pin for SS then you need to change that connection too
You also need to change the sketch to use the pins used by the Mega
PiN 12 is "Master In Slave Out" ➜ if you don't need it, it it means the slave does not speak to the master
for the arduino one i used the pin 11 for the DIN, pin 13 for the CLK, pin 10 for CS, pin 7 for DC and pin 8 for the RST meanwhile for the arduino mega i changed only pin 11 with 20, 50 (also i tried with 51), and pin 13 with 21, 52 but i didn't changed the sketch and it doesn't work
If you didn't change the sketch then how will it know that you are using different pin numbers ?
There are ways that it could be done, but please post your sketch, using code tags when you do, so that we can see what is going on
#include "OLED_Driver.h"
#include "GUI_paint.h"
#include "DEV_Config.h"
#include "Debug.h"
#include "ImageData.h"
void setup() {
System_Init();
if(USE_IIC) {
Serial.print("Only USE_SPI_4W, Please revise DEV_config.h !!!");
return 0;
}
Serial.print(F("OLED_Init()...\r\n"));
OLED_1in5_rgb_Init();
Driver_Delay_ms(500);
OLED_1in5_rgb_Clear();
//1.Create a new image size
UBYTE *BlackImage;
Serial.print("Paint_NewImage\r\n");
Paint_NewImage(BlackImage, OLED_1in5_RGB_WIDTH, OLED_1in5_RGB_HEIGHT, 270, BLACK);
Paint_SetScale(65);
while(1) {
// 2.Write directly to memory through the GUI
Serial.print("Drawing:page 1\r\n");
Paint_DrawPoint(20, 20, BLUE, DOT_PIXEL_1X1, DOT_STYLE_DFT);
Paint_DrawPoint(40, 20, BRED, DOT_PIXEL_2X2, DOT_STYLE_DFT);
Paint_DrawPoint(60, 20, GRED, DOT_PIXEL_3X3, DOT_STYLE_DFT);
Paint_DrawLine(10, 10, 10, 25, GBLUE, DOT_PIXEL_1X1, LINE_STYLE_SOLID);
Paint_DrawLine(30, 10, 30, 25, RED, DOT_PIXEL_1X1, LINE_STYLE_SOLID);
Paint_DrawLine(50, 10, 50, 25, MAGENTA, DOT_PIXEL_1X1, LINE_STYLE_DOTTED);
Paint_DrawLine(70, 10, 70, 25, GREEN, DOT_PIXEL_1X1, LINE_STYLE_DOTTED);
Paint_DrawCircle(30, 90, 20, CYAN, DOT_PIXEL_1X1, DRAW_FILL_EMPTY);
Paint_DrawRectangle(15, 75, 45, 105, BROWN, DOT_PIXEL_1X1, DRAW_FILL_EMPTY);
Paint_DrawCircle(80, 80, 25, BROWN, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(65, 65, 95, 95, CYAN, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Driver_Delay_ms(2000);
OLED_1in5_rgb_Clear();
Serial.print("Drawing:page 2\r\n");
for(UBYTE i=0; i<16; i++){
Paint_DrawRectangle(0, i*8, 127, (i+1)*8, i*4095, DOT_PIXEL_1X1, DRAW_FILL_FULL);
}
Driver_Delay_ms(2000);
OLED_1in5_rgb_Clear();
Serial.print("Drawing:page 3\r\n");
Paint_DrawString_EN(10, 0, "waveshare", &Font16, BLACK, BLUE);
Paint_DrawNum(10, 30, "123.4567", &Font12, 2, RED, BLACK);
Paint_DrawString_CN(10, 50,"你好Ab", &Font12CN, BLACK, BROWN);
Paint_DrawString_CN(0, 80,"微雪电子", &Font24CN, BLACK, BRED);
Driver_Delay_ms(2000);
OLED_1in5_rgb_Clear();
Serial.print("Drawing:page 4\r\n");
OLED_1in5_rgb_Display_Part(gImage_1in5_rgb, 0, 0, 60, 60);
Driver_Delay_ms(2000);
OLED_1in5_rgb_Clear();
}
}
void loop() {
}
for this project i used also another 17 sketch for making this work
there are 9 sketch for make the program work and another 8 for the font for the lcd
Did you miss my request to use code tags when posting the code
Posting your code using code tags prevents parts of it being interpreted as HTML coding and makes it easier to copy for examination
In my experience the easiest way to tidy up the code and add the code tags is as follows
Start by tidying up your code by using Tools/Auto Format in the IDE to make it easier to read. Then use Edit/Copy for Forum and paste what was copied in a new reply. Code tags will have been added to the code to make it easy to read in the forum thus making it easier to provide help.
It is also helpful to post error messages in code tags as it makes it easier to scroll through them and copy them for examination
/******************************************************************************
**************************Hardware interface layer*****************************
| file : DEV_Config.cpp
| version : V1.0
| date : 2020-06-16
| function : Provide the hardware underlying interface
******************************************************************************/
#include "DEV_Config.h"
/********************************************************************************
function: System Init and exit
note:
Initialize the communication method
********************************************************************************/
uint8_t System_Init(void)
{
//set pin
pinMode(OLED_CS, OUTPUT);
pinMode(OLED_RST, OUTPUT);
pinMode(OLED_DC, OUTPUT);
//set Serial
Serial.begin(115200);
#if USE_SPI_4W
Serial.println("USE_SPI");
//set OLED SPI
SPI.setDataMode(SPI_MODE3);
SPI.setBitOrder(MSBFIRST);
SPI.setClockDivider(SPI_CLOCK_DIV2);
SPI.begin();
#elif USE_IIC
//set OLED I2C
Serial.println("USE_I2C");
OLED_DC_0;//DC = 1 => Address = 0x3d
OLED_CS_0;
Wire.setClock(1000000);
Wire.begin();
#endif
return 0;
}
/********************************************************************************
function: Hardware interface
note:
SPI4W_Write_Byte(value) :
hardware SPI
I2C_Write_Byte(value, cmd):
hardware I2C
********************************************************************************/
void SPI4W_Write_Byte(uint8_t DATA)
{
SPI.transfer(DATA);
}
void I2C_Write_Byte(uint8_t value, uint8_t Cmd)
{
uint8_t Addr = 0x3c;
Wire.beginTransmission(Addr);
Wire.write(Cmd);
Wire.write(value);
Wire.endTransmission();
}
/********************************************************************************
function: Delay function
note:
Driver_Delay_ms(xms) : Delay x ms
Driver_Delay_us(xus) : Delay x us
********************************************************************************/
void Driver_Delay_ms(unsigned long xms)
{
delay(xms);
}
void Driver_Delay_us(int xus)
{
for (int j = xus; j > 0; j--);
}
/******************************************************************************
**************************Hardware interface layer*****************************
* | file : DEV_Config.h
* | version : V1.0
* | date : 2020-06-16
* | function : Provide the hardware underlying interface
******************************************************************************/
#ifndef _DEV_CONFIG_H_
#define _DEV_CONFIG_H_
#include <SPI.h>
#include <Wire.h>
#include <avr/pgmspace.h>
/**
* data
**/
#define UBYTE uint8_t
#define UWORD uint16_t
#define UDOUBLE uint32_t
#define USE_SPI_4W 1
#define USE_IIC 0
#define IIC_CMD 0X00
#define IIC_RAM 0X40
/****************************************************************************************
//Use the library function definition
*****************************************************************************************/
//GPIO config
#define OLED_CS 10
#define OLED_CS_0 digitalWrite(OLED_CS, LOW)
#define OLED_CS_1 digitalWrite(OLED_CS, HIGH)
#define OLED_RST 8
#define OLED_RST_0 digitalWrite(OLED_RST, LOW)
#define OLED_RST_1 digitalWrite(OLED_RST, HIGH)
#define OLED_DC 7
#define OLED_DC_0 digitalWrite(OLED_DC, LOW)
#define OLED_DC_1 digitalWrite(OLED_DC, HIGH)
/*------------------------------------------------------------------------------------------------------*/
uint8_t System_Init(void);
void SPI4W_Write_Byte(uint8_t DATA);
void I2C_Write_Byte(uint8_t value, uint8_t Cmd);
void Driver_Delay_ms(unsigned long xms);
void Driver_Delay_us(int xus);
#endif
/*****************************************************************************
* | File : Debug.h
* | Author : Waveshare team
* | Function : debug with printf
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-06-16
* | Info : Basic version
*
******************************************************************************/
#ifndef __DEBUG_H
#define __DEBUG_H
#include "stdio.h"
#define DEBUG 0
#if DEBUG
#define Debug(__info,...) printf("Debug : " __info,##__VA_ARGS__)
#else
#define Debug(__info,...)
#endif
#endif
/******************************************************************************
* | File : GUI_Paint.c
* | Author : Waveshare electronics
* | Function : Achieve drawing: draw points, lines, boxes, circles and
* their size, solid dotted line, solid rectangle hollow
* rectangle, solid circle hollow circle.
* | Info :
* Achieve display characters: Display a single character, string, number
* Achieve time display: adaptive size display time minutes and seconds
*----------------
* | This version: V3.2
* | Date : 2020-08-18
* | Info :
* -----------------------------------------------------------------------------
* V3.2(2020-08-18):
* 1.Change: Paint_SetScale(UBYTE scale)
* Add scale 65K
* 2.Change: Paint_SetPixel(UWORD Xpoint, UWORD Ypoint, UWORD Color)
* Add the branch for scale 65K
* 3.Change: Paint_Clear(UWORD Color)
* Add the branch for scale 65K
* -----------------------------------------------------------------------------
* V3.1(2020-08-14):
* 1.Change: Paint_SetScale(UBYTE scale)
* Add scale 16
* 2.Change: Paint_SetPixel(UWORD Xpoint, UWORD Ypoint, UWORD Color)
* Add the branch for scale 16
* 3.Change: Paint_Clear(UWORD Color)
* Add the branch for scale 16
* -----------------------------------------------------------------------------
* V3.0(2019-04-18):
* 1.Change:
* Paint_DrawPoint(..., DOT_STYLE DOT_STYLE)
* => Paint_DrawPoint(..., DOT_STYLE Dot_Style)
* Paint_DrawLine(..., LINE_STYLE Line_Style, DOT_PIXEL Dot_Pixel)
* => Paint_DrawLine(..., DOT_PIXEL Line_width, LINE_STYLE Line_Style)
* Paint_DrawRectangle(..., DRAW_FILL Filled, DOT_PIXEL Dot_Pixel)
* => Paint_DrawRectangle(..., DOT_PIXEL Line_width, DRAW_FILL Draw_Fill)
* Paint_DrawCircle(..., DRAW_FILL Draw_Fill, DOT_PIXEL Dot_Pixel)
* => Paint_DrawCircle(..., DOT_PIXEL Line_width, DRAW_FILL Draw_Filll)
*
* -----------------------------------------------------------------------------
* V2.0(2018-11-15):
* 1.add: Paint_NewImage()
* Create an image's properties
* 2.add: Paint_SelectImage()
* Select the picture to be drawn
* 3.add: Paint_SetRotate()
* Set the direction of the cache
* 4.add: Paint_RotateImage()
* Can flip the picture, Support 0-360 degrees,
* but only 90.180.270 rotation is better
* 4.add: Paint_SetMirroring()
* Can Mirroring the picture, horizontal, vertical, origin
* 5.add: Paint_DrawString_CN()
* Can display Chinese(GB1312)
*
* -----------------------------------------------------------------------------
* V1.0(2018-07-17):
* Create library
*
* 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 "GUI_Paint.h"
#include "DEV_Config.h"
#include "Debug.h"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h> //memset()
#include <math.h>
#include "OLED_Driver.h"
PAINT Paint;
/******************************************************************************
function: Create Image
parameter:
image : Pointer to the image cache
width : The width of the picture
Height : The height of the picture
Color : Whether the picture is inverted
******************************************************************************/
void Paint_NewImage(UBYTE *image, UWORD Width, UWORD Height, UWORD Rotate, UWORD Color)
{
Paint.Image = NULL;
Paint.Image = image;
Paint.WidthMemory = Width;
Paint.HeightMemory = Height;
Paint.Color = Color;
Paint.Scale = 2;
Paint.WidthByte = (Width % 8 == 0)? (Width / 8 ): (Width / 8 + 1);
Paint.HeightByte = Height;
// printf("WidthByte = %d, HeightByte = %d\r\n", Paint.WidthByte, Paint.HeightByte);
// printf(" EPD_WIDTH / 8 = %d\r\n", 122 / 8);
Paint.Rotate = Rotate;
Paint.Mirror = MIRROR_NONE;
if(Rotate == ROTATE_0 || Rotate == ROTATE_180) {
Paint.Width = Width;
Paint.Height = Height;
} else {
Paint.Width = Height;
Paint.Height = Width;
}
}
/******************************************************************************
function: Select Image
parameter:
image : Pointer to the image cache
******************************************************************************/
void Paint_SelectImage(UBYTE *image)
{
Paint.Image = image;
}
/******************************************************************************
function: Select Image Rotate
parameter:
Rotate : 0,90,180,270
******************************************************************************/
void Paint_SetRotate(UWORD Rotate)
{
if(Rotate == ROTATE_0 || Rotate == ROTATE_90 || Rotate == ROTATE_180 || Rotate == ROTATE_270) {
Debug("Set image Rotate %d\r\n", Rotate);
Paint.Rotate = Rotate;
} else {
Debug("rotate = 0, 90, 180, 270\r\n");
}
}
void Paint_SetScale(UBYTE scale)
{
if(scale == 2){
Paint.Scale = scale;
Paint.WidthByte = (Paint.WidthMemory % 8 == 0)? (Paint.WidthMemory / 8 ): (Paint.WidthMemory / 8 + 1);
}else if(scale == 4){
Paint.Scale = scale;
Paint.WidthByte = (Paint.WidthMemory % 4 == 0)? (Paint.WidthMemory / 4 ): (Paint.WidthMemory / 4 + 1);
}else if(scale ==16) {
Paint.Scale = scale;
Paint.WidthByte = (Paint.WidthMemory%2==0) ? (Paint.WidthMemory/2) : (Paint.WidthMemory/2+1);
}else if(scale ==65) {
Paint.Scale = scale;
Paint.WidthByte = Paint.WidthMemory*2;
}else{
Debug("Set Scale Input parameter error\r\n");
Debug("Scale Only support: 2 4 16 65\r\n");
}
}
/******************************************************************************
function: Select Image mirror
parameter:
mirror :Not mirror,Horizontal mirror,Vertical mirror,Origin mirror
******************************************************************************/
void Paint_SetMirroring(UBYTE mirror)
{
if(mirror == MIRROR_NONE || mirror == MIRROR_HORIZONTAL ||
mirror == MIRROR_VERTICAL || mirror == MIRROR_ORIGIN) {
Debug("mirror image x:%s, y:%s\r\n",(mirror & 0x01)? "mirror":"none", ((mirror >> 1) & 0x01)? "mirror":"none");
Paint.Mirror = mirror;
} else {
Debug("mirror should be MIRROR_NONE, MIRROR_HORIZONTAL, \
MIRROR_VERTICAL or MIRROR_ORIGIN\r\n");
}
}
/******************************************************************************
function: Draw Pixels
parameter:
Xpoint : At point X
Ypoint : At point Y
Color : Painted colors
******************************************************************************/
void Paint_SetPixel(UWORD Xpoint, UWORD Ypoint, UWORD Color)
{
if(Xpoint > Paint.Width || Ypoint > Paint.Height){
Debug("Exceeding display boundaries\r\n");
return;
}
UWORD X, Y;
switch(Paint.Rotate) {
case 0:
X = Xpoint;
Y = Ypoint;
break;
case 90:
X = Paint.WidthMemory - Ypoint - 1;
Y = Xpoint;
break;
case 180:
X = Paint.WidthMemory - Xpoint - 1;
Y = Paint.HeightMemory - Ypoint - 1;
break;
case 270:
X = Ypoint;
Y = Paint.HeightMemory - Xpoint - 1;
break;
default:
return;
}
switch(Paint.Mirror) {
case MIRROR_NONE:
break;
case MIRROR_HORIZONTAL:
X = Paint.WidthMemory - X - 1;
break;
case MIRROR_VERTICAL:
Y = Paint.HeightMemory - Y - 1;
break;
case MIRROR_ORIGIN:
X = Paint.WidthMemory - X - 1;
Y = Paint.HeightMemory - Y - 1;
break;
default:
return;
}
if(X > Paint.WidthMemory || Y > Paint.HeightMemory){
Debug("Exceeding display boundaries\r\n");
return;
}
if(Paint.Scale == 2){
UDOUBLE Addr = X / 8 + Y * Paint.WidthByte;
UBYTE Rdata = Paint.Image[Addr];
if(Color == BLACK)
Paint.Image[Addr] = Rdata & ~(0x80 >> (X % 8));
else
Paint.Image[Addr] = Rdata | (0x80 >> (X % 8));
}else if(Paint.Scale == 4){
UDOUBLE Addr = X / 4 + Y * Paint.WidthByte;
Color = Color % 4;//Guaranteed color scale is 4 --- 0~3
UBYTE Rdata = Paint.Image[Addr];
Rdata = Rdata & (~(0xC0 >> ((X % 4)*2)));
Paint.Image[Addr] = Rdata | ((Color << 6) >> ((X % 4)*2));
}else if(Paint.Scale == 16) {
UDOUBLE Addr = X / 2 + Y * Paint.WidthByte;
UBYTE Rdata = Paint.Image[Addr];
Color = Color % 16;
Rdata = Rdata & (~(0xf0 >> ((X % 2)*4)));
Paint.Image[Addr] = Rdata | ((Color << 4) >> ((X % 2)*4));
}else if(Paint.Scale == 65) {
OLED_1in5_rgb_Set_Point(X, Y, Color);
}
}
/******************************************************************************
function: Clear the color of the picture
parameter:
Color : Painted colors
******************************************************************************/
void Paint_Clear(UWORD Color)
{
if(Paint.Scale == 2 || Paint.Scale == 4) {
for (UWORD Y = 0; Y < Paint.HeightByte; Y++) {
for (UWORD X = 0; X < Paint.WidthByte; X++ ) {//8 pixel = 1 byte
UDOUBLE Addr = X + Y*Paint.WidthByte;
Paint.Image[Addr] = Color;
}
}
}else if(Paint.Scale == 16) {
for (UWORD Y = 0; Y < Paint.HeightByte; Y++) {
for (UWORD X = 0; X < Paint.WidthByte; X++ ) {//8 pixel = 1 byte
UDOUBLE Addr = X + Y*Paint.WidthByte;
Color = Color & 0x0f;
Paint.Image[Addr] = (Color<<4) | Color;
}
}
}else if(Paint.Scale == 65) {
for (UWORD Y = 0; Y < Paint.HeightByte; Y++) {
for (UWORD X = 0; X < Paint.WidthByte; X++ ) {//8 pixel = 1 byte
OLED_1in5_rgb_Set_Point(X, Y, Color);
}
}
}
}
/******************************************************************************
function: Clear the color of a window
parameter:
Xstart : x starting point
Ystart : Y starting point
Xend : x end point
Yend : y end point
Color : Painted colors
******************************************************************************/
void Paint_ClearWindows(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend, UWORD Color)
{
UWORD X, Y;
for (Y = Ystart; Y < Yend; Y++) {
for (X = Xstart; X < Xend; X++) {//8 pixel = 1 byte
Paint_SetPixel(X, Y, Color);
}
}
}
/******************************************************************************
function: Draw Point(Xpoint, Ypoint) Fill the color
parameter:
Xpoint : The Xpoint coordinate of the point
Ypoint : The Ypoint coordinate of the point
Color : Painted color
Dot_Pixel : point size
Dot_Style : point Style
******************************************************************************/
void Paint_DrawPoint(UWORD Xpoint, UWORD Ypoint, UWORD Color,
DOT_PIXEL Dot_Pixel, DOT_STYLE Dot_Style)
{
if (Xpoint > Paint.Width || Ypoint > Paint.Height) {
Debug("Paint_DrawPoint Input exceeds the normal display range\r\n");
printf("Xpoint = %d , Paint.Width = %d \r\n ",Xpoint,Paint.Width);
printf("Ypoint = %d , Paint.Height = %d \r\n ",Ypoint,Paint.Height);
return;
}
int16_t XDir_Num , YDir_Num;
if (Dot_Style == DOT_FILL_AROUND) {
for (XDir_Num = 0; XDir_Num < 2 * Dot_Pixel - 1; XDir_Num++) {
for (YDir_Num = 0; YDir_Num < 2 * Dot_Pixel - 1; YDir_Num++) {
if(Xpoint + XDir_Num - Dot_Pixel < 0 || Ypoint + YDir_Num - Dot_Pixel < 0)
break;
// printf("x = %d, y = %d\r\n", Xpoint + XDir_Num - Dot_Pixel, Ypoint + YDir_Num - Dot_Pixel);
Paint_SetPixel(Xpoint + XDir_Num - Dot_Pixel, Ypoint + YDir_Num - Dot_Pixel, Color);
}
}
} else {
for (XDir_Num = 0; XDir_Num < Dot_Pixel; XDir_Num++) {
for (YDir_Num = 0; YDir_Num < Dot_Pixel; YDir_Num++) {
Paint_SetPixel(Xpoint + XDir_Num - 1, Ypoint + YDir_Num - 1, Color);
}
}
}
}
/******************************************************************************
function: Draw a line of arbitrary slope
parameter:
Xstart ：Starting Xpoint point coordinates
Ystart ：Starting Xpoint point coordinates
Xend ：End point Xpoint coordinate
Yend ：End point Ypoint coordinate
Color ：The color of the line segment
Line_width : Line width
Line_Style: Solid and dotted lines
******************************************************************************/
void Paint_DrawLine(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend,
UWORD Color, DOT_PIXEL Line_width, LINE_STYLE Line_Style)
{
if (Xstart > Paint.Width || Ystart > Paint.Height ||
Xend > Paint.Width || Yend > Paint.Height) {
Debug("Paint_DrawLine Input exceeds the normal display range\r\n");
return;
}
UWORD Xpoint = Xstart;
UWORD Ypoint = Ystart;
int dx = (int)Xend - (int)Xstart >= 0 ? Xend - Xstart : Xstart - Xend;
int dy = (int)Yend - (int)Ystart <= 0 ? Yend - Ystart : Ystart - Yend;
// Increment direction, 1 is positive, -1 is counter;
int XAddway = Xstart < Xend ? 1 : -1;
int YAddway = Ystart < Yend ? 1 : -1;
//Cumulative error
int Esp = dx + dy;
char Dotted_Len = 0;
for (;;) {
Dotted_Len++;
//Painted dotted line, 2 point is really virtual
if (Line_Style == LINE_STYLE_DOTTED && Dotted_Len % 3 == 0) {
//Debug("LINE_DOTTED\r\n");
if(Color)
Paint_DrawPoint(Xpoint, Ypoint, BLACK, Line_width, DOT_STYLE_DFT);
else
Paint_DrawPoint(Xpoint, Ypoint, WHITE, Line_width, DOT_STYLE_DFT);
Dotted_Len = 0;
} else {
Paint_DrawPoint(Xpoint, Ypoint, Color, Line_width, DOT_STYLE_DFT);
}
if (2 * Esp >= dy) {
if (Xpoint == Xend)
break;
Esp += dy;
Xpoint += XAddway;
}
if (2 * Esp <= dx) {
if (Ypoint == Yend)
break;
Esp += dx;
Ypoint += YAddway;
}
}
}
/******************************************************************************
function: Draw a rectangle
parameter:
Xstart ：Rectangular Starting Xpoint point coordinates
Ystart ：Rectangular Starting Xpoint point coordinates
Xend ：Rectangular End point Xpoint coordinate
Yend ：Rectangular End point Ypoint coordinate
Color ：The color of the Rectangular segment
Line_width: Line width
Draw_Fill : Whether to fill the inside of the rectangle
******************************************************************************/
void Paint_DrawRectangle(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend,
UWORD Color, DOT_PIXEL Line_width, DRAW_FILL Draw_Fill)
{
if (Xstart > Paint.Width || Ystart > Paint.Height ||
Xend > Paint.Width || Yend > Paint.Height) {
Debug("Input exceeds the normal display range\r\n");
return;
}
if (Draw_Fill) {
UWORD Ypoint;
for(Ypoint = Ystart; Ypoint < Yend; Ypoint++) {
Paint_DrawLine(Xstart, Ypoint, Xend, Ypoint, Color , Line_width, LINE_STYLE_SOLID);
}
} else {
Paint_DrawLine(Xstart, Ystart, Xend, Ystart, Color, Line_width, LINE_STYLE_SOLID);
Paint_DrawLine(Xstart, Ystart, Xstart, Yend, Color, Line_width, LINE_STYLE_SOLID);
Paint_DrawLine(Xend, Yend, Xend, Ystart, Color, Line_width, LINE_STYLE_SOLID);
Paint_DrawLine(Xend, Yend, Xstart, Yend, Color, Line_width, LINE_STYLE_SOLID);
}
}
/******************************************************************************
function: Use the 8-point method to draw a circle of the
specified size at the specified position->
parameter:
X_Center ：Center X coordinate
Y_Center ：Center Y coordinate
Radius ：circle Radius
Color ：The color of the ：circle segment
Line_width: Line width
Draw_Fill : Whether to fill the inside of the Circle
******************************************************************************/
void Paint_DrawCircle(UWORD X_Center, UWORD Y_Center, UWORD Radius,
UWORD Color, DOT_PIXEL Line_width, DRAW_FILL Draw_Fill)
{
if (X_Center > Paint.Width || Y_Center >= Paint.Height) {
Debug("Paint_DrawCircle Input exceeds the normal display range\r\n");
return;
}
//Draw a circle from(0, R) as a starting point
int16_t XCurrent, YCurrent;
XCurrent = 0;
YCurrent = Radius;
//Cumulative error,judge the next point of the logo
int16_t Esp = 3 - (Radius << 1 );
int16_t sCountY;
if (Draw_Fill == DRAW_FILL_FULL) {
while (XCurrent <= YCurrent ) { //Realistic circles
for (sCountY = XCurrent; sCountY <= YCurrent; sCountY ++ ) {
Paint_DrawPoint(X_Center + XCurrent, Y_Center + sCountY, Color, DOT_PIXEL_DFT, DOT_STYLE_DFT);//1
Paint_DrawPoint(X_Center - XCurrent, Y_Center + sCountY, Color, DOT_PIXEL_DFT, DOT_STYLE_DFT);//2
Paint_DrawPoint(X_Center - sCountY, Y_Center + XCurrent, Color, DOT_PIXEL_DFT, DOT_STYLE_DFT);//3
Paint_DrawPoint(X_Center - sCountY, Y_Center - XCurrent, Color, DOT_PIXEL_DFT, DOT_STYLE_DFT);//4
Paint_DrawPoint(X_Center - XCurrent, Y_Center - sCountY, Color, DOT_PIXEL_DFT, DOT_STYLE_DFT);//5
Paint_DrawPoint(X_Center + XCurrent, Y_Center - sCountY, Color, DOT_PIXEL_DFT, DOT_STYLE_DFT);//6
Paint_DrawPoint(X_Center + sCountY, Y_Center - XCurrent, Color, DOT_PIXEL_DFT, DOT_STYLE_DFT);//7
Paint_DrawPoint(X_Center + sCountY, Y_Center + XCurrent, Color, DOT_PIXEL_DFT, DOT_STYLE_DFT);
}
if (Esp < 0 )
Esp += 4 * XCurrent + 6;
else {
Esp += 10 + 4 * (XCurrent - YCurrent );
YCurrent --;
}
XCurrent ++;
}
} else { //Draw a hollow circle
while (XCurrent <= YCurrent ) {
Paint_DrawPoint(X_Center + XCurrent, Y_Center + YCurrent, Color, Line_width, DOT_STYLE_DFT);//1
Paint_DrawPoint(X_Center - XCurrent, Y_Center + YCurrent, Color, Line_width, DOT_STYLE_DFT);//2
Paint_DrawPoint(X_Center - YCurrent, Y_Center + XCurrent, Color, Line_width, DOT_STYLE_DFT);//3
Paint_DrawPoint(X_Center - YCurrent, Y_Center - XCurrent, Color, Line_width, DOT_STYLE_DFT);//4
Paint_DrawPoint(X_Center - XCurrent, Y_Center - YCurrent, Color, Line_width, DOT_STYLE_DFT);//5
Paint_DrawPoint(X_Center + XCurrent, Y_Center - YCurrent, Color, Line_width, DOT_STYLE_DFT);//6
Paint_DrawPoint(X_Center + YCurrent, Y_Center - XCurrent, Color, Line_width, DOT_STYLE_DFT);//7
Paint_DrawPoint(X_Center + YCurrent, Y_Center + XCurrent, Color, Line_width, DOT_STYLE_DFT);//0
if (Esp < 0 )
Esp += 4 * XCurrent + 6;
else {
Esp += 10 + 4 * (XCurrent - YCurrent );
YCurrent --;
}
XCurrent ++;
}
}
}
/******************************************************************************
function: Show English characters
parameter:
Xpoint ：X coordinate
Ypoint ：Y coordinate
Acsii_Char ：To display the English characters
Font ：A structure pointer that displays a character size
Color_Foreground : Select the foreground color
Color_Background : Select the background color
******************************************************************************/
void Paint_DrawChar(UWORD Xpoint, UWORD Ypoint, const char Acsii_Char,
sFONT* Font, UWORD Color_Foreground, UWORD Color_Background)
{
UWORD Page, Column;
if (Xpoint > Paint.Width || Ypoint > Paint.Height) {
//Debug("Paint_DrawChar Input exceeds the normal display range\r\n");
return;
}
uint32_t Char_Offset = (Acsii_Char - ' ') * Font->Height * (Font->Width / 8 + (Font->Width % 8 ? 1 : 0));
const unsigned char *ptr = &Font->table[Char_Offset];
for ( Page = 0; Page < Font->Height; Page ++ ) {
for ( Column = 0; Column < Font->Width; Column ++ ) {
//To determine whether the font background color and screen background color is consistent
if (FONT_BACKGROUND == Color_Background) { //this process is to speed up the scan
if (pgm_read_byte(ptr) & (0x80 >> (Column % 8)))
Paint_SetPixel (Xpoint + Column, Ypoint + Page, Color_Foreground );
} else {
if (pgm_read_byte(ptr) & (0x80 >> (Column % 8))) {
Paint_SetPixel (Xpoint + Column, Ypoint + Page, Color_Foreground );
} else {
Paint_SetPixel (Xpoint + Column, Ypoint + Page, Color_Background );
}
}
//One pixel is 8 bits
if (Column % 8 == 7) {
ptr++;
}
}/* Write a line */
if (Font->Width % 8 != 0) {
ptr++;
}
}/* Write all */
}
/******************************************************************************
function: Display the string
parameter:
Xstart ：X coordinate
Ystart ：Y coordinate
pString ：The first address of the English string to be displayed
Font ：A structure pointer that displays a character size
Color_Foreground : Select the foreground color
Color_Background : Select the background color
******************************************************************************/
void Paint_DrawString_EN(UWORD Xstart, UWORD Ystart, const char * pString,
sFONT* Font, UWORD Color_Foreground, UWORD Color_Background)
{
UWORD Xpoint = Xstart;
UWORD Ypoint = Ystart;
if (Xstart > Paint.Width || Ystart > Paint.Height) {
Debug("Paint_DrawString_EN Input exceeds the normal display range\r\n");
return;
}
while (* pString != '\0') {
//if X direction filled , reposition to(Xstart,Ypoint),Ypoint is Y direction plus the Height of the character
if ((Xpoint + Font->Width ) > Paint.Width ) {
Xpoint = Xstart;
Ypoint += Font->Height;
}
// If the Y direction is full, reposition to(Xstart, Ystart)
if ((Ypoint + Font->Height ) > Paint.Height ) {
Xpoint = Xstart;
Ypoint = Ystart;
}
Paint_DrawChar(Xpoint, Ypoint, * pString, Font, Color_Background, Color_Foreground);
//The next character of the address
pString ++;
//The next word of the abscissa increases the font of the broadband
Xpoint += Font->Width;
}
}
/******************************************************************************
function: Display the string
parameter:
Xstart ：X coordinate
Ystart ：Y coordinate
pString ：The first address of the Chinese string and English
string to be displayed
Font ：A structure pointer that displays a character size
Color_Foreground : Select the foreground color
Color_Background : Select the background color
******************************************************************************/
void Paint_DrawString_CN(UWORD Xstart, UWORD Ystart, const char * pString, cFONT* font, UWORD Color_Background, UWORD Color_Foreground)
{
const unsigned char* p_text = pString;
int refcolumn = Xstart;
int i, j, Num;
/* Send the string character by character on EPD */
while (*p_text != 0) {
if (*p_text < 0x7F) { //ASCII
for (Num = 0; Num < font->size ; Num++) {
if (*p_text == pgm_read_byte(&font->table[Num].index[0])) {
const char* ptr = &font->table[Num].matrix[0];
for (j = 0; j < font->Height; j++) {
for (i = 0; i < font->Width; i++) {
if (pgm_read_byte(ptr) & (0x80 >> (i % 8))) {
Paint_SetPixel(refcolumn + i,Ystart + j, Color_Foreground);
}
if (i % 8 == 7) {
ptr++;
}
}
if (font->Width % 8 != 0) {
ptr++;
}
}
break;
}
}
/* Point on the next character */
p_text += 1;
/* Decrement the column position by 16 */
refcolumn += font->ASCII_Width;
} else { //中文
for (Num = 0; Num < font->size ; Num++) {
if ((*p_text == pgm_read_byte(&font->table[Num].index[0])) && (*(p_text + 1) == pgm_read_byte(&font->table[Num].index[1])) && (*(p_text + 2) == pgm_read_byte(&font->table[Num].index[2]))) {
const char* ptr = &font->table[Num].matrix[0];
for (j = 0; j < font->Height; j++) {
for (i = 0; i < font->Width; i++) {
if (pgm_read_byte(ptr) & (0x80 >> (i % 8))) {
Paint_SetPixel(refcolumn + i,Ystart + j, Color_Foreground);
}
if (i % 8 == 7) {
ptr++;
}
}
if (font->Width % 8 != 0) {
ptr++;
}
}
break;
}
}
/* Point on the next character */
p_text += 3;
/* Decrement the column position by 16 */
refcolumn += font->Width;
}
}
}
/******************************************************************************
function: Display nummber
parameter:
Xstart ：X coordinate
Ystart : Y coordinate
Number : The number displayed
Font ：A structure pointer that displays a character size
Digit : Fractional width
Color_Foreground : Select the foreground color
Color_Background : Select the background color
******************************************************************************/
#define ARRAY_LEN 255
void Paint_DrawNum(UWORD Xpoint, UWORD Ypoint,const char * Number,
sFONT* Font, UWORD Digit,UWORD Color_Foreground, UWORD Color_Background)
{
uint8_t Str_Array[ARRAY_LEN] = {0};
uint8_t *pStr = Str_Array;
uint8_t i, len = 0;
int16_t arr[2] = {0, -1};
int16_t *p = arr;
if (Xpoint > Paint.Width || Ypoint > Paint.Height) {
Debug("Paint_DisNum Input exceeds the normal display range\r\n");
return;
}
while(Number[len] != '\0') {
len++; //get total length
(*p)++; //get the integer part length
if(Number[len] == '.') p++; //get fractional part length
}
if(Digit > 0) {
if(Digit <= arr[1]) {
for(i=0; i<len-(arr[1]-Digit); i++) //cut some Number
Str_Array[i] = Number[i];
}
else {
for(i=0; i<len+(Digit-arr[1]); i++) {
if(i >= len) //add '0'
Str_Array[i] = '0';
else
Str_Array[i] = Number[i];
}
}
}
else
for(i=0; i<len; i++) {
Str_Array[i] = Number[i];
}
//show
Paint_DrawString_EN(Xpoint, Ypoint, (const char*)pStr, Font, Color_Background, Color_Foreground);
}
/******************************************************************************
function: Display time
parameter:
Xstart ：X coordinate
Ystart : Y coordinate
pTime : Time-related structures
Font ：A structure pointer that displays a character size
Color_Foreground : Select the foreground color
Color_Background : Select the background color
******************************************************************************/
void Paint_DrawTime(UWORD Xstart, UWORD Ystart, PAINT_TIME *pTime, sFONT* Font,
UWORD Color_Foreground, UWORD Color_Background)
{
uint8_t value[10] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
UWORD Dx = Font->Width;
//Write data into the cache
Paint_DrawChar(Xstart , Ystart, value[pTime->Hour / 10], Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx , Ystart, value[pTime->Hour % 10], Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx + Dx / 4 + Dx / 2 , Ystart, ':' , Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx * 2 + Dx / 2 , Ystart, value[pTime->Min / 10] , Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx * 3 + Dx / 2 , Ystart, value[pTime->Min % 10] , Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx * 4 + Dx / 2 - Dx / 4, Ystart, ':' , Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx * 5 , Ystart, value[pTime->Sec / 10] , Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx * 6 , Ystart, value[pTime->Sec % 10] , Font, Color_Background, Color_Foreground);
}
/******************************************************************************
function: Display monochrome bitmap
parameter:
image_buffer ：A picture data converted to a bitmap
info:
Use a computer to convert the image into a corresponding array,
and then embed the array directly into Imagedata.cpp as a .c file.
******************************************************************************/
void Paint_DrawBitMap(const unsigned char* image_buffer)
{
UWORD x, y;
UDOUBLE Addr = 0;
for (y = 0; y < Paint.HeightByte; y++) {
for (x = 0; x < Paint.WidthByte; x++) {//8 pixel = 1 byte
Addr = x + y * Paint.WidthByte;
Paint.Image[Addr] = (unsigned char)image_buffer[Addr];
}
}
}
///******************************************************************************
//function: SDisplay half of monochrome bitmap
//parameter:
// Region : 1 Upper half
// 2 Lower half
//info:
//******************************************************************************/
//void Paint_DrawBitMap_Half(const unsigned char* image_buffer, UBYTE Region)
//{
// UWORD x, y;
// UDOUBLE Addr = 0;
//
// if(Region == 1){
// for (y = 0; y < Paint.HeightByte; y++) {
// for (x = 0; x < Paint.WidthByte; x++) {//8 pixel = 1 byte
// Addr = x + y * Paint.WidthByte;
// Paint.Image[Addr] = (unsigned char)image_buffer[Addr];
// }
// }
// }else{
// for (y = 0; y < Paint.HeightByte; y++) {
// for (x = 0; x < Paint.WidthByte; x++) {//8 pixel = 1 byte
// Addr = x + y * Paint.WidthByte ;
// Paint.Image[Addr] = \
// (unsigned char)image_buffer[Addr+ (Paint.HeightByte)*Paint.WidthByte];
// }
// }
// }
//}
///******************************************************************************
//function: SDisplay half of monochrome bitmap
//parameter:
// Region : 1 Upper half
// 2 Lower half
//info:
//******************************************************************************/
//void Paint_DrawBitMap_OneQuarter(const unsigned char* image_buffer, UBYTE Region)
//{
// UWORD x, y;
// UDOUBLE Addr = 0;
//
// if(Region == 1){
// for (y = 0; y < Paint.HeightByte; y++) {
// for (x = 0; x < Paint.WidthByte; x++) {//8 pixel = 1 byte
// Addr = x + y * Paint.WidthByte;
// Paint.Image[Addr] = (unsigned char)image_buffer[Addr];
// }
// }
// }else if(Region == 2){
// for (y = 0; y < Paint.HeightByte; y++) {
// for (x = 0; x < Paint.WidthByte; x++) {//8 pixel = 1 byte
// Addr = x + y * Paint.WidthByte ;
// Paint.Image[Addr] = \
// (unsigned char)image_buffer[Addr+ (Paint.HeightByte)*Paint.WidthByte];
// }
// }
// }else if(Region == 3){
// for (y = 0; y < Paint.HeightByte; y++) {
// for (x = 0; x < Paint.WidthByte; x++) {//8 pixel = 1 byte
// Addr = x + y * Paint.WidthByte ;
// Paint.Image[Addr] = \
// (unsigned char)image_buffer[Addr+ (Paint.HeightByte)*Paint.WidthByte*2];
// }
// }
// }else if(Region == 4){
// for (y = 0; y < Paint.HeightByte; y++) {
// for (x = 0; x < Paint.WidthByte; x++) {//8 pixel = 1 byte
// Addr = x + y * Paint.WidthByte ;
// Paint.Image[Addr] = \
// (unsigned char)image_buffer[Addr+ (Paint.HeightByte)*Paint.WidthByte*3];
// }
// }
// }
//}
void Paint_DrawBitMap_Block(const unsigned char* image_buffer, UBYTE Region)
{
UWORD x, y;
UDOUBLE Addr = 0;
for (y = 0; y < Paint.HeightByte; y++) {
for (x = 0; x < Paint.WidthByte; x++) {//8 pixel = 1 byte
Addr = x + y * Paint.WidthByte ;
Paint.Image[Addr] = \
(unsigned char)image_buffer[Addr+ (Paint.HeightByte)*Paint.WidthByte*(Region - 1)];
}
}
}
/******************************************************************************
* | File : GUI_Paint.h
* | Author : Waveshare electronics
* | Function : Achieve drawing: draw points, lines, boxes, circles and
* their size, solid dotted line, solid rectangle hollow
* rectangle, solid circle hollow circle.
* | Info :
* Achieve display characters: Display a single character, string, number
* Achieve time display: adaptive size display time minutes and seconds
*----------------
* | This version: V3.2
* | Date : 2020-08-18
* | Info :
* -----------------------------------------------------------------------------
* V3.2(2020-08-18):
* 1.Change: Paint_SetScale(UBYTE scale)
* Add scale 65K
* 2.Change: Paint_SetPixel(UWORD Xpoint, UWORD Ypoint, UWORD Color)
* Add the branch for scale 65K
* 3.Change: Paint_Clear(UWORD Color)
* Add the branch for scale 65K
* -----------------------------------------------------------------------------
* V3.1(2020-08-14):
* 1.Change: Paint_SetScale(UBYTE scale)
* Add scale 16
* 2.Change: Paint_SetPixel(UWORD Xpoint, UWORD Ypoint, UWORD Color)
* Add the branch for scale 16
* 3.Change: Paint_Clear(UWORD Color)
* Add the branch for scale 16
* -----------------------------------------------------------------------------
* V3.0(2019-04-18):
* 1.Change:
* Paint_DrawPoint(..., DOT_STYLE DOT_STYLE)
* => Paint_DrawPoint(..., DOT_STYLE Dot_Style)
* Paint_DrawLine(..., LINE_STYLE Line_Style, DOT_PIXEL Dot_Pixel)
* => Paint_DrawLine(..., DOT_PIXEL Line_width, LINE_STYLE Line_Style)
* Paint_DrawRectangle(..., DRAW_FILL Filled, DOT_PIXEL Dot_Pixel)
* => Paint_DrawRectangle(..., DOT_PIXEL Line_width, DRAW_FILL Draw_Fill)
* Paint_DrawCircle(..., DRAW_FILL Draw_Fill, DOT_PIXEL Dot_Pixel)
* => Paint_DrawCircle(..., DOT_PIXEL Line_width, DRAW_FILL Draw_Filll)
*
* -----------------------------------------------------------------------------
* V2.0(2018-11-15):
* 1.add: Paint_NewImage()
* Create an image's properties
* 2.add: Paint_SelectImage()
* Select the picture to be drawn
* 3.add: Paint_SetRotate()
* Set the direction of the cache
* 4.add: Paint_RotateImage()
* Can flip the picture, Support 0-360 degrees,
* but only 90.180.270 rotation is better
* 4.add: Paint_SetMirroring()
* Can Mirroring the picture, horizontal, vertical, origin
* 5.add: Paint_DrawString_CN()
* Can display Chinese(GB1312)
*
* -----------------------------------------------------------------------------
* V1.0(2018-07-17):
* Create library
*
* 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 __GUI_PAINT_H
#define __GUI_PAINT_H
#include "DEV_Config.h"
#include "fonts.h"
/**
* Image attributes
**/
typedef struct {
UBYTE *Image;
UWORD Width;
UWORD Height;
UWORD WidthMemory;
UWORD HeightMemory;
UWORD Color;
UWORD Rotate;
UWORD Mirror;
UWORD WidthByte;
UWORD HeightByte;
UWORD Scale;
} PAINT;
extern PAINT Paint;
/**
* Display rotate
**/
#define ROTATE_0 0
#define ROTATE_90 90
#define ROTATE_180 180
#define ROTATE_270 270
/**
* Display Flip
**/
typedef enum {
MIRROR_NONE = 0x00,
MIRROR_HORIZONTAL = 0x01,
MIRROR_VERTICAL = 0x02,
MIRROR_ORIGIN = 0x03,
} MIRROR_IMAGE;
#define MIRROR_IMAGE_DFT MIRROR_NONE
/**
* image color
**/
#define WHITE 0xFFFF
#define BLACK 0x0000
#define BLUE 0x001F
#define BRED 0XF81F
#define GRED 0XFFE0
#define GBLUE 0X07FF
#define RED 0xF800
#define MAGENTA 0xF81F
#define GREEN 0x07E0
#define CYAN 0x7FFF
#define YELLOW 0xFFE0
#define BROWN 0XBC40
#define BRRED 0XFC07
#define GRAY 0X8430
#define IMAGE_BACKGROUND WHITE
#define FONT_FOREGROUND BLACK
#define FONT_BACKGROUND WHITE
//4 Gray level
#define GRAY1 0x03 //Blackest
#define GRAY2 0x02
#define GRAY3 0x01 //gray
#define GRAY4 0x00 //white
/**
* The size of the point
**/
typedef enum {
DOT_PIXEL_1X1 = 1, // 1 x 1
DOT_PIXEL_2X2 , // 2 X 2
DOT_PIXEL_3X3 , // 3 X 3
DOT_PIXEL_4X4 , // 4 X 4
DOT_PIXEL_5X5 , // 5 X 5
DOT_PIXEL_6X6 , // 6 X 6
DOT_PIXEL_7X7 , // 7 X 7
DOT_PIXEL_8X8 , // 8 X 8
} DOT_PIXEL;
#define DOT_PIXEL_DFT DOT_PIXEL_1X1 //Default dot pilex
/**
* Point size fill style
**/
typedef enum {
DOT_FILL_AROUND = 1, // dot pixel 1 x 1
DOT_FILL_RIGHTUP , // dot pixel 2 X 2
} DOT_STYLE;
#define DOT_STYLE_DFT DOT_FILL_AROUND //Default dot pilex
/**
* Line style, solid or dashed
**/
typedef enum {
LINE_STYLE_SOLID = 0,
LINE_STYLE_DOTTED,
} LINE_STYLE;
/**
* Whether the graphic is filled
**/
typedef enum {
DRAW_FILL_EMPTY = 0,
DRAW_FILL_FULL,
} DRAW_FILL;
/**
* Custom structure of a time attribute
**/
typedef struct {
UWORD Year; //0000
UBYTE Month; //1 - 12
UBYTE Day; //1 - 30
UBYTE Hour; //0 - 23
UBYTE Min; //0 - 59
UBYTE Sec; //0 - 59
} PAINT_TIME;
extern PAINT_TIME sPaint_time;
//init and Clear
void Paint_NewImage(UBYTE *image, UWORD Width, UWORD Height, UWORD Rotate, UWORD Color);
void Paint_SelectImage(UBYTE *image);
void Paint_SetRotate(UWORD Rotate);
void Paint_SetMirroring(UBYTE mirror);
void Paint_SetPixel(UWORD Xpoint, UWORD Ypoint, UWORD Color);
void Paint_SetScale(UBYTE scale);
void Paint_Clear(UWORD Color);
void Paint_ClearWindows(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend, UWORD Color);
//Drawing
void Paint_DrawPoint(UWORD Xpoint, UWORD Ypoint, UWORD Color, DOT_PIXEL Dot_Pixel, DOT_STYLE Dot_FillWay);
void Paint_DrawLine(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend, UWORD Color, DOT_PIXEL Line_width, LINE_STYLE Line_Style);
void Paint_DrawRectangle(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend, UWORD Color, DOT_PIXEL Line_width, DRAW_FILL Draw_Fill);
void Paint_DrawCircle(UWORD X_Center, UWORD Y_Center, UWORD Radius, UWORD Color, DOT_PIXEL Line_width, DRAW_FILL Draw_Fill);
//Display string
void Paint_DrawChar(UWORD Xstart, UWORD Ystart, const char Acsii_Char, sFONT* Font, UWORD Color_Foreground, UWORD Color_Background);
void Paint_DrawString_EN(UWORD Xstart, UWORD Ystart, const char * pString, sFONT* Font, UWORD Color_Foreground, UWORD Color_Background);
void Paint_DrawString_CN(UWORD Xstart, UWORD Ystart, const char * pString, cFONT* font, UWORD Color_Foreground, UWORD Color_Background);
void Paint_DrawNum(UWORD Xpoint, UWORD Ypoint, const char * Number, sFONT* Font, UWORD Digit,UWORD Color_Foreground, UWORD Color_Background);
void Paint_DrawTime(UWORD Xstart, UWORD Ystart, PAINT_TIME *pTime, sFONT* Font, UWORD Color_Foreground, UWORD Color_Background);
//pic
void Paint_DrawBitMap(const unsigned char* image_buffer);
//void Paint_DrawBitMap_Half(const unsigned char* image_buffer, UBYTE Region);
//void Paint_DrawBitMap_OneQuarter(const unsigned char* image_buffer, UBYTE Region);
//void Paint_DrawBitMap_OneEighth(const unsigned char* image_buffer, UBYTE Region);
void Paint_DrawBitMap_Block(const unsigned char* image_buffer, UBYTE Region);
#endif
/*****************************************************************************
* | File : OLED_Driver.cpp
* | Author : Waveshare team
* | Function : 1.5inch RGB OLED Module Drive function
* | Info :
*----------------
* | This version: V2.0
* | Date : 2020-08-20
* | Info :
* -----------------------------------------------------------------------------
#
# 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 "OLED_Driver.h"
#include "stdio.h"
/*******************************************************************************
function:
Hardware reset
*******************************************************************************/
static void OLED_Reset(void)
{
OLED_RST_1;
Driver_Delay_ms(100);
OLED_RST_0;
Driver_Delay_ms(100);
OLED_RST_1;
Driver_Delay_ms(100);
}
/*******************************************************************************
function:
Write register address and data
*******************************************************************************/
static void OLED_WriteReg(uint8_t Reg)
{
#if USE_SPI_4W
OLED_DC_0;
OLED_CS_0;
SPI4W_Write_Byte(Reg);
OLED_CS_1;
#endif
}
static void OLED_WriteData(uint8_t Data)
{
#if USE_SPI_4W
OLED_DC_1;
OLED_CS_0;
SPI4W_Write_Byte(Data);
OLED_CS_1;
#endif
}
/*******************************************************************************
function:
Common register initialization
*******************************************************************************/
static void OLED_InitReg(void)
{
OLED_WriteReg(0xfd); // command lock
OLED_WriteData(0x12);
OLED_WriteReg(0xfd); // command lock
OLED_WriteData(0xB1);
OLED_WriteReg(0xae); // display off
OLED_WriteReg(0xa4); // Normal Display mode
OLED_WriteReg(0x15); //set column address
OLED_WriteData(0x00); //column address start 00
OLED_WriteData(0x7f); //column address end 127
OLED_WriteReg(0x75); //set row address
OLED_WriteData(0x00); //row address start 00
OLED_WriteData(0x7f); //row address end 127
OLED_WriteReg(0xB3);
OLED_WriteData(0xF1);
OLED_WriteReg(0xCA);
OLED_WriteData(0x7F);
OLED_WriteReg(0xa0); //set re-map & data format
OLED_WriteData(0x74); //Horizontal address increment
OLED_WriteReg(0xa1); //set display start line
OLED_WriteData(0x00); //start 00 line
OLED_WriteReg(0xa2); //set display offset
OLED_WriteData(0x00);
OLED_WriteReg(0xAB);
OLED_WriteReg(0x01);
OLED_WriteReg(0xB4);
OLED_WriteData(0xA0);
OLED_WriteData(0xB5);
OLED_WriteData(0x55);
OLED_WriteReg(0xC1);
OLED_WriteData(0xC8);
OLED_WriteData(0x80);
OLED_WriteData(0xC0);
OLED_WriteReg(0xC7);
OLED_WriteData(0x0F);
OLED_WriteReg(0xB1);
OLED_WriteData(0x32);
OLED_WriteReg(0xB2);
OLED_WriteData(0xA4);
OLED_WriteData(0x00);
OLED_WriteData(0x00);
OLED_WriteReg(0xBB);
OLED_WriteData(0x17);
OLED_WriteReg(0xB6);
OLED_WriteData(0x01);
OLED_WriteReg(0xBE);
OLED_WriteData(0x05);
OLED_WriteReg(0xA6);
}
/********************************************************************************
function:
initialization
********************************************************************************/
void OLED_1in5_rgb_Init(void)
{
//Hardware reset
OLED_Reset();
//Set the initialization register
OLED_InitReg();
Driver_Delay_ms(200);
//Turn on the OLED display
OLED_WriteReg(0xAF);
}
/********************************************************************************
function:
Clear screen
********************************************************************************/
void OLED_1in5_rgb_Clear(void)
{
UWORD i;
OLED_WriteReg(0x15);
OLED_WriteData(0);
OLED_WriteData(127);
OLED_WriteReg(0x75);
OLED_WriteData(0);
OLED_WriteData(127);
// fill!
OLED_WriteReg(0x5C);
for(i=0; i<OLED_1in5_RGB_WIDTH*OLED_1in5_RGB_HEIGHT*2; i++){
OLED_WriteData(0x00);
}
}
/********************************************************************************
function: Draw a point
********************************************************************************/
void OLED_1in5_rgb_Set_Point(UBYTE Xpoint, UBYTE Ypoint, UWORD Color)
{
OLED_WriteReg(0x15);
OLED_WriteData(Xpoint);
OLED_WriteData(Xpoint);
OLED_WriteReg(0x75);
OLED_WriteData(Ypoint);
OLED_WriteData(Ypoint);
// fill!
OLED_WriteReg(0x5C);
OLED_WriteData(Color>>8);
OLED_WriteData(Color);
}
/********************************************************************************
function: Update all memory to OLED
********************************************************************************/
void OLED_1in5_rgb_Display(const UBYTE *Image)
{
UWORD i, j, temp;
OLED_WriteReg(0x15);
OLED_WriteData(0);
OLED_WriteData(127);
OLED_WriteReg(0x75);
OLED_WriteData(0);
OLED_WriteData(127);
// fill!
OLED_WriteReg(0x5C);
for(i=0; i<OLED_1in5_RGB_HEIGHT; i++)
for(j=0; j<OLED_1in5_RGB_WIDTH*2; j++)
{
temp = Image[j + i*256];
OLED_WriteData(temp);
}
}
/********************************************************************************
function: Update all memory to OLED
********************************************************************************/
void OLED_1in5_rgb_Display_Part(const UBYTE *Image, UBYTE Xstart, UBYTE Ystart, UBYTE Xend, UBYTE Yend)
{
UWORD i, j, temp;
OLED_WriteReg(0x15);
OLED_WriteData(Xstart);
OLED_WriteData(Xend-1);
OLED_WriteReg(0x75);
OLED_WriteData(Ystart);
OLED_WriteData(Yend-1);
// fill!
OLED_WriteReg(0x5C);
for(i=0; i<Yend-Ystart; i++)
for(j=0; j<(Xend-Xstart)*2; j++)
{
temp = pgm_read_byte(&Image[j + i*(Xend-Xstart)*2]);
OLED_WriteData(temp);
}
}
/*****************************************************************************
* | File : OLED_Driver.h
* | Author : Waveshare team
* | Function : 1.5inch RGB OLED Module Drive function
* | Info :
*----------------
* | This version: V2.0
* | Date : 2020-08-20
* | Info :
* -----------------------------------------------------------------------------
#
# 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 __OLED_DRIVER_H
#define __OLED_DRIVER_H
#include "DEV_Config.h"
/********************************************************************************
function:
Define the full screen height length of the display
********************************************************************************/
#define OLED_1in5_RGB_WIDTH 128//OLED width
#define OLED_1in5_RGB_HEIGHT 128 //OLED height
void OLED_1in5_rgb_Init(void);
void OLED_1in5_rgb_Clear(void);
void OLED_1in5_rgb_Set_Point(UBYTE Xpoint, UBYTE Ypoint, UWORD Color);
void OLED_1in5_rgb_Display(const UBYTE *Image);
void OLED_1in5_rgb_Display_Part(const UBYTE *Image, UBYTE Xstart, UBYTE Ystart, UBYTE Xend, UBYTE Yend);
#endif
ah ok thanks, for the error, when i verify it with arduino it isn't give me wrong so i don't know why it doesn't work
It would have been better to modify the bad looking post rather than posting again… the ugly thing is still there polluting the thread….
Sorry if I'm being persistent but l'd like to know if you have any news about the problem
I suspect that you purchased the wrong kit.
LEGO are boxes containing the brightly coloured blocks that snap together.
If they are too small got your fingers, you could try DUPLO
Reading is optional for these kits.
I'm not going to trawl through all that code, about 95% of which is irrelevant junk, BUT IF you have the line
pinMode(10, OUTPUT)
in your kosher Uno setup, the 10 needs to be changed to 53 in your Mega code. This applies irrespective of whether you are using the pin or not.
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.