Artnetwifi+SDread

//-------------------Set RTC-------------------------------------------------------
#include "time.h"


const char* ntpServer = "pool.ntp.org";
const long  gmtOffset_sec = 3600;
const int   daylightOffset_sec = 3600;

//------------------------------ WiFi details------------------------------

char ssid[] = "Weix";
char pass[] = "asdf1234!";
//const char *ssid     = "Weix";
//const char *password = "asdf1234!";

IPAddress local_ip(172, 20, 10, 10);
IPAddress gateway_ip(172, 20, 10, 1);
IPAddress subnet_ip(255, 255, 255, 240);


//----------------------------------BLYNK------------------------------------------
//#define BLYNK_TIMEOUT_MS  750  // must be BEFORE BlynkSimpleEsp8266.h doesn't work !!!
//#define BLYNK_HEARTBEAT   17 
#define BLYNK_PRINT Serial

#include <BlynkSimpleEsp32.h>
/*
#define BLYNK_USE_DIRECT_CONNECT

#include <BlynkSimpleEsp32_BLE.h>
#include <BLEDevice.h>
#include <BLEServer.h>
*/
//char auth[] = "4ef690bc3df245299df2307ee2ea8b41";
char auth[] = "7a38277d88df4359ae5e62cc646e8105";

BlynkTimer timer;
//--------------------------------Clock display---------------------------------

#include <Adafruit_GFX.h>
#include <FastLED.h>
#include <FastLED_NeoMatrix.h>

#include <Wire.h> // must be included here so that Arduino library object file references work
#include <RtcDS1307.h>
RtcDS1307<TwoWire> Rtc(Wire);


#define mw 80
#define mh 32
#define NUMMATRIX (mw*mh)
#define LED_RUN_LENGTH 16//number of leds per column

CRGB matrixleds[NUMMATRIX];

FastLED_NeoMatrix *matrix = new FastLED_NeoMatrix(matrixleds,16,16,5,2, 
  NEO_TILE_TOP + NEO_TILE_LEFT + NEO_TILE_ROWS +NEO_TILE_ZIGZAG+
     NEO_MATRIX_TOP     + NEO_MATRIX_LEFT +
    NEO_MATRIX_COLUMNS + NEO_MATRIX_ZIGZAG );

const uint16_t colors[] = {
  matrix->Color(255, 0, 0), matrix->Color(0, 255, 0), matrix->Color(0, 0, 255) };

//-------------------------------

#include <WiFi.h>
//#include <ESP8266WiFi.h>

#include <WiFiClient.h>
#include <Artnet.h>

#include "SD.h"
#include "SPI.h"
//#define FASTLED_ALLOW_INTERRUPTS 0
//#define INTERRUPT_THRESHOLD 1
#include "FastLED.h"
FASTLED_USING_NAMESPACE
#define FASTLED_SHOW_CORE 0


#define LED_WIDTH 80
#define LED_HEIGHT 32
#define NUM_LEDS LED_WIDTH*LED_HEIGHT
#define UNIVERSE_SIZE 170
#define PIXEL_PER_PIN NUM_LEDS/5 
/*we will  use 5 pins each pin will drive two 16x16 panel hence 512 pix  it will take 15ms to refresh your entire panel instead of 76ms
hence having a refresh rate of 65fps instead of 13fps*/
#define PIN1 2
#define PIN2 4
#define PIN3 27
#define PIN4 12
#define PIN5 13
//CRGB leds[NUM_LEDS];
uint8_t readbuffer[NUM_LEDS*3];
char filename[256];
char READ_NAME[]="savedata"; //the name of your save
Artnet artnet;

File root;
File  myFile;
static TaskHandle_t FastLEDshowTaskHandle = 0;
static TaskHandle_t FastLEDshowTaskHandle2 = 0;
static TaskHandle_t userTaskHandle = 0;

#define BRIGHTNESS bright

char datestring[20];
char blank[20];

int MatrixTime=1;
int Screen=1;
int bright=100;


BLYNK_WRITE(V0) 
{ Screen=param.asInt();
}

BLYNK_WRITE(V1) // 
{ MatrixTime=param.asInt();
}

BLYNK_WRITE(V2) // Slider - Brightnes
{
  bright = param.asLong();
}

void FastLEDshowESP32()
{
    if (userTaskHandle == 0) {
        const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 200 );
        // -- Store the handle of the current task, so that the show task can
        //    notify it when it's done
       // noInterrupts();
        userTaskHandle = xTaskGetCurrentTaskHandle();
        
        // -- Trigger the show task
        xTaskNotifyGive(FastLEDshowTaskHandle);

        // -- Wait to be notified that it's done
        ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS( 500 ));//portMAX_DELAY);
        //delay(100);
        //interrupts();
        userTaskHandle = 0;
    }
}



