LoginSignup
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

More than 1 year has passed since last update.

@caa45040(caa45040)

ESP32とST7735 Parallelでデモ1

Last updated at Posted at 2023-12-07

ESP32とST7735 Parallelでデモ1

x 過去ログを見よ

目的
液晶のテスト

o_cop839.jpg

o_cop840.jpg

o_cop849.jpg

メイン





//OLED_SSD1306_BITMAP_DV67_color_UNO


//ヘッダーファイル
#include <Adafruit_GFX.h>
#include "hh.h"
#include "ns_font64x128_nana_seg.h"
#include "SER_RX_9600_ESP32_1.h"

//定義
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 160 // OLED display height, in pixels
//#define SCREEN_HEIGHT 80 // OLED display height, in pixels stm32G071
NA_ST7735_P display(SCREEN_WIDTH, SCREEN_HEIGHT);


// ビットマップデータ
uint8_t databytes[8] = 

{

0b01100110,
0b10101111,
0b10111111,
0b11011111,

0b01111110,
0b01111110,
0b00111100,
0b00011000

};


//初期化
void setup() {

  //ソフトウエアシリアルのポートをhiにする 初期化
  pinMode(RX1,INPUT_PULLUP);

  // I2Cアドレスは使用するディスプレイに合わせて変更する
  display.begin();

  //表示方向
  display.setRotation(0);

  // 画面表示をクリア
  display.clearDisplay();

  //ビットマップの表示
  //display.drawBitmap(0, 0, databytes, 8, 8,  WHITE);
  display.drawBitmap(3, 3, databytes, 8, 8,  RED);

  // テキストサイズを設定
  display.setTextSize(3);
  // テキスト色を設定
  //display.setTextColor(WHITE);
  display.setTextColor(RED);
  // テキストの開始位置を設定
  display.setCursor(20, 20);

  // 1行目に46を表示
  display.println("START");

  // 画面の左側に長方形(塗りつぶしなし)を描画
  // display.drawRect(左上x, 左上y, 幅, 高さ, 線の色)
  //display.drawRect(0, 0, 127, 80, WHITE);
  display.drawRect(0, 0, 127, 159, WHITE);

  // 描画バッファの内容を画面に表示
  display.display();

  delay(3000); //1秒待つ

}//setup


//表示する値
char aa=23;


//メインループ
void loop() {

  //表示方向
  display.setRotation(3);

  // 画面表示をクリア
  //display.clearDisplay();
  uint16_t *jjk  = display.getBuffer();
  for(int yu=0;yu<(SCREEN_WIDTH*SCREEN_HEIGHT);yu++){
      jjk[yu]=0xffff;
  }//for

  int d10 = 4;
  int d1  = 6;

//0 0
//1 1
//2 23
//3 4
//4 5
//5 6
//6 7
//7 89
 //             0 1 2 3 4 5 6 7 8 9
 int d_top[] = {0,1,2,2,3,4,5,6,7,7};

//0 0
//1 17
//2 2
//3 35
//4 49
//5 68
 //             0 1 2 3 4 5 6 7 8 9
 int d_bot[] = {0,1,2,3,4,3,5,1,5,4};



//start----------------------------------------------


    //                 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1
    //                 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
    //                 -------------------------------
    int henkan1[16] = {0,1,2,3,4,5,6,7,8,9,9,9,9,9,9,9};


    //char ch = pc_getc();
    char ch=(((aa*205)>>11)<<4);ch=ch+(aa-((ch>>4)*10));
    if(aa>=99){aa = 0;}else{aa++;}


    d10 = henkan1[   (ch>>4) & 0x0f ];

    d1  = henkan1[    ch     & 0x0f ];


//end----------------------------------------------


  int bl=0b0000000000011111;




#define Bsize ((64/8)*64)
#define LOOP_Bsize (Bsize/4)
#define REVERSE_BITMAP() for(int ll=0;ll<LOOP_Bsize;ll++){Rptr[ll]=~Sptr[ll];}


  unsigned char databytesTT_BLACK[Bsize];
  int *Rptr = (int *)(&databytesTT_BLACK[0]); //リバースをイントのポインターに強制キャスト
  int *Sptr; //ソースのポイント

  //1文字目の表示
  //ソースをイントのポインターに強制キャスト
  Sptr = (int *)(&databytes_top[ Bsize * d_top[d10] ]); 
  //ビット反転処理
  REVERSE_BITMAP();
  display.drawBitmap( 0+8+4, 0, databytesTT_BLACK , 64, 64, bl);

  //ソースをイントのポインターに強制キャスト
  Sptr = (int *)(&databytes_bot[ Bsize * d_bot[d10] ]); 
  //ビット反転処理
  REVERSE_BITMAP();
  display.drawBitmap( 0+8+4, 64, databytesTT_BLACK , 64, 64, bl);


  //2文字目の表示
  //ソースをイントのポインターに強制キャスト
  Sptr = (int *)(&databytes_top[ Bsize * d_top[d1] ]); 
  //ビット反転処理
  REVERSE_BITMAP();
  display.drawBitmap( 64+8+8+4, 0, databytesTT_BLACK , 64, 64, bl);

  //ソースをイントのポインターに強制キャスト
  Sptr = (int *)(&databytes_bot[ Bsize * d_bot[d1] ]); 
  //ビット反転処理
  REVERSE_BITMAP();
  display.drawBitmap( 64+8+8+4, 64, databytesTT_BLACK , 64, 64, bl);

  // 描画バッファの内容を画面に表示
  display.display();

  delay(1000); //1秒待つ

}//loop

