项目代码 /********************************************************************************************************************************************************
* *
* Project: FFT Spectrum Analyzer *
* Target Platform: ESP32 *
* *
* Version: 1.0 *
* Hardware setup: See github *
* Spectrum analyses done with analog chips MSGEQ7 *
* *
* Mark Donners *
* The Electronic Engineer *
* Website: www.theelectronicengineer.nl *
* facebook: https://www.facebook.com/TheelectronicEngineer *
* youtube: https://www.youtube.com/channel/UCm5wy-2RoXGjG2F9wpDFF3w *
* github: https://github.com/donnersm *
* *
*********************************************************************************************************************************************************
* Version History *
* 1.0 First release, code extraced from 14 band spectrum analyzer 3.00 and modified to by used with FFT on a ESP32. No need for frequency board or *
* MCGEQ7 chips. *
* - HUB75 interface or *
* - WS2812 leds ( matrix/ledstrips) *
* - 8/16/32 or 64 channel analyzer *
* - calibration for White noise, pink noise, brown noise sensitivity included and selectable *
* - Fire screensaver *
* - Display of logo and interface text when used with HUB75 *
* *
*********************************************************************************************************************************************************
* Version FFT 1.0 release July 2021 *
*********************************************************************************************************************************************************
* Status | Description *
* Open | Some Hub75 displays use a combination of chipsets of are from a different productions batch which will not work with this libary *
* Open | Sometime the long press for activating/de-activating the autoChange Pattern mode doesn't work *
* Solved | When using 64 bands, band 0 is always at max value. This was caused by the array dize [64]-> solved by chnaging it to 65 *
* Not a bug | Different types of HUB75 displays require different libary settings.It is what it is and it all depends on what the distributer sends you.*
* | For into on the libary settings, see the library documentation on Github: https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-I2S-DMA *
* Wish | Web interface. not possible without some heavy workaround cant use WIFI and ADC at same time *
* *******************************************************************************************************************************************************
* People who inspired me to do this build and figure out how stuff works:
* Dave Plummer https://www.youtube.com/channel/UCNzszbnvQeFzObW0ghk0Ckw
* Mrfaptastic https://github.com/mrfaptastic
* Scott Marley https://www.youtube.com/user/scottmarley85
* Brian Lough https://www.youtube.com/user/witnessmenow
* atomic14 https://www.youtube.com/channel/UC4Otk-uDioJN0tg6s1QO9lw
*
* Make sure your arduino IDE settings: Compiler warnings is set to default to make sure the code will compile */
#define VERSION "V1.0"
#include <FastLED_NeoMatrix.h>
#include <arduinoFFT.h>
#include "I2SPLUGIN.h"
#include <math.h>
#include <ESP32-HUB75-MatrixPanel-I2S-DMA.h>
#include "FFT.h"
#include "LEDDRIVER.H"
#include "Settings.h"
#include "PatternsHUB75.h"
#include "PatternsLedstrip.h"
#include "fire.h"
#include "logos.h"
int skip=true;
int ButtonOnTimer=0;
int ButtonStarttime=0;
int ButtonSequenceCounter=0;
int ButtonOffTimer=0;
int ButtonStoptime=0;
int ButtonPressedCounter=0;
int ButtonReleasedCounter=0;
int ShortPressFlag=0;
int LongPressFlag=0;
int LongerPressFlag=0;
boolean Next_is_new_pressed= true;
boolean Next_is_new_release = true;
int PreviousPressTime=0;
#define up 1
#define down 0
int PeakDirection=0;
long LastDoNothingTime = 0; // only needed for screensaver
int DemoModeMem=0; // to remember what mode we are in when going to demo, in order to restore it after wake up
bool AutoModeMem=false; // same story
bool DemoFlag=false; // we need to know if demo mode was manually selected or auto engadged.
char LCDPrintBuf[30];
void setup() {
Serial.begin(115200);
Serial.println("Setting up Audio Input I2S");
setupI2S();
Serial.println("Audio input setup completed");
delay(1000);
#ifdef Ledstrip
SetupLEDSTRIP();
#endif
#ifdef HUB75
SetupHUB75();
if (kMatrixHeight>60){
dma_display->setBrightness8(100);
#if LogoBoot
drawLogo();
delay(2500);
#endif
}
#endif
}
void loop() {
size_t bytesRead = 0;
int TempADC=0;
if (skip==false)i2s_adc_disable(I2S_NUM_0);
skip=false; // we only want to skip this the very first loop run.
//Handle Userinterface
{
// set brightness and test if button is pressed
TempADC = analogRead(BRIGHTNESSPOT);
if (TempADC<10){ // ADC value < 10 so button is pressed
ButtonOffTimer=0;
ButtonOnTimer=millis()-ButtonStarttime;
ButtonStoptime=millis();
}
else { // no Button pressed so ADC value is not related to button and can be proccessed
ButtonOnTimer=0;
ButtonOffTimer=millis()-ButtonStoptime;
ButtonStarttime = millis();
// read potmeters and process
Peakdelay=map(analogRead(PEAKDELAYPOT),0,4095,1,100);
BRIGHTNESSMARK=map(TempADC,100,2100,BRIGHTNESSMIN,BRIGHTNESSMAX);
// dbgprint("potm:%d",BRIGHTNESSMARK);
#ifdef Ledstrip
FastLED.setBrightness(BRIGHTNESSMARK);
#endif
#ifdef HUB75
dma_display->setBrightness8(map(TempADC,100,2100,BRIGHTNESSMIN,BRIGHTNESSMAX));
#endif
}
if(ButtonOffTimer>ButtonTimeout){
ButtonStoptime=millis(); // time that no switch was presset will reset the counter.
ButtonSequenceCounter=0; // reset the sequencecounter
if (ShortPressFlag==1){
// Serial.printf("Short press detected\n");
buttonPushCounter = (buttonPushCounter + 1) % 13;
#ifdef HUB75
dma_display->clearScreen();
#endif
Serial.printf("Pattern Mode changed to: %d\n",buttonPushCounter);
ShortPressFlag=0;
}
}
if ((ButtonOnTimer>LongerPress)&&(ButtonOnTimer<(LongerPress+ShortPress))){LongerPressFlag=1;}
else if ((ButtonOnTimer>LongPress)&&(ButtonOnTimer<(LongPress+ShortPress))){LongPressFlag=1;}
else if ((ButtonOnTimer>ShortPress)&&(ButtonOnTimer<(2*ShortPress))){
ShortPressFlag=1;
if((millis()-PreviousPressTime)<ButtonSequenceRepeatTime){
ButtonSequenceCounter++;
dbgprint("Multible press counter: %d\n",ButtonSequenceCounter);
ShortPressFlag=0;
CalibrationType= (CalibrationType +1)% 4;
Serial.printf("Calibration table changed to: %s\n",Filtername[CalibrationType]);
sprintf(LCDPrintBuf,"Cal Filter: %s",Filtername[CalibrationType]);
DisplayPrint(LCDPrintBuf);
}
PreviousPressTime=millis();
}
if (LongerPressFlag==1){
dbgprint( "Longer press detected\n");
autoChangePatterns = !autoChangePatterns;
if(autoChangePatterns == true){
Serial.print("Patterns wil now change every few seconds\n");
DisplayPrint((char*) "Autochange ON");
}
else {
Serial.print("Automatically changing of pattern is now disabled\n");
DisplayPrint((char*) "Autochange OFF");
}
LongerPressFlag=0;
ShortPressFlag=0;
}
else if (LongPressFlag==1){
dbgprint("long press detected\n");
autoChangePatterns = !autoChangePatterns;
if(autoChangePatterns == true){
Serial.print("Patterns wil now change every few seconds\n");
DisplayPrint((char*) "Autochange ON");
}
else {
Serial.print("Automatically changing of pattern is now disabled\n");
DisplayPrint((char*)"Autochange OFF");
}
LongPressFlag=0;
ShortPressFlag=0;
}
} // end user interface
//############ Step 1: read samples from the I2S Buffer ##################
i2s_adc_enable(I2S_NUM_0);
i2s_read(I2S_PORT,
(void*)samples,
sizeof(samples),
&bytesRead, // workaround This is the actual buffer size last half will be empty but why?
portMAX_DELAY); // no timeout
if (bytesRead != sizeof(samples)){
Serial.printf("Could only read %u bytes of %u in FillBufferI2S()\n", bytesRead, sizeof(samples));
// return;
}
//############ Step 2: compensate for Channel number and offset, safe all to vReal Array ############
for (uint16_t i = 0; i < ARRAYSIZE(samples); i++) {
vReal[i] = offset-samples[i];
vImag[i] = 0.0; //Imaginary part must be zeroed in case of looping to avoid wrong calculations and overflows
#if PrintADCRAW
Serial.printf("%7d,",samples[i]);
#endif
#if VisualizeAudio
Serial.printf("%d\n",samples[i]);
#endif
}
#if PrintADCRAW
Serial.printf("\n");
#endif
//############ Step 3: Do FFT on the VReal array ############
// compute FFT
FFT.DCRemoval();
FFT.Windowing(vReal, SAMPLEBLOCK, FFT_WIN_TYP_HAMMING, FFT_FORWARD);
FFT.Compute(vReal, vImag, SAMPLEBLOCK, FFT_FORWARD);
FFT.ComplexToMagnitude(vReal, vImag, SAMPLEBLOCK);
FFT.MajorPeak(vReal, SAMPLEBLOCK, samplingFrequency);
for (int i = 0; i < numBands; i++) {
FreqBins[i] = 0;
}
//############ Step 4: Fill the frequency bins with the FFT Samples ############
float averageSum = 0.0f;
for (int i = 2; i < SAMPLEBLOCK / 2; i++){
averageSum+=vReal[i];
if (vReal[i] > NoiseTresshold){
int freq = BucketFrequency(i);
int iBand = 0;
while (iBand < numBands){
if (freq < BandCutoffTable[iBand])break;
iBand++;
}
if (iBand > numBands)iBand = numBands;
FreqBins[iBand]+= vReal[i];
// float scaledValue = vReal[i];
// if (scaledValue > peak[iBand])
// peak[iBand] = scaledValue;
}
}
// bufmd[0]=FreqBins[12];
#if PrintRAWBins
for ( int y=0; y<numBands;y++){
Serial.printf("%7.1f,",FreqBins[y]);
}
Serial.printf("\n");
#endif
//############ Step 5: Determine the VU value and mingle in the readout...( cheating the bands ) ############ Step
float t=averageSum / (SAMPLEBLOCK / 2);
gVU = max(t, (oldVU * 3 + t) / 4);
oldVU = gVU;
if(gVU>DemoTreshold)LastDoNothingTime = millis(); // if there is signal in any off the bands[>2] then no demo mode
// Serial.printf("gVu: %d\n",(int) gVU);
for(int j=0;j<numBands;j++){
if (CalibrationType==1)FreqBins[j]*= BandCalibration_Pink[j];
else if (CalibrationType==2)FreqBins[j]*= BandCalibration_White[j];
else if (CalibrationType==3)FreqBins[j]*= BandCalibration_Brown[j];
}
//*
//############ Step 6: Averaging and making it all fit on screen
//for (int i = 0; i < numBands; i++) {
//Serial.printf ("Chan[%d]:%d",i,(int)FreqBins[i]);
//FreqBins[i] = powf(FreqBins[i], gLogScale); // in case we want log scale..i leave it in here as reminder
// Serial.printf( " - log: %d \n",(int)FreqBins[i]);
// }
static float lastAllBandsPeak = 0.0f;
float allBandsPeak = 0;
//bufmd[1]=FreqBins[13];
//bufmd[2]=FreqBins[1];
for (int i = 0; i < numBands; i++){
//allBandsPeak = max (allBandsPeak, FreqBins[i]);
if (FreqBins[i]> allBandsPeak){
allBandsPeak = FreqBins[i];
}
}
if (allBandsPeak < 1)allBandsPeak = 1;
// The followinf picks allBandsPeak if it's gone up. If it's gone down, it "averages" it by faking a running average of GAIN_DAMPEN past peaks
allBandsPeak = max(allBandsPeak, ((lastAllBandsPeak * (GAIN_DAMPEN-1)) + allBandsPeak) / GAIN_DAMPEN); // Dampen rate of change a little bit on way down
lastAllBandsPeak = allBandsPeak;
if (allBandsPeak < 80000)allBandsPeak = 80000;
for (int i = 0; i < numBands; i++){
FreqBins[i] /= (allBandsPeak * 1.0f);
}
// Process the FFT data into bar heights
for (int band = 0; band < numBands; band++) {
int barHeight = FreqBins[band]*kMatrixHeight-1; //(AMPLITUDE);
if (barHeight > TOP-2) barHeight = TOP-2;
// Small amount of averaging between frames
barHeight = ((oldBarHeights[band] * 1) + barHeight) / 2;
// Move peak up
if (barHeight > peak[band]) {
peak[band] = min(TOP, barHeight);
PeakFlag[band]=1;
}
bndcounter[band]+=barHeight; // ten behoeve calibratie
// if there hasn't been much of a input signal for a longer time ( see settings ) go to demo mode
if ((millis() - LastDoNothingTime) > DemoAfterSec && DemoFlag==false)
{ dbgprint("In loop 1: %d", millis() - LastDoNothingTime);
DemoFlag=true;
// first store current mode so we can go back to it after wake up
DemoModeMem=buttonPushCounter;
AutoModeMem=autoChangePatterns;
autoChangePatterns=false;
buttonPushCounter=12;
#ifdef HUB75
dma_display->clearScreen();
#endif
dbgprint("Automode is turned of because of demo");
}
// Wait,signal is back? then wakeup!
else if (DemoFlag==true && (millis() - LastDoNothingTime) < DemoAfterSec )
{ //("In loop 2: %d", millis() - LastDoNothingTime);
// while in demo the democounter was reset due to signal on one of the bars.
// So we need to exit demo mode.
#ifdef HUB75
dma_display->clearScreen();
#endif
buttonPushCounter=DemoModeMem; // restore settings
dbgprint ("automode setting restored to: %d",AutoModeMem);
autoChangePatterns=AutoModeMem;// restore settings
DemoFlag=false;
}
#if BottomRowAlwaysOn
if (barHeight==0)barHeight=1; // make sure there is always one bar that lights up
#endif
// Now visualize those bar heights
switch (buttonPushCounter) {
case 0:
#ifdef HUB75
PeakDirection=down;
BoxedBars(band, barHeight);
BluePeak(band);
#endif
#ifdef Ledstrip
changingBarsLS(band, barHeight);
#endif
break;
case 1:
#ifdef HUB75
PeakDirection=down;
BoxedBars2(band, barHeight);
BluePeak(band);
#endif
#ifdef Ledstrip
TriBarLS(band, barHeight);
TriPeakLS(band);
#endif
break;
case 2:
#ifdef HUB75
PeakDirection=down;
BoxedBars3(band, barHeight);
RedPeak(band);
#endif
#ifdef Ledstrip
rainbowBarsLS(band, barHeight);
NormalPeakLS(band, PeakColor1);
#endif
break;
case 3:
#ifdef HUB75
PeakDirection=down;
RedBars(band, barHeight);
BluePeak(band);
#endif
#ifdef Ledstrip
purpleBarsLS(band, barHeight);
NormalPeakLS(band, PeakColor2);
#endif
break;
case 4:
#ifdef HUB75
PeakDirection=down;
ColorBars(band, barHeight);
#endif
#ifdef Ledstrip
SameBarLS(band, barHeight);
NormalPeakLS(band, PeakColor3);
#endif
break;
case 5:
#ifdef HUB75
PeakDirection=down;
Twins(band, barHeight);
WhitePeak(band);
#endif
#ifdef Ledstrip
SameBar2LS(band, barHeight);
NormalPeakLS(band, PeakColor3);
#endif
break;
case 6:
#ifdef HUB75
PeakDirection=down;
Twins2(band, barHeight);
WhitePeak(band);
#endif
#ifdef Ledstrip
centerBarsLS(band, barHeight);
#endif
break;
case 7:
#ifdef HUB75
PeakDirection=down;
TriBars(band, barHeight);
TriPeak(band);
#endif
#ifdef Ledstrip
centerBars2LS(band, barHeight);
#endif
break;
case 8:
#ifdef HUB75
PeakDirection=up;
TriBars(band, barHeight);
TriPeak(band);
#endif
#ifdef Ledstrip
centerBars3LS(band, barHeight);
#endif
break;
case 9:
#ifdef HUB75
PeakDirection=down;
centerBars(band, barHeight);
#endif
#ifdef Ledstrip
BlackBarLS(band, barHeight);
outrunPeakLS(band);
#endif
break;
case 10:
#ifdef HUB75
PeakDirection=down;
centerBars2(band, barHeight);
#endif
#ifdef Ledstrip
BlackBarLS(band, barHeight);
NormalPeakLS(band, PeakColor5);
#endif
break;
case 11:
#ifdef HUB75
PeakDirection=down;
BlackBars(band, barHeight);
DoublePeak(band);
#endif
#ifdef Ledstrip
BlackBarLS(band, barHeight);
TriPeak2LS(band);
#endif
break;
case 12:
#ifdef HUB75
make_fire(); // go to demo mode
#endif
#ifdef Ledstrip
matrix->fillRect(0, 0, matrix->width(), 1, 0x0000); // delete the VU meter
make_fire();
#endif
break;
}
// Save oldBarHeights for averaging later
oldBarHeights[band] = barHeight;
}
// for calibration
//bndcounter[h]+=barHeight;
if (loopcounter==256){
loopcounter=0;
#if CalibratieLog
Calibration();
for(int g=0;g<numBands;g++)bndcounter[g]=0;
#endif
}
loopcounter++;
if (buttonPushCounter!=12) DrawVUMeter(0); // Draw it when not in screensaver mode
#if PrintRAWBins
Serial.printf("\n");
//delay(10);
#endif
// Decay peak
EVERY_N_MILLISECONDS(Fallingspeed){
for (byte band = 0; band < numBands; band++){
if(PeakFlag[band]==1){
PeakTimer[band]++;
if (PeakTimer[band]> Peakdelay){PeakTimer[band]=0;PeakFlag[band]=0;}
}
else if ((peak[band] > 0) &&(PeakDirection==up)){
peak[band] += 1;
if (peak[band]>(kMatrixHeight+10))peak[band]=0;
} // when to far off screen then reset peak height
else if ((peak[band] > 0)&&(PeakDirection==down)){ peak[band] -= 1;}
}
colorTimer++;
}
EVERY_N_MILLISECONDS(10)colorTimer++; // Used in some of the patterns
EVERY_N_SECONDS(SecToChangePattern) {
// if (FastLED.getBrightness() == 0) FastLED.setBrightness(BRIGHTNESSMARK); //Re-enable if lights are "off"
if (autoChangePatterns){
buttonPushCounter = (buttonPushCounter + 1) % 12;
#ifdef HUB75
dma_display->clearScreen();
#endif
}
}
#ifdef Ledstrip
delay(1); // needed to give fastled a minimum recovery time
FastLED.show();
#endif
} // loop end
// BucketFrequency
//
// Return the frequency corresponding to the Nth sample bucket. Skips the first two
// buckets which are overall amplitude and something else.
int BucketFrequency(int iBucket){
if (iBucket <= 1)return 0;
int iOffset = iBucket - 2;
return iOffset * (samplingFrequency / 2) / (SAMPLEBLOCK / 2);
}
void DrawVUPixels(int i, int yVU, int fadeBy = 0){
CRGB VUC;
if (i>(PANE_WIDTH/3)){
VUC.r=255;
VUC.g=0;
VUC.b=0 ;
}
else if (i>(PANE_WIDTH/5)){
VUC.r=255;
VUC.g=255;
VUC.b=0;
}
else{ // green
VUC.r=0;
VUC.g=255;
VUC.b=0;
}
#ifdef Ledstrip
int xHalf = matrix->width()/2;
// matrix->drawPixel(xHalf-i-1, yVU, CRGB(0,100,0).fadeToBlackBy(fadeBy));
// matrix->drawPixel(xHalf+i, yVU, CRGB(0,100,0).fadeToBlackBy(fadeBy));
matrix->drawPixel(xHalf-i-1, yVU, CRGB(VUC.r,VUC.g,VUC.b).fadeToBlackBy(fadeBy));
matrix->drawPixel(xHalf+i, yVU, CRGB(VUC.r,VUC.g,VUC.b).fadeToBlackBy(fadeBy));
#endif
#ifdef HUB75
int xHalf = PANE_WIDTH/2;
dma_display->drawPixelRGB888(xHalf-i-2,yVU,VUC.r,VUC.g,VUC.b); //left side of screen line 0
dma_display->drawPixelRGB888(xHalf-i-2,yVU+1,VUC.r,VUC.g,VUC.b); //left side of screen line 1
dma_display->drawPixelRGB888(xHalf+i+1,yVU,VUC.r,VUC.g,VUC.b); // right side of screen line 0
dma_display->drawPixelRGB888(xHalf+i+1,yVU+1,VUC.r,VUC.g,VUC.b);// right side of screen line 1
#endif
}
void DrawVUMeter(int yVU){
static int iPeakVUy = 0; // size (in LED pixels) of the VU peak
static unsigned long msPeakVU = 0; // timestamp in ms when that peak happened so we know how old it is
const int MAX_FADE = 256;
#ifdef HUB75
for(int x=0; x<PANE_WIDTH;x++){
dma_display->drawPixelRGB888(x,yVU,0,0,0);
dma_display->drawPixelRGB888(x,yVU+1,0,0,0);
}
#endif
#ifdef Ledstrip
matrix->fillRect(0, yVU, matrix->width(), 1, 0x0000);
#endif
if (iPeakVUy > 1){
int fade = MAX_FADE * (millis() - msPeakVU) / (float) 1000;
DrawVUPixels(iPeakVUy, yVU, fade);
}
int xHalf = (PANE_WIDTH/2)-1;
int bars = map(gVU, 0, MAX_VU, 1, xHalf);
bars = min(bars, xHalf);
if(bars > iPeakVUy){
msPeakVU = millis();
iPeakVUy = bars;
}
else if (millis() - msPeakVU > 1000)iPeakVUy = 0;
for (int i = 0; i < bars; i++)DrawVUPixels(i, yVU);
}
void Calibration(void){
Serial.printf("BandCalibration_XXXX[%1d]=\n{",numBands);
long Totalbnd=0;
for (int g=0;g<numBands;g++){
if (bndcounter[g]>Totalbnd)Totalbnd=bndcounter[g];
}
for (int g=0;g<numBands;g++){
bndcounter[g]=Totalbnd/bndcounter[g];
Serial.printf(" %2.2f",bndcounter[g]);
if(g<numBands-1)Serial.printf(",");
else Serial.print(" };\n");
}
}
//**************************************************************************************************
// D B G P R I N T *
//**************************************************************************************************
// Send a line of info to serial output. Works like vsprintf(), but checks the DEBUG flag. *
// Print only if DEBUG flag is true. Always returns the formatted string. *
// Usage dbgprint("this is the text you want: %d", variable);
//**************************************************************************************************
void dbgprint(const char * format, ...) {
if (DEBUG) {
static char sbuf[DEBUG_BUFFER_SIZE]; // For debug lines
va_list varArgs; // For variable number of params
va_start(varArgs, format); // Prepare parameters
vsnprintf(sbuf, sizeof(sbuf), format, varArgs); // Format the message
va_end(varArgs); // End of using parameters
if (DEBUG) // DEBUG on?
{
Serial.print("Debug: "); // Yes, print prefix
Serial.println(sbuf); // and the info
}
// return sbuf; // Return stored string
}
}
void make_fire() {
uint16_t i, j;
if (t > millis()) return;
t = millis() + (1000 / FPS);
// First, move all existing heat points up the display and fade
for (i = rows - 1; i > 0; --i) {
for (j = 0; j < cols; ++j) {
uint8_t n = 0;
if (pix[i - 1][j] > 0)
n = pix[i - 1][j] - 1;
pix[i][j] = n;
}
}
// Heat the bottom row
for (j = 0; j < cols; ++j) {
i = pix[0][j];
if (i > 0) {
pix[0][j] = random(NCOLORS - 6, NCOLORS - 2);
}
}
// flare
for (i = 0; i < nflare; ++i) {
int x = flare[i] & 0xff;
int y = (flare[i] >> 8) & 0xff;
int z = (flare[i] >> 16) & 0xff;
glow(x, y, z);
if (z > 1) {
flare[i] = (flare[i] & 0xffff) | ((z - 1) << 16);
} else {
// This flare is out
for (int j = i + 1; j < nflare; ++j) {
flare[j - 1] = flare[j];
}
--nflare;
}
}
newflare();
// Set and draw
for (i = 0; i < rows; ++i) {
for (j = 0; j < cols; ++j) {
// matrix -> drawPixel(j, rows - i, colors[pix[i][j]]);
CRGB COlsplit=colors[pix[i][j]];
#ifdef HUB75
dma_display->drawPixelRGB888(j,rows - i,COlsplit.r,COlsplit.g,COlsplit.b);
#endif
#ifdef Ledstrip
matrix -> drawPixel(j, rows - i, colors[pix[i][j]]);
#endif
}
}
}
void drawLogo(void){
#ifdef HUB75
// logo is 46 width and 54 high
int i=0;
int xyStart[2]={(kMatrixWidth/2)-23,2};
CRGB pix;
for (int y=0;y<50;y++){
for (int x=0;x<46;x++){
pix=logo[i];
i++;
dma_display->drawPixelRGB888(x+xyStart[0],y+xyStart[1],pix.r,pix.g,pix.b);
}
}
dma_display->fillRect(5, 53, kMatrixWidth-10, 11, dma_display->color444(0, 0, 0));
delay(1000);
dma_display->setTextSize(1);
dma_display->setTextWrap(false);
dma_display->setCursor(10,55);
dma_display->print("Spectrum FFT ");
dma_display->print(VERSION);
delay(2000);
dma_display->fillRect(5, 53, kMatrixWidth-10, 11, dma_display->color444(0, 0, 0));
dma_display->setTextColor(dma_display->color444(15,15,0));
dma_display->setCursor(10,55);
dma_display->print(" Mark Donners ");
delay(2000);
#endif
}
void DisplayPrint(char * text){
#ifdef HUB75
dma_display->fillRect(8, 8, kMatrixWidth-16, 11, dma_display->color444(0,0 , 0));
dma_display->setTextSize(1);
dma_display->setTextWrap(false);
dma_display->setCursor(10,10);
dma_display->print(text);
delay(1000);
dma_display->fillRect(8, 8, kMatrixWidth-16, 11, dma_display->color444(0,0 , 0));
#endif
} 复制代码 
沪公网安备31011502402448
置顶卡
变色卡
千斤顶
萌萌哒新人
活跃会员
宣传大使
牛X认证
创作达人
ARD DAY
摸鱼团员
志“童”道合
编辑选择奖