void FastLEDshowESP322()
{
    if (userTaskHandle == 0) {
        const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 200 );
        // -- Store the handle of the current task, so that the show task can
        //    notify it when it's done
       // noInterrupts();
        userTaskHandle = xTaskGetCurrentTaskHandle();
        
        // -- Trigger the show task
        xTaskNotifyGive(FastLEDshowTaskHandle2);
        //to thge contrary to the other one we do not wait for the display task to come back
    }
}

void FastLEDshowTask(void *pvParameters)
{
    const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 500 );
    // -- Run forever...
    for(;;) {
        // -- Wait for the trigger
        ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
        

    
        FastLED.show();

    
        xTaskNotifyGive(userTaskHandle);
    }
}



void FastLEDshowTask2(void *pvParameters)
{
    const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 500 );
    // -- Run forever...
    for(;;) {
        // -- Wait for the trigger
        ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
        

    
        FastLED.show();
  userTaskHandle=0;
    
       // xTaskNotifyGive(userTaskHandle);
    }
}

void RTCtime(){
///----------------------------------------RTC-Set---------------------------------------------
    /*
    Serial.print("compiled: ");
    Serial.print(__DATE__);
    Serial.println(__TIME__);
    */
    configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
    struct tm timeinfo;

    Rtc.Begin();
    
    RtcDateTime compiled;
    if(getLocalTime(&timeinfo))
    {

    compiled =RtcDateTime(
            (uint16_t )timeinfo.tm_year,
            (uint8_t) timeinfo.tm_mon,
            (uint8_t) timeinfo.tm_mday,
            (uint8_t) timeinfo.tm_hour,
            (uint8_t) timeinfo.tm_min,
            (uint8_t) timeinfo.tm_sec) ;
}
else
{
  Serial.println("error");
}


  if (!Rtc.IsDateTimeValid()) 
    {
        Serial.println("RTC lost confidence in the DateTime!");
        Rtc.SetDateTime(compiled);
    }

    if (!Rtc.GetIsRunning())
    {
        Serial.println("RTC was not actively running, starting now");
        Rtc.SetIsRunning(true);
    }

    RtcDateTime now = Rtc.GetDateTime();
    if (now < compiled) 
    {
        Serial.println("RTC is older than compile time!  (Updating DateTime)");
        Rtc.SetDateTime(compiled);
    }
    else if (now > compiled) 
    {
        Serial.println("RTC is newer than compile time. (this is expected)");
    }
    else if (now == compiled) 
    {
        Serial.println("RTC is the same as compile time! (not expected but all is fine)");
    }
    Rtc.SetSquareWavePin(DS1307SquareWaveOut_Low); 

}    
//--------------------------------------------------------------------------------------------------

void Wifi(){

WiFi.begin("Weix", "asdf1234!");
Blynk.config(auth);
//delay(1000);
  /*
if (WiFi.status() == WL_CONNECTED) {
    Blynk.config(auth);
    }*/
 
}


int WAIT_WIFI_MAX=500;
 int WAIT_WIFI = WAIT_WIFI_MAX;

bool reconnect=false;

//-----------------------------------------------SETUP---------------------------------------------
void setup() {
  
Serial.begin(115200);

//WiFi.config(local_ip, gateway_ip, subnet_ip);
delay(100);
WiFi.begin("Weix", "asdf1234!");
delay(1500);
Blynk.config(auth);
    Blynk.connect();
//Blynk.connectWiFi(ssid, pass);

//timer.setInterval(5000L, CheckConnection); 
 /* 
if (WiFi.status() == WL_CONNECTED) {
  //Blynk.connectWiFi(ssid, pass);
    
  reconnect=false;
    }
 
if (WiFi.status() != WL_CONNECTED)
{   Blynk.disconnect();
 reconnect=true;
}
*/
    Rtc.Begin();
    RTCtime();
  

artnet.begin(NUM_LEDS+160,UNIVERSE_SIZE,1);
//Blynk.begin(auth);


  xTaskCreatePinnedToCore(FastLEDshowTask2, "FastLEDshowTask2", 1000, NULL,3, &FastLEDshowTaskHandle2, FASTLED_SHOW_CORE);
   xTaskCreatePinnedToCore(FastLEDshowTask, "FastLEDshowTask", 3000, NULL,3, &FastLEDshowTaskHandle, FASTLED_SHOW_CORE);
  
  FastLED.setBrightness(BRIGHTNESS);
  
  /* WiFi.mode(WIFI_STA);
    
    Serial.printf("Connecting ");
    WiFi.begin("", "");

    while (WiFi.status() != WL_CONNECTED) {
      Serial.println(WiFi.status());
   
      
        delay(500);
        Serial.print(".");
    }

    Serial.println("");
    Serial.println("WiFi connected.");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());
*/
     if(!SD.begin(5,SPI,80000000)){
        Serial.println("Card Mount Failed");
        return;
    }
    uint8_t cardType = SD.cardType();

    if(cardType == CARD_NONE){
        Serial.println("No SD card attached");
        return;
    }

    memset(filename, 0, 255);
    sprintf(filename,"/%s.dat",READ_NAME);
 myFile = SD.open(filename);
    
    
  
  FastLED.addLeds<WS2812B, PIN1, GRB>(matrixleds, 0*PIXEL_PER_PIN, PIXEL_PER_PIN); 
  FastLED.addLeds<WS2812B, PIN2, GRB>(matrixleds, 1*PIXEL_PER_PIN, PIXEL_PER_PIN); 
  FastLED.addLeds<WS2812B, PIN3, GRB>(matrixleds, 2*PIXEL_PER_PIN, PIXEL_PER_PIN); 
  FastLED.addLeds<WS2812B, PIN4, GRB>(matrixleds, 3*PIXEL_PER_PIN, PIXEL_PER_PIN); 
  FastLED.addLeds<WS2812B, PIN5, GRB>(matrixleds, 4*PIXEL_PER_PIN, PIXEL_PER_PIN); 

  //FastLED.addLeds<NEOPIXEL,PIN3>(matrixleds, NUMMATRIX); 
  
  
  matrix->begin();
  matrix->setTextWrap(true);
  //matrix->setBrightness(100);  //doesnt work here
  matrix->setTextColor(colors[40]); //colors 0 is normal! donnt know what i did .. but colors[40] is disapeared fonts :)


}
bool artnetdisplay=false;