SER_RX_9600_ESP32_1.h




//SER_RX_9600_ESP32_1.h

#define RX1      22


int pc_getc()
{

  int a,b,c,d,e,f,g,h;
  int bs;

  //待ちループ
  while( digitalRead(RX1) == 1 ) {}

    delayMicroseconds(156-1);
    a=(digitalRead(RX1));

    delayMicroseconds(104-0);
    b=(digitalRead(RX1));

    delayMicroseconds(104-0);
    c=(digitalRead(RX1));

    delayMicroseconds(104-0);
    d=(digitalRead(RX1));

    delayMicroseconds(104-1);
    e=(digitalRead(RX1));

    delayMicroseconds(104-0);
    f=(digitalRead(RX1));

    delayMicroseconds(104-0);
    g=(digitalRead(RX1));

    delayMicroseconds(104-0);

    h=(digitalRead(RX1));
    delayMicroseconds(156-1);

    bs=h*128+g*64+f*32+e*16+d*8+c*4+b*2+a;

    return(bs);
}//pc_getc

hh.cpp



#ifdef __AVR__
#include <avr/pgmspace.h>
#elif defined(ESP8266) || defined(ESP32) || defined(ARDUINO_ARCH_RP2040)
#include <pgmspace.h>
#else
#define pgm_read_byte(addr)                                                    \
  (*(const unsigned char *)(addr)) ///< PROGMEM workaround for non-AVR
#endif

#if !defined(__ARM_ARCH) && !defined(ENERGIA) && !defined(ESP8266) &&          \
    !defined(ESP32) && !defined(__arc__)
#include <util/delay.h>
#endif

#include "hh.h"
#include <Adafruit_GFX.h>



#define NA_ST7735_P_swap(a, b)                                                     \
  (((a) ^= (b)), ((b) ^= (a)), ((a) ^= (b))) ///< No-temp-var swap operation

