pi_i2c_pico_neomatrix_ex02.ino の変更点

追加された行はこの色です。
削除された行はこの色です。
pi_i2c_pico_neomatrix_ex02.ino へ行く。
pi_i2c_pico_neomatrix_ex02.ino の差分を削除
#author("2025-05-20T18:30:14+09:00","","")
#author("2025-05-20T18:31:06+09:00","","")
[[Required-Software-and-Data]]

#code(c){{
// Adafruit_NeoMatrix example for single NeoPixel Shield.
// Scrolls 'Howdy' across the matrix in a portrait (vertical) orientation.
 
#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>
#ifndef PSTR
 #define PSTR // Make Arduino Due happy
#endif
 
#include <Wire.h>
#define SLAVE_ADDRESS 0x30
int status = 0;
 
#define PIN 6
 
// MATRIX DECLARATION:
// Parameter 1 = width of NeoPixel matrix
// Parameter 2 = height of matrix
// Parameter 3 = pin number (most are valid)
// Parameter 4 = matrix layout flags, add together as needed:
//   NEO_MATRIX_TOP, NEO_MATRIX_BOTTOM, NEO_MATRIX_LEFT, NEO_MATRIX_RIGHT:
//     Position of the FIRST LED in the matrix; pick two, e.g.
//     NEO_MATRIX_TOP + NEO_MATRIX_LEFT for the top-left corner.
//   NEO_MATRIX_ROWS, NEO_MATRIX_COLUMNS: LEDs are arranged in horizontal
//     rows or in vertical columns, respectively; pick one or the other.
//   NEO_MATRIX_PROGRESSIVE, NEO_MATRIX_ZIGZAG: all rows/columns proceed
//     in the same order, or alternate lines reverse direction; pick one.
//   See example below for these values in action.
// Parameter 5 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_GRBW    Pixels are wired for GRBW bitstream (RGB+W NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
 
 
// Example for NeoPixel Shield.  In this application we'd like to use it
// as a 5x8 tall matrix, with the USB port positioned at the top of the
// Arduino.  When held that way, the first pixel is at the top right, and
// lines are arranged in columns, progressive order.  The shield uses
// 800 KHz (v2) pixels that expect GRB color data.
/* */
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(32, 16, PIN,
  NEO_MATRIX_TOP     + NEO_MATRIX_LEFT +
  NEO_MATRIX_COLUMNS + NEO_MATRIX_ZIGZAG,
  NEO_GRB            + NEO_KHZ800);
 
const uint16_t colors[] = {
  matrix.Color(255, 0, 0), matrix.Color(0, 255, 0), matrix.Color(0, 0, 255) };

uint16_t buffer[32][16];
/* */ 
void setup() {
   Serial.begin(115200);
   //Serial.print("pi_i2c_nano_neomatrix_ex4\n");
/* */
  matrix.begin();
  matrix.setTextWrap(false);
  //Serial.print("matrix.begin\n");
  matrix.setBrightness(40);  //40
/* */
//  matrix.setTextColor(colors[0]);
  //Serial.print("matrix.setBrightness\n");
 
  int x=15;
 
  //Serial.print(x);
  //Serial.print("\n");

  // initialize i2c as slave
  Wire.setSDA(4);
  Wire.setSCL(5);
  Wire.begin(SLAVE_ADDRESS+x);
  Wire.setClock( 400000UL);

  //Wire.setClock(400000); //400Khz i2c clock
  //Serial.print("Wire.begin(...)");
 
  // define callbacks for i2c communication
  Wire.onReceive(receiveEvent);
  Wire.onRequest(requestEvent);
}
 
int x    = matrix.width();
int pass = 0;
 
void loop() {
  delay(10);
}
 
char cmd[32];
 
// call back for receive data
void receiveEvent(int byteCount){
 
// command:
//   clear... 0x00
//   show ... 0x01
//   set1 ix,iy,r,g,b
//         ... 0x02  *,*,  *,*,*
//   setn ix,iy,n, r0,g0,b0, ..r(n-1),g(n-1),b(n-1)   n<=8
//         ... 0x03 *,*, *, *,*,*, ..., *,*,*
//   shift left 1 ... 0x04
  int i=0;
  while(Wire.available()) {
    cmd[i] = Wire.read();
    i++;
  }
  int n=i;
  /*
  for(i=0;i<n;i++){
    Serial.print(" "); Serial.print(cmd[i],HEX);
  }
  Serial.println(" ");
  */
  if(cmd[0]==0x00){
    for(int i=0;i<16;i++){
      for(int j=0;j<32;j++){
        buffer[j][i]=0;
      }
    }
    matrix.fillScreen(0);
  } 
  else
  if(cmd[0]==0x01){
    matrix.show();
    delay(5);
  }
  else
  if(cmd[0]==0x02){ //set1
  //   set1 ix,iy,r,g,b
  //         ... 0x02  *,*,  *,*,*
     int ix=cmd[1];
     int iy=cmd[2];
     int r=cmd[3];
     int g=cmd[4];
     int b=cmd[5];
     int16_t c=matrix.Color(r,g,b);
     matrix.drawPixel(iy,ix,c);
     buffer[iy][ix]=c;
  }
  else
  if(cmd[0]==0x03){
     int ix=cmd[1];
     int iy=cmd[2];
     int n=cmd[3];
     int rn[n];
     int gn[n];
     int bn[n];
     for(int i=0;i<n;i++){
        rn[i]=cmd[i*3+4];
        gn[i]=cmd[i*3+5];
        bn[i]=cmd[i*3+6];
     }
     for(int i=0;i<n;i++){
        int iyp=i%4;
        int ixp=i/4;
        int16_t c=matrix.Color(rn[i],gn[i],bn[i]);
        matrix.drawPixel(iy+iyp,ix+ixp,c);
        buffer[iy+iyp][ix+ixp]=c;
     }
  }
  else
  if(cmd[0]==0x04){ // shift left one bit
     for(int i=0;i<16;i++){
       for(int j=1;j<32;j++){
         buffer[j-1][i]=buffer[j][i];
       }
       for(int j=0;j<31;j++){
        matrix.drawPixel(j,i,buffer[j][i]);
       }
     }
  }
  else
  if(cmd[0]==0x05){ // shift right one bit
     for(int i=0;i<16;i++){
       for(int j=1;j<32;j++){
         buffer[32-j][i]=buffer[32-j-1][i];
       }
       for(int j=1;j<32;j++){
        matrix.drawPixel(j,i,buffer[j][i]);
       }
     }
  }
  else
  if(cmd[0]==0x06){ // brightness
    int bx=cmd[1];
    matrix.setBrightness(bx);
  }
}
 
 
void requestEvent(){
  Wire.write(status);
}
}}
----
#counter