LED Matrix mit GLEDIATOR/PixelController und Protokoll - Hilfe

/*
 * PixelInvaders tpm2.net implementation, Copyright (C) 2013 michael vogt <michu@neophob.com>
 *
 * If you like this, make sure you check out http://www.pixelinvaders.ch
 *
 * This file is part of PixelController.
 *
 * PixelController is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * PixelController is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *
 *
 */


#include <FastLED.h> //Neue FastLED Library V3 wird genutzt


//---- START USER CONFIG ----


#define DEBUG 1


//how many led pixels are connected
#define NUM_LEDS 102 //Anpassung auf 100 LEDs. Hier steht 102, da es etwas mit dem Protokoll der Pixel zu tun hat. Nehme ich hier 100, gehen in der "Testroutine", welche alle LEDs rot macht, die letzten 2 LEDs nicht an. Dies hat damit zu tun, dass bei den APAs zum Schluss des Datenstreams noch ein paar unnütze Daten reingeshiftet werden müssen.


// Teensy 3.0 has the LED on pin 13
const int ledPin = 13;


//---- END USER CONFIG ----


#define BAUD_RATE 230400


//define some tpm constants
#define TPM2NET_HEADER_SIZE 4
#define TPM2NET_HEADER_IDENT 0x9c
#define TPM2NET_CMD_DATAFRAME 0xda
#define TPM2NET_CMD_COMMAND 0xc0
#define TPM2NET_CMD_ANSWER 0xaa
#define TPM2NET_FOOTER_IDENT 0x36
#define DATA_PIN 8
#define CLOCK_PIN 9


//3 byte per pixel or 24bit (RGB)
#define BPP 3


//package size we expect.
#define MAX_PACKED_SIZE 520


#define PIXELS_PER_PACKET 170


// buffers for receiving and sending data
uint8_t packetBuffer[MAX_PACKED_SIZE]; //buffer to hold incoming packet
uint16_t psize;
uint8_t currentPacket;
uint8_t totalPacket;


CRGB leds[NUM_LEDS];


//********************************
// SETUP
//********************************
void setup() {
  Serial.begin(BAUD_RATE);
  Serial.flush();
  Serial.setTimeout(20);
#ifdef DEBUG
  Serial.println("HI");
#endif


  pinMode(ledPin, OUTPUT);
  debugBlink(500);


  memset(packetBuffer, 0, MAX_PACKED_SIZE);


  //LEDS.addLeds<WS2801>(leds, NUM_LEDS);
  FastLED.addLeds<APA102, DATA_PIN, CLOCK_PIN, BGR>(leds, NUM_LEDS); //Änderung hier: Nutzung des Daten Pins 8 und Clock Pin 9


  //Flickering issues?
  //...it turned out that as my PSU got hotter, the voltage was dropping towards the end of the LED strip.
  //Tried feeding power to both ends of the strip, only delayed the issue slightly.  Changed to a bigger PSU and fault went away
  //(dual ends feeding power).


  // For safety (to prevent too high of a power draw), the test case defaults to
  // setting brightness to 50% brightness
  LEDS.setBrightness(64);


  showInitImage();      // display some colors
}


//********************************
// LOOP
//********************************
void loop() {
  int16_t res = readCommand();
  if (res > 0) {
#ifdef DEBUG
    Serial.print("FINE: ");
    Serial.print(psize, DEC);
    Serial.print("/");
    Serial.print(currentPacket, DEC);
#if defined (CORE_TEENSY_SERIAL)
    Serial.send_now();
#endif


#endif
    digitalWrite(ledPin, HIGH);
    updatePixels();
    digitalWrite(ledPin, LOW);
  }
#ifdef DEBUG
  else {
    if (res != -1) {
      Serial.print("ERR: ");
      Serial.println(res, DEC);
#if defined (CORE_TEENSY_SERIAL)
      Serial.send_now();
#endif
    }
  }
#endif
}


//********************************
// UPDATE PIXELS
//********************************
void updatePixels() {
  uint8_t nrOfPixels = psize / 3;


  uint16_t ofs = 0;
  uint16_t ledOffset = PIXELS_PER_PACKET * currentPacket;


  for (uint16_t i = 0; i < nrOfPixels; i++) {
    leds[i + ledOffset] = CRGB(packetBuffer[ofs++], packetBuffer[ofs++], packetBuffer[ofs++]);
  }


  //update only if all data packets recieved
  if (currentPacket == totalPacket - 1) {
#ifdef DEBUG
    Serial.println("DRAW!");
#if defined (CORE_TEENSY_SERIAL)
    Serial.send_now();
#endif
#endif
    FastLED.show();
  } else {
#ifdef DEBUG
    Serial.print("NOTUPDATE: ");
    Serial.println(currentPacket, DEC);
#if defined (CORE_TEENSY_SERIAL)
    Serial.send_now();
#endif
#endif
  }
}


//********************************
// READ SERIAL PORT
//********************************
int16_t readCommand() {
  uint8_t startChar = Serial.read();
  if (startChar != TPM2NET_HEADER_IDENT) {
    return -1;
  }


  uint8_t dataFrame = Serial.read();
  if (dataFrame != TPM2NET_CMD_DATAFRAME) {
    return -2;
  }


  uint8_t s1 = Serial.read();
  uint8_t s2 = Serial.read();
  psize = (s1 << 8) + s2;
  if (psize < 6 || psize > MAX_PACKED_SIZE) {
    return -3;
  }


  currentPacket = Serial.read();
  totalPacket = Serial.read();


  //get remaining bytes
  uint16_t recvNr = Serial.readBytes((char *)packetBuffer, psize);
  if (recvNr != psize) {
    return -5;
  }


  uint8_t endChar = Serial.read();
  if (endChar != TPM2NET_FOOTER_IDENT) {
    return -6;
  }


  return psize;
}