/*
//GPIOの設定1　開始

//GPIO
#define GPIO_A0_P A0
#define GPIO_A1_P A1
#define GPIO_A2_P A2
#define GPIO_A3_P A3

//GPIO
#define GPIO_A0(s) digitalWrite(GPIO_A0_P,s)
#define GPIO_A1(s) digitalWrite(GPIO_A1_P,s)
#define GPIO_A2(s) digitalWrite(GPIO_A2_P,s)
#define GPIO_A3(s) digitalWrite(GPIO_A3_P,s)

#define GPIO_RD_P     GPIO_A3_P //RD=1
#define GPIO_WR_P     GPIO_A2_P //WR=1
#define GPIO_RS_P     GPIO_A1_P //RS=0
#define GPIO_RESET_P  GPIO_A0_P //RESET=1


#define GPIO_RD(y)     GPIO_A3(y) //RD=1
#define GPIO_WR(y)     GPIO_A2(y) //WR=1
#define GPIO_RS(y)     GPIO_A1(y) //RS=0
#define GPIO_RESET(y)  GPIO_A0(y) //RESET=1


#define GPIO_DB7  7
#define GPIO_DB6  6
#define GPIO_DB5  5
#define GPIO_DB4  4
#define GPIO_DB3  3
#define GPIO_DB2  2
#define GPIO_DB1  A5
#define GPIO_DB0  A4

//GPIOの設定1　終了
*/

/*

//GPIOの設定2　開始

//GPIO
#define GPIO_A4_P A4
#define GPIO_A5_P A5
#define GPIO_D3_P 3
#define GPIO_D2_P 2

//GPIO
#define GPIO_A4(s) digitalWrite(GPIO_A4_P,s)
#define GPIO_A5(s) digitalWrite(GPIO_A5_P,s)
#define GPIO_D3(s) digitalWrite(GPIO_D3_P,s)
#define GPIO_D2(s) digitalWrite(GPIO_D2_P,s)


#define GPIO_RD_P     GPIO_A4_P //RD=1
#define GPIO_WR_P     GPIO_D3_P //WR=1
#define GPIO_RS_P     GPIO_A5_P //RS=0
#define GPIO_RESET_P  GPIO_D2_P //RESET=1

#define GPIO_RD(y)    GPIO_A4(y) //RD=1
#define GPIO_WR(y)    GPIO_D3(y) //WR=0
#define GPIO_RS(y)    GPIO_A5(y) //RS=0
#define GPIO_RESET(y) GPIO_D2(y) //RESET=1


#define GPIO_DB7  A0
#define GPIO_DB6   7
#define GPIO_DB5  A1
#define GPIO_DB4   6
#define GPIO_DB3  A2
#define GPIO_DB2   5
#define GPIO_DB1  A3
#define GPIO_DB0   4

//GPIOの設定2　終了

*/


///*

//GPIOの設定3　開始

//GPIO
#define GPIO_D32_P 32
#define GPIO_D33_P 33
#define GPIO_D19_P 19
#define GPIO_D18_P 18

//GPIO
#define GPIO_D32(s) digitalWrite(GPIO_D32_P,s)
#define GPIO_D33(s) digitalWrite(GPIO_D33_P,s)
#define GPIO_D19(s) digitalWrite(GPIO_D19_P,s)
#define GPIO_D18(s) digitalWrite(GPIO_D18_P,s)


#define GPIO_RD_P     GPIO_D33_P //RD=1
#define GPIO_WR_P     GPIO_D18_P //WR=1
#define GPIO_RS_P     GPIO_D32_P //RS=0
#define GPIO_RESET_P  GPIO_D19_P //RESET=1

#define GPIO_RD(y)    GPIO_D33(y) //RD=1
#define GPIO_WR(y)    GPIO_D18(y) //WR=0
#define GPIO_RS(y)    GPIO_D32(y) //RS=0
#define GPIO_RESET(y) GPIO_D19(y) //RESET=1


#define GPIO_DB7  14
#define GPIO_DB6  4
#define GPIO_DB5  27
#define GPIO_DB4  16
#define GPIO_DB3  26
#define GPIO_DB2  17
#define GPIO_DB1  25
#define GPIO_DB0  5

//GPIOの設定3　終了

//*/