void loop() {   
  if((WiFi.status() != WL_CONNECTED)) //&&(!Blynk.connected()))
  {Blynk.disconnect();
  }
if((WiFi.status() == WL_CONNECTED)&&(!Blynk.connected())){
    Blynk.config(auth);
    Blynk.connect();
    }

if(WiFi.status() != WL_CONNECTED){
    Blynk.disconnect();
    WiFi.begin("Weix", "asdf1234!");
    while (WiFi.status() != WL_CONNECTED) {
      Serial.println(WiFi.status());
        delay(500);
        Serial.print(".");
    }
    Blynk.config(auth);
    Blynk.connect();
    }
    
 if(Blynk.connected()){
    Blynk.run();
    RTCtime();
  }

  
  FastLED.setBrightness(BRIGHTNESS);
/*
if((WiFi.status() == WL_CONNECTED) && (!Blynk.connected())){
    
    Serial.println("Not connected to Blynk server");
    delay(100); 
    Blynk.connect();  
    delay(100);
  }
   
  if (WiFi.status() != WL_CONNECTED) {
    if(WiFi.SSID() == "Weix"){
  
      Serial.println("Trying  to connect...");
    if(reconnect==false)
    {
      //Blynk.stop();
     //Blynk.disconnect();
     Serial.println("blynk disconnected");
     reconnect==true;
    }
    if(WAIT_WIFI>=WAIT_WIFI_MAX)
    {delay(100);
      WiFi.begin("Weix", "asdf1234!");
      delay(100);
       Blynk.config(auth);
         if(!Blynk.connected()){
    
    Serial.println("Not connected to Blynk server");
    delay(100); 
    Blynk.connect();  
    delay(100);
  }
      
      WAIT_WIFI=0;
    }
    WAIT_WIFI++;
    }
  }
    if (WiFi.status() == WL_CONNECTED) {
  WAIT_WIFI=WAIT_WIFI_MAX;
    if(reconnect==true) {
      
      if(!Blynk.connected()){
    
    Serial.println("Not connected to Blynk server"); 
    delay(100);
    Blynk.connect();  
    delay(100);
  }

      reconnect=false;
      RTCtime();
       }
      }
*/    
    
 RtcDateTime now = Rtc.GetDateTime();
 printDateTime(now); 
 
 if(Screen==1){Serial.println("SD-Card");
      artnetdisplay=false;
      if (myFile.available())
      {
      myFile.read(readbuffer,NUM_LEDS*sizeof(CRGB));
      memcpy(matrixleds,readbuffer,NUM_LEDS*sizeof(CRGB));
       
      }
         
      else
      {
      myFile.seek(0);
      }
 
    
 }
   else
   { Serial.println("Artnet-Wifi");
   if (WiFi.status() == WL_CONNECTED)
     {
       artnetdisplay=true;
            if(artnet.read()); 
        memcpy(matrixleds,artnet.getframe(),NUM_LEDS*sizeof(CRGB));
        
        
        artnet.resetsync();
     }
      
   }
 
    
if(MatrixTime==1){
    Serial.println("on");
    matrix->print (datestring);
   }
    else{
      Serial.println("off");
      matrix->print (blank);
      }
  if(artnetdisplay){
    FastLED.show();
      //FastLEDshowESP322();
  }else{
    FastLED.show();
    //FastLEDshowESP32();
  }
}

void printDateTime(const RtcDateTime& dt)
{  
sprintf(datestring,"%02u:%02u:%02u", dt.Hour(), dt.Minute(), dt.Second());
sprintf(blank,"");            
Serial.print(datestring);
matrix->clear();
 matrix->setCursor(0, 0);

}