// --------------------------------------------
//     create initial image
// --------------------------------------------
void showInitImage() {
  /*for (int i = 0 ; i < NUM_LEDS; i++ ) {
    leds[i] = CRGB(i & 255, (i >> 1) & 255, (i >> 2) & 255);
  }*/
  for (int i = 0; i < NUM_LEDS; i++)
  {
    leds[i] = CRGB::Red;
  }
  FastLED.show();
}


void debugBlink(uint8_t t) {
  digitalWrite(ledPin, HIGH);
  delay(t);
  digitalWrite(ledPin, LOW);
}

//#include "pt.h"
#include "FastLED.h"
/* LED und Arduino Variablen */
#define NUM_LEDS             102                // Number of LEDs
#define MAX_ARGS             500                 // Max Number of command arguments
#define BAUDRATE             500000             // Baudrate
#define SERIAL               Serial            // Serial port for communication
#define SERIAL_DEBUG         Serial             // Serial port for debugging
#define DATA_PIN             8                 // PIN where LEDs are connected/Used for TM1809/WS2811 chipsets, because they dont use SPI
#define CLOCK_PIN            9                  // used for some SPI chipsets, e.g. WS2801
#define BRIGHTNESS           127                // define global brightness 0..255
//#define taster               12
//choose your LED chipset in void setup()
enum Protocol
{
  // positions
  posStart      = 0,
  posType       = 1,
  posFsHigh     = 2,
  posFsLow      = 3,
  posData       = 4,
  // bytes
  tpm2Start     = 0xc9,
  tpm2DataFrame = 0xda,
  tpm2Command   = 0xc0,
  tpm2Answer    = 0xaa,
  tpm2End       = 0x36,
  tpm2Ack       = 0xAC
};
enum Mode
{
  mNone,
  mCommunication,
  mProgram
};
struct Data
{
  int pos;
  uint8_t type;
  uint16_t fs;
  uint8_t command;
  CRGB rgb[NUM_LEDS];
} data;
byte args[MAX_ARGS];
unsigned long lastDataAt = 0;
//int program = 0;
//int mode = mNone;
int effectDelay = 100;
//static struct pt pt1;
void setup()
{
  while (!Serial);
  oneColorAll(0, 0, 20);
  Serial.begin(BAUDRATE);
  delay(2000);
  oneColorAll(0, 0, 0);
  //memset(data.rgb, 0, sizeof(struct CRGB) * NUM_LEDS);
  FastLED.addLeds<APA102, DATA_PIN, CLOCK_PIN>(data.rgb, NUM_LEDS);
  FastLED.setBrightness(BRIGHTNESS);


}
/* loop
*/
void loop()
{
  if (Serial.available())
  {
    doCommunication();


  }
}
/* do communication
*/
void doCommunication()
{


  // read ...
  while (Serial.available() > 0)
  {


    byte val = Serial.read();


    if (val == tpm2Start || data.pos == posStart ) {  //&& val == tpm2Start                                 // Startbyte
      resetVars();


    }
    else if (val == tpm2Start)
      resetVars();


    else if (data.pos == posType && (val == tpm2DataFrame || val == tpm2Command))    // Block-Art
      data.type = val;
    else if (data.pos == posFsHigh)                                                  // Framesize (High Bit)
    {
      data.fs = (val << 8) & 0xFF00;
      if (data.fs > NUM_LEDS * 3)
      {


        resetVars();
        continue;
      }
    }
    else if (data.pos == posFsLow)                                                   // Framesize (Low byte)
    {
      data.fs += val & 0x00FF;
      if (data.fs > NUM_LEDS * 3)
      {


        resetVars();
        continue;
      }
    }
    else if (data.pos == posData + data.fs && val == tpm2End) {                       // End Byte
      parsePacket();
    }
    else if (data.pos >= posData && data.pos < posData + data.fs) {                   // Bytes zwischen Header und Ende lesen
      evaluateData(val);
    }


    data.pos++;
  }
}
/* evaluate data
*/
void evaluateData(byte val)
{
  if (data.type == tpm2DataFrame)        // frame data
  {
    uint8_t* rgb = (uint8_t*)data.rgb;
    rgb[data.pos - posData] = val;


  }


}
/* reset variables
*/
void resetVars()
{
  memset(&data, 0, sizeof(Data));
  //oneColorAll(0, 20, 0);
  //data.rgb = (struct CRGB*)FastSPI_LED.getRGBData();
  memset(data.rgb, 0,  NUM_LEDS * sizeof(struct CRGB));
}
/* parse packet
*/
void parsePacket()
{


  switch (data.type)
  {
    case tpm2DataFrame:
      {
        showLeds();
        //break;
      }
    default:
      ; //break;
  }
  Serial.write(tpm2Ack);
  resetVars();
  data.pos = -1;
}
/* set LED color
*/
void setLedColor(int led, uint8_t r, uint8_t g, uint8_t b)
{
  data.rgb[led].r = r;
  data.rgb[led].g = g;
  data.rgb[led].b = b;
}
/* one Color All
*/
void oneColorAll(uint8_t r, uint8_t g, uint8_t b)
{
  resetVars();
  for (int led = 0; led < NUM_LEDS; led++)
    setLedColor(led, r, g, b);
  showLeds();
  //effectDelay = 1000;
}
/* Output Leds
*/
void showLeds()
{
  FastLED.show();
}