void NA_ST7735_P::GPIO_8BIT(uint8_t s)
{
  digitalWrite( GPIO_DB7, (s >> 7) & 1);
  digitalWrite( GPIO_DB6, (s >> 6) & 1);
  digitalWrite( GPIO_DB5, (s >> 5) & 1);
  digitalWrite( GPIO_DB4, (s >> 4) & 1);
  digitalWrite( GPIO_DB3, (s >> 3) & 1);
  digitalWrite( GPIO_DB2, (s >> 2) & 1);
  digitalWrite( GPIO_DB1, (s >> 1) & 1);
  digitalWrite( GPIO_DB0, s & 1);
} //GPIO_8BIT

//コマンドの書き込み
void NA_ST7735_P::LCD_Write_CMD(uint8_t a)
{
  GPIO_RS(0); //A0=0;
  GPIO_8BIT(a);//P1=a; data
  GPIO_WR(0);//WRB=0;
  GPIO_WR(1);//WRB=1;
} //LCD_Write_CMD


//データ書き込み
void NA_ST7735_P::LCD_Write_Data(uint8_t a)
{
  GPIO_RS(1);//A0=1;
  GPIO_8BIT(a);//P1=a; data
  GPIO_WR(0);//WRB=0;
  GPIO_WR(1);//WRB=1;
} //LCD_Write_Data


//液晶の初期化処理
void NA_ST7735_P::TXDT144TF_ST7735S_Init(void)
{

  //----------  ST7735S Reset Sequence  --------//

  GPIO_RESET(1);//LCD_RESET=1;

  delay(1); //Delay 1ms

  GPIO_RESET(0);//LCD_RESET=0;

  delay(1); //Delay 1ms

  GPIO_RESET(1);//LCD_RESET=1;

  delay(120); //Delay 120ms

  LCD_Write_CMD(0x01);//SOFTWARE RESET
  delay(50);

  LCD_Write_CMD(0x11);//SLEEP OUT
  delay(200);

  LCD_Write_CMD(0x29);//display on
  delay(100);

  LCD_Write_CMD(0x3a);//Interface pixel format
  LCD_Write_Data(0x05);//16bit mode
  delay(100);

  LCD_Write_CMD(0x36);//RGB-RGR format
  LCD_Write_Data(0x08);//RGB mode
  delay(100);

} //TXDT144TF_ST7735S_Init



NA_ST7735_P::NA_ST7735_P(uint8_t w, uint8_t h)
    : Adafruit_GFX(w, h), buffer(NULL)

{
}


//バッファのクリア
NA_ST7735_P::~NA_ST7735_P(void) {
  if (buffer) {
    free(buffer);
    buffer = NULL;
  }
}//~NA_ST7735_P



//初期処理
bool NA_ST7735_P::begin(void) {

  if ((!buffer) && !(buffer = (uint16_t *)malloc(WIDTH * HEIGHT * 2)   ))
    return false;

  //バッファーのクリア
  clearDisplay();

  //ポートのモード設定
  //アウトプットモード
  pinMode(GPIO_DB7, OUTPUT);
  pinMode(GPIO_DB6, OUTPUT);
  pinMode(GPIO_DB5, OUTPUT);
  pinMode(GPIO_DB4, OUTPUT);
  pinMode(GPIO_DB3, OUTPUT);
  pinMode(GPIO_DB2, OUTPUT);

  pinMode(GPIO_RESET_P, OUTPUT);
  pinMode(GPIO_RS_P, OUTPUT);
  pinMode(GPIO_WR_P, OUTPUT);
  pinMode(GPIO_RD_P, OUTPUT);
  pinMode(GPIO_DB0, OUTPUT);
  pinMode(GPIO_DB1, OUTPUT);

  //ポートの初期化
  GPIO_RD(1);//RD=1
  GPIO_WR(1);//WR=1
  GPIO_RS(0);//RS=0
  GPIO_RESET(1);//RESET=1

  delay(500); //0.5秒待つ

  //液晶の初期化処理
  TXDT144TF_ST7735S_Init();

  //画面の書き込み開始
  display();

  return true; // Success
}//begin




//点の表示
void NA_ST7735_P::drawPixel(int16_t x, int16_t y, uint16_t color) {
  if ((x >= 0) && (x < width()) && (y >= 0) && (y < height())) {
    // Pixel is in-bounds. Rotate coordinates if needed.
    switch (getRotation()) {
    case 1:
      NA_ST7735_P_swap(x, y);
      x = WIDTH - x - 1;
      break;
    case 2:
      x = WIDTH - x - 1;
      y = HEIGHT - y - 1;
      break;
    case 3:
      NA_ST7735_P_swap(x, y);
      y = HEIGHT - y - 1;
      break;
    }//end switch

    //ドットのカラーの設定
    buffer[ y<<7 | x ] = color;

  }//if
}//drawPixel

//バッファのクリア
void NA_ST7735_P::clearDisplay(void) {
  memset(buffer, 0, WIDTH * HEIGHT * 2 );
}




bool NA_ST7735_P::getPixel(int16_t x, int16_t y) {
  if ((x >= 0) && (x < width()) && (y >= 0) && (y < height())) {
    // Pixel is in-bounds. Rotate coordinates if needed.
    switch (getRotation()) {
    case 1:
      NA_ST7735_P_swap(x, y);
      x = WIDTH - x - 1;
      break;
    case 2:
      x = WIDTH - x - 1;
      y = HEIGHT - y - 1;
      break;
    case 3:
      NA_ST7735_P_swap(x, y);
      y = HEIGHT - y - 1;
      break;
    }
    return (buffer[ y<<7 | x ] );
  }
  return false; // Pixel out of bounds
}



uint16_t *NA_ST7735_P::getBuffer(void) { return buffer; }

//ESP8266の時
#if defined(ESP8266)

#define GPIO_0to31SET_REG   *((volatile unsigned long *)GPIO_OUT_W1TS_REG)
#define GPIO_0to31CLR_REG   *((volatile unsigned long *)GPIO_OUT_W1TC_REG)

#endif


//ESP8266じゃない時
#if !defined(ESP8266)

unsigned long pp_aaa;
unsigned long pp_bbb;
#define GPIO_0to31SET_REG   pp_aaa
#define GPIO_0to31CLR_REG   pp_bbb

#endif




//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
void NA_ST7735_P::HS_GPIO_8BIT_A(uint8_t s)
{
  
int work_a = 0;
//------------------------------------------------------
//7bit
work_a = work_a |( ( (s >> 7) & 1) << 14) ;
//------------------------------------------------------
//6bit
work_a = work_a |( ( (s >> 6) & 1) << 4);
//------------------------------------------------------
//5bit
work_a = work_a |( ( (s >> 5) & 1) << 27);
//------------------------------------------------------
//4bit
work_a = work_a |( ( (s >> 4) & 1) << 16);
//------------------------------------------------------
//3bit
work_a = work_a |( ( (s >> 3) & 1) << 26);
//------------------------------------------------------
//2bit
work_a = work_a |( ( (s >> 2) & 1) << 17);
//------------------------------------------------------
//1bit
work_a = work_a |( ( (s >> 1) & 1) << 25);
//------------------------------------------------------
//0bit
work_a = work_a |( ( s & 1) << 5);

  //[0-31]レジスターの書き込み
 
  //セットレジスターの設定
  GPIO_0to31SET_REG = GPIO_0to31SET_REG | work_a;

//delayMicroseconds(3);

  //リセットレジスターの設定　反転させてマスクして足しこむ
  GPIO_0to31CLR_REG = GPIO_0to31CLR_REG |

(

(  (1 << 14)|(1 << 4)|(1 << 27)|(1 << 16) | (1 << 26)|(1 << 17)|(1 << 25)|(1 << 5)  )

 & (~work_a)

);

//delayMicroseconds(3);

} //GPIO_8BIT
//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

//bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
void NA_ST7735_P::HS_GPIO_8BIT_B(uint8_t s)
{
//------------------------------------------------------
   //7bit
   if( ( (s >> 7) & 1) == 0 ) {
     GPIO_0to31CLR_REG = GPIO_0to31CLR_REG | (1<<14);
   } else {
     GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<14);
   } //end if
//------------------------------------------------------
  //6bit
  if( ( (s >> 6) & 1) == 0 ) {
     GPIO_0to31CLR_REG = GPIO_0to31CLR_REG | (1<<4);
   } else {
     GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<4);
   } //end if
//------------------------------------------------------
   //5bit
   if( ( (s >> 5) & 1) == 0 ) {
     GPIO_0to31CLR_REG = GPIO_0to31CLR_REG | (1<<27);
   } else {
     GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<27);
   } //end if
//------------------------------------------------------
   //4bit
   if( ( (s >> 4) & 1) == 0 ) {
     GPIO_0to31CLR_REG = GPIO_0to31CLR_REG | (1<<16);
   } else {
     GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<16);
   } //end if
//------------------------------------------------------
   //3bit
   if( ( (s >> 3) & 1) == 0 ) {
     GPIO_0to31CLR_REG = GPIO_0to31CLR_REG | (1<<26);
   } else {
     GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<26);
   } //end if
//------------------------------------------------------
   //2bit
   if( ( (s >> 2) & 1) == 0 ) {
     GPIO_0to31CLR_REG = GPIO_0to31CLR_REG | (1<<17);
   } else {
     GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<17);
   } //end if
//------------------------------------------------------
   //1bit
   if( ( (s >> 1) & 1) == 0 ) {
     GPIO_0to31CLR_REG = GPIO_0to31CLR_REG | (1<<25);
   } else {
     GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<25);
   } //end if
//------------------------------------------------------
   //0bit
   if( ( (s >> 0) & 1) == 0 ) {
     GPIO_0to31CLR_REG = GPIO_0to31CLR_REG | (1<<5);
   } else {
     GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<5);
   } //end if  
} //GPIO_8BIT


//bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
//bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb


//セット
#define GPIO_0to31SET_REG_18  (GPIO_0to31SET_REG=GPIO_0to31SET_REG|(1<<GPIO_D18_P))

//クリア
#define GPIO_0to31CLR_REG_18  (GPIO_0to31CLR_REG=GPIO_0to31CLR_REG|(1<<GPIO_D18_P))


//WR信号を出力
void NA_ST7735_P::HS_GPIO_WR(int o_a) {


   //ゼロの場合は、クリア　それ以外は、セット
   if( o_a == 0 ) {

     GPIO_0to31CLR_REG = GPIO_0to31CLR_REG | (1<<18);

   } else {

     GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<18);

   } //end if

} // end GPIO_WR


#if !defined(ESP8266)
//画面のリフレッシュ
void NA_ST7735_P::display(void) {

//buffer = (uint16_t*)yu; //とりま 仮想VRAMに実態を設定


//  uint16_t count = WIDTH * ((HEIGHT + 7) / 8);
//  uint16_t *ptr = buffer;

//    while (count--) {
//
//      //WIRE_WRITE(*ptr++);
//    }

//どつかから拾ってきたint を　文字列　にするアルゴリズム
//int a=0x01234567;
//char s[4];
//int *p;
//p=(int*)s;
//*p=a;

  //画面の書き込み開始
  LCD_Write_CMD(0x2C); //memory write

    GPIO_RS(1);//A0=1; //データモード

////debug start
//        HS_GPIO_8BIT_A(0xff); delay(3000);
//        HS_GPIO_8BIT_A(0x00); delay(1000);
//
//
//        for(int s=0;s<8;s++){
//                        HS_GPIO_8BIT_A(1 << s);delay(1000);
//        }
//        
//        HS_GPIO_8BIT_A(0x00); delay(1000);
////debug end

  char vg[2];
  uint16_t *ptr;  //ポインター型
  ptr = (uint16_t*)vg; //ポインターに実態の文字列を強制型変換して入れる

  for (int i = 0; i < (HEIGHT * WIDTH); i++) {
 
      *ptr=buffer[i]; //ptr と　vg は、ポインタでリンクしている
//---------------- 1バイト目
        GPIO_8BIT(vg[1]); //汎用

        GPIO_WR(0);//WRB=0; 10 //汎用
        GPIO_WR(1);//WRB=1; 10 //汎用
//---------------- 2バイト目
        GPIO_8BIT(vg[0]); //汎用

        GPIO_WR(0);//WRB=0; 10 //汎用
        GPIO_WR(1);//WRB=1; 10 //汎用      
  }//i


}//display
#endif


#if defined(ESP8266)
//画面のリフレッシュ
void NA_ST7735_P::display(void) {

  // ESP8266 needs a periodic yield() call to avoid watchdog reset.
  // With the limited size of SSD1306 displays, and the fast bitrate
  // being used (1 MHz or more), I think one yield() immediately before
  // a screen write and one immediately after should cover it.  But if
  // not, if this becomes a problem, yields() might be added in the
  // 32-byte transfer condition below.
  yield();

  //画面の書き込み開始
  LCD_Write_CMD(0x2C); //memory write

  GPIO_RS(1);//A0=1; //データモード
        
  //なぜかウェートが必要
  GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<5);
  GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<5);
  GPIO_0to31SET_REG = GPIO_0to31SET_REG | (1<<5);

  uint16_t vg;

  for (int i = 0; i < ( WIDTH * HEIGHT); i++) {
 
      vg=buffer[i]; //ptr と　vg は、ポインタでリンクしている
        //---------------- 1バイト目
        HS_GPIO_8BIT_A(vg >> 8); //8ビット出力 esp32
        GPIO_0to31CLR_REG_18;
        GPIO_0to31SET_REG_18;
        //---------------- 2バイト目
        HS_GPIO_8BIT_A(vg & 0xff); //8ビット出力 esp32
        GPIO_0to31CLR_REG_18;
        GPIO_0to31SET_REG_18;
  }//i

  yield(); //ESP8266

}//display
#endif

hh.h



#ifndef _NA_ST7735_P_H_
#define _NA_ST7735_P_H_

#include <Adafruit_GFX.h>

#define ESP8266 1
#ifndef NO_ADAFRUIT_NA_ST7735_P_COLOR_COMPATIBILITY
#define BLACK NA_ST7735_P_BLACK     ///< Draw 'off' pixels
#define WHITE NA_ST7735_P_WHITE     ///< Draw 'on' pixels
#define RED NA_ST7735_P_RED     ///< Draw 'on' pixels
//#define INVERSE NA_ST7735_P_INVERSE ///< Invert pixels
#endif
/// fit into the SSD1306_ naming scheme
#define NA_ST7735_P_BLACK 0x0000   ///< Draw 'off' pixels
#define NA_ST7735_P_WHITE 0xffff   ///< Draw 'on' pixels
#define NA_ST7735_P_RED 0b1111100000000000 //red
 
///< Draw 'on' pixels
//#define NA_ST7735_P_INVERSE 2 ///< Invert pixels


class NA_ST7735_P : public Adafruit_GFX {
public:

  NA_ST7735_P(uint8_t w, uint8_t h);

  ~NA_ST7735_P(void);

  bool begin(void);
  void display(void);
  void clearDisplay(void);
  void drawPixel(int16_t x, int16_t y, uint16_t color);
  bool getPixel(int16_t x, int16_t y);
  uint16_t *getBuffer(void);

  void GPIO_8BIT(uint8_t s);
  void LCD_Write_CMD(uint8_t ww);
  void LCD_Write_Data(uint8_t ii);
  void TXDT144TF_ST7735S_Init(void);

  void HS_GPIO_8BIT_A(uint8_t s);
  void HS_GPIO_8BIT_B(uint8_t s);
  void HS_GPIO_WR(int o_a);

protected:

  uint16_t *buffer; ///< Buffer data used for display buffer. Allocated when
                    ///< begin method is called.

};

#endif // _NA_ST7735_P_H_

ns_font64x128_nana_seg.h

0
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?