diagram.json


typedef union int16_ty
{
  int16_t d;
  byte    b[2];
};
typedef union float_ty
{
  float d;
  byte  b[4];
};

void write_int16(int pos, int16_t d)
{
  int16_ty loc;
  loc.d = d;
  EEPROM.write(pos++,loc.b[0]);
  EEPROM.write(pos++,loc.b[1]);
}
int16_t read_int16(int pos)
{
  int16_ty loc;
  loc.b[0] = EEPROM.read(pos++);
  loc.b[1] = EEPROM.read(pos++);
  return loc.d;
}

void write_float(int pos, float d)
{
  float_ty loc;
  loc.d = d;
  EEPROM.write(pos++,loc.b[0]);
  EEPROM.write(pos++,loc.b[1]);
  EEPROM.write(pos++,loc.b[2]);
  EEPROM.write(pos++,loc.b[3]);
}
float read_float(int pos)
{
  float_ty loc;
  loc.b[0] = EEPROM.read(pos++);
  loc.b[1] = EEPROM.read(pos++);
  loc.b[2] = EEPROM.read(pos++);
  loc.b[3] = EEPROM.read(pos++);
  return loc.d;
}

void commit()
{
  #if defined externRC
    end_RC();
    EEPROM.commit();
    delay(100);
    init_RC();
  #else
    EEPROM.commit();
   #endif
}

void ACC_Read()
{
  accZero[0] = read_int16(0);
  accZero[1] = read_int16(2);
  accZero[2] = read_int16(4);
}
void ACC_Store()
{
  write_int16(0, accZero[0]);
  write_int16(2, accZero[1]);
  write_int16(4, accZero[2]);
  EEPROM.write(63, 0x55);
  commit();
}

void PID_Read()
{
  yawRate       = read_float(10);
  rollPitchRate = read_float(14);
  P_PID         = read_float(18);
  I_PID         = read_float(22);
  D_PID         = read_float(26);
  P_Level_PID   = read_float(30);
  I_Level_PID   = read_float(34);
  D_Level_PID   = read_float(38);
}
void PID_Store()
{
  write_float(10,yawRate);
  write_float(14,rollPitchRate);
  write_float(18,P_PID);
  write_float(22,I_PID);
  write_float(26,D_PID);
  write_float(30,P_Level_PID);
  write_float(34,I_Level_PID);
  write_float(38,D_Level_PID);
  EEPROM.write(62, 0xAA);
  commit();
}


eprom.ino

#include <esp_now.h>
#include <WiFi.h>
#include <Wire.h>
#include "EEPROM.h"

#include "rc.h"

#define WIFI_CHANNEL 4
#define PWMOUT  // normal esc, uncomment for serial esc
#define LED 2
#define CALSTEPS 256 // gyro and acc calibration steps
//#define externRC // use of external RC receiver in ppmsum mode
//#define webServer // use of webserver to change PID

extern int16_t accZero[3];
extern float yawRate;
extern float rollPitchRate;
extern float P_PID;
extern float I_PID;
extern float D_PID;
extern float P_Level_PID;
extern float I_Level_PID;
extern float D_Level_PID;

volatile boolean recv;
//volatile int peernum = 0;
//esp_now_peer_info_t slave;

void recv_cb(const uint8_t *macaddr, const uint8_t *data, int len)
{
  recv = true;
  //Serial.print("recv_cb ");
  //Serial.println(len); 
  if (len == RCdataSize) 
  {
    for (int i=0;i<RCdataSize;i++) RCdata.data[i] = data[i];
  }
  /*
  if (!esp_now_is_peer_exist(macaddr))
  {
    Serial.println("adding peer ");
    esp_now_add_peer(macaddr, ESP_NOW_ROLE_COMBO, WIFI_CHANNEL, NULL, 0);
    peernum++;
  }
  */
};

#define ACCRESO 4096 // 
#define CYCLETIME 3
#define MINTHROTTLE 1090
#define MIDRUD 1495 // 
#define THRCORR 19

enum ang { ROLL,PITCH,YAW };

static int16_t gyroADC[3];
static int16_t accADC[3];
static int16_t gyroData[3];
static float angle[2]    = {0,0};  
extern int calibratingA;

#ifdef flysky
  #define ROL 0//крен
  #define PIT 1//тангаж
  #define THR 2//газ
 #define RUD 3//рыск
#else //orangerx
  #define ROL 1//крен  2
  #define PIT 2//тангаж3
  #define THR 0//газ   1
  #define RUD 3//рыск  4
#endif

#define AU1 4
#define AU2 5
static int16_t rcCommand[] = {0,0,0};

#define GYRO     0
#define STABI    1
static int8_t flightmode;
static int8_t oldflightmode;

boolean armed = false;
uint8_t armct = 0;
int debugvalue = 0;

void setup() 
{
  Serial.begin(115200); Serial.println();

  delay(3000); // give it some time to stop shaking after battery plugin
  MPU6050_init();
  MPU6050_readId(); // must be 0x68, 104dec
  
  EEPROM.begin(64);
  if (EEPROM.read(63) != 0x55) Serial.println("Need to do ACC calib");
  else ACC_Read(); // eeprom is initialized
  if (EEPROM.read(62) != 0xAA) Serial.println("Need to check and write PID");
  else PID_Read(); // eeprom is initialized

  
  WiFi.mode(WIFI_STA); // Station mode for esp-now 
  #if defined webServer
    setupwebserver();
    delay(500); 
  #endif


  #if defined externRC
    init_RC();
  #else
    Serial.printf("This mac: %s, ", WiFi.macAddress().c_str()); 
    Serial.printf(", channel: %i\n", WIFI_CHANNEL); 
    if (esp_now_init() != 0) Serial.println("*** ESP_Now init failed");
    esp_now_register_recv_cb(recv_cb);
  #endif

  delay(500); 
  pinMode(LED,OUTPUT);
  digitalWrite(LED,LOW);
  initServo();
}

uint32_t rxt; // receive time, used for falisave

void loop() 
{
  uint32_t now,mnow,diff; 
  now = millis(); // actual time
  if (debugvalue == 5) mnow = micros();

  #if defined webServer
    loopwebserver();
  #endif

  if (recv)
  {
    recv = false;  
    #if !defined externRC  
      buf_to_rc();
    #endif

    if (debugvalue == 4) Serial.printf("%4d %4d %4d %4d \n", rcValue[0], rcValue[1], rcValue[2], rcValue[3]); 
  
    if      (rcValue[AU1] < 1300) flightmode = GYRO;
    else                          flightmode = STABI;   
    if (oldflightmode != flightmode)
    {
      zeroGyroAccI();
      oldflightmode = flightmode;
    }

    if (armed) 
    {
      rcValue[THR]    -= THRCORR;
      rcCommand[ROLL]  = rcValue[ROL] - MIDRUD;
      rcCommand[PITCH] = rcValue[PIT] - MIDRUD;
      rcCommand[YAW]   = rcValue[RUD] - MIDRUD;
    }  
    else
    {  
      if (rcValue[THR] < MINTHROTTLE) armct++;
      if (armct >= 25) 
      { 
        digitalWrite(LED,HIGH); 
        armed = true;
      }
    }

    if (debugvalue == 5) Serial.printf("RC input ms: %d\n",now - rxt);
    rxt = millis();
  }

  Gyro_getADC();
  
  ACC_getADC();

  getEstimatedAttitude();

  pid();

  mix();

  writeServo();
  
  // Failsave part
  if (now > rxt+90)
  {
    rcValue[THR] = MINTHROTTLE;
    if (debugvalue == 5) Serial.printf("RC Failsafe after %d \n",now-rxt);
    rxt = now;
  }

  // parser part
  if (Serial.available())
  {
    char ch = Serial.read();
    // Perform ACC calibration
    if (ch == 10) Serial.println();
    else if (ch == 'A')
    { 
      Serial.println("Doing ACC calib");
      calibratingA = CALSTEPS;
      while (calibratingA != 0)
      {
        delay(CYCLETIME);
        ACC_getADC(); 
      }
      ACC_Store();
      Serial.println("ACC calib Done");
    }
    else if (ch == 'R')
    {
      Serial.print("Act Rate :  ");
      Serial.print(yawRate); Serial.print("  ");
      Serial.print(rollPitchRate); Serial.println();
      Serial.println("Act PID :");
      Serial.print(P_PID); Serial.print("  ");
      Serial.print(I_PID); Serial.print("  ");
      Serial.print(D_PID); Serial.println();
      Serial.print(P_Level_PID); Serial.print("  ");
      Serial.print(I_Level_PID); Serial.print("  ");
      Serial.print(D_Level_PID); Serial.println();
    }
    else if (ch == 'D')
    {
      Serial.println("Loading default PID");
      yawRate = 6.0;
      rollPitchRate = 5.0;
      P_PID = 0.15;    // P8
      I_PID = 0.00;    // I8
      D_PID = 0.08; 
      P_Level_PID = 0.35;   // P8
      I_Level_PID = 0.00;   // I8
      D_Level_PID = 0.10;
      PID_Store();
    }
    else if (ch == 'W')
    {
      char ch = Serial.read();
      int n = Serial.available();
      if (n == 3)
      {
        n = readsernum();        
        if      (ch == 'p') { P_PID       = float(n) * 0.01 + 0.004; Serial.print("pid P ");       Serial.print(P_PID); }
        else if (ch == 'i') { I_PID       = float(n) * 0.01 + 0.004; Serial.print("pid I ");       Serial.print(I_PID); }
        else if (ch == 'd') { D_PID       = float(n) * 0.01 + 0.004; Serial.print("pid D ");       Serial.print(D_PID); }
        else if (ch == 'P') { P_Level_PID = float(n) * 0.01 + 0.004; Serial.print("pid Level P "); Serial.print(P_Level_PID); }
        else if (ch == 'I') { I_Level_PID = float(n) * 0.01 + 0.004; Serial.print("pid Level I "); Serial.print(I_Level_PID); }
        else if (ch == 'D') { D_Level_PID = float(n) * 0.01 + 0.004; Serial.print("pid Level D "); Serial.print(D_Level_PID); }
        else Serial.println("unknown command");
      }
      else if (ch == 'S') { PID_Store(); Serial.print("stored in EEPROM"); }
      else 
      {
        Serial.println("Input format wrong");
        Serial.println("Wpxx, Wixx, Wdxx - write gyro PID, example: Wd13");
        Serial.println("WPxx, WIxx, WDxx - write level PID, example: WD21");
      }
    }
    else if (ch >= '0' && ch <='9') debugvalue = ch -'0';
    else
    {
      Serial.println("A - acc calib");
      Serial.println("D - write default PID");
      Serial.println("R - read actual PID");
      Serial.println("Wpxx, Wixx, Wdxx - write gyro PID");
      Serial.println("WPxx, WIxx, WDxx - write level PID");
      Serial.println("WS - Store PID in EEPROM");
      Serial.println("Display data:");
      Serial.println("0 - off");
      Serial.println("1 - Gyro values");
      Serial.println("2 - Acc values");
      Serial.println("3 - Angle values");
      Serial.println("4 - RC values");
      Serial.println("5 - Cycletime");
    }
  }

  if      (debugvalue == 1) Serial.printf("%4d %4d %4d \n", gyroADC[0], gyroADC[1], gyroADC[2]);  
  else if (debugvalue == 2) Serial.printf("%5d %5d %5d \n", accADC[0], accADC[1], accADC[2]);
  else if (debugvalue == 3) Serial.printf("%3f %3f \n", angle[0], angle[1]); 
  
  delay(CYCLETIME-1);  

  if (debugvalue == 5) 
  {
    diff = micros() - mnow;
    Serial.println(diff); 
  }
}

int readsernum()
{
  int num;
  char numStr[3];  
  numStr[0] = Serial.read();
  numStr[1] = Serial.read();
  return atol(numStr);
}


EspCopter32_0_3v.ino


enum cart { X,Y,Z };

#define GYRO_SCALE ((1998 * PI)/(32767.0f * 180.0f * 1000.0f)) // MPU6050
#define F_GYRO_SCALE 0.001 * GYRO_SCALE // in usec

/* Set the Gyro Weight for Gyro/Acc complementary filter
   Increasing this value would reduce and delay Acc influence on the output of the filter*/
#define GYR_CMPF_FACTOR 90
#define INV_GYR_CMPF_FACTOR   (1.0f / (GYR_CMPF_FACTOR  + 1.0f))

typedef struct fp_vector 
{		
  float X,Y,Z;		
} t_fp_vector_def;

typedef union 
{		
  float A[3];		
  t_fp_vector_def V;		
} t_fp_vector;


float InvSqrt (float x)
{ 
  union{  
    int32_t i;  
    float   f; 
  } conv; 
  conv.f = x; 
  conv.i = 0x5f3759df - (conv.i >> 1); 
  return 0.5f * conv.f * (3.0f - x * conv.f * conv.f);
}

// Rotate Estimated vector(s) with small angle approximation, according to the gyro data
void rotateV(struct fp_vector *v,float* delta) 
{
  fp_vector v_tmp = *v;
  v->Z -= delta[ROLL]  * v_tmp.X + delta[PITCH] * v_tmp.Y;
  v->X += delta[ROLL]  * v_tmp.Z - delta[YAW]   * v_tmp.Y;
  v->Y += delta[PITCH] * v_tmp.Z + delta[YAW]   * v_tmp.X;
}

static t_fp_vector EstG = { 0.0, 0.0, (float)ACCRESO };
static float accData[3]  = {0,0,0};

uint32_t  tnow; 

void getEstimatedAttitude()
{
  uint8_t axis;
  float deltaGyroAngle[3];
  uint32_t  tdiff; 
  float scale; 

  tdiff = micros() - tnow;
  tnow = micros();
  scale = (float)tdiff * F_GYRO_SCALE; 
  
  // Initialization
  for (axis = 0; axis < 3; axis++) 
  {
    deltaGyroAngle[axis] = (float)gyroADC[axis] * scale;
    accData[axis]  = (float)accADC[axis];
    gyroData[axis] = gyroADC[axis];
  }
  
  rotateV(&EstG.V,deltaGyroAngle); 
  
  // Apply complimentary filter (Gyro drift correction)
  for (axis = 0; axis < 3; axis++) 
    EstG.A[axis] = (EstG.A[axis] * GYR_CMPF_FACTOR + accData[axis]) * INV_GYR_CMPF_FACTOR;
  
  // Attitude of the estimated vector
  float sqGZ = sq(EstG.V.Z);
  float sqGX = sq(EstG.V.X);
  float sqGX_sqGZ = sqGX + sqGZ;
  float invmagXZ  = InvSqrt(sqGX_sqGZ);
  angle[ROLL]  = 572.95f * atan2(EstG.V.X , EstG.V.Z);
  angle[PITCH] = 572.95f * atan2(EstG.V.Y , invmagXZ*sqGX_sqGZ);
}


IMU.ino

#include <Wire.h>

#define MPU6050_ADDRESS 0x68 
  #define SMPLRT_DIV 0
  #define DLPF_CFG   4

#define ACC_ORIENTATION(X, Y, Z)  {accADC[ROLL]  = -X; accADC[PITCH]  = -Y; accADC[YAW]  =  Z;}
#define GYRO_ORIENTATION(X, Y, Z) {gyroADC[ROLL] =  Y; gyroADC[PITCH] = -X; gyroADC[YAW] = -Z;}

void i2cRead(uint8_t Address, uint8_t Register, uint8_t Nbytes, uint8_t* Data) 
{
  Wire.beginTransmission(Address);
  Wire.write(Register);
  Wire.endTransmission();

  Wire.requestFrom(Address, Nbytes);
  uint8_t index=0;
  while (Wire.available())
    Data[index++]=Wire.read();
}

void i2cWriteByte(uint8_t Address, uint8_t Register, uint8_t Data) 
{
  Wire.beginTransmission(Address);
  Wire.write(Register);
  Wire.write(Data);
  Wire.endTransmission();
}

#define ADDRESS 0x03
int calibratingG = CALSTEPS;
int calibratingA = 0;
int16_t gyroZero[3] = {0,0,0};
int16_t accZero[3] = {0,0,0};

// ****************
// GYRO common part
// ****************
void GYRO_Common() 
{
  static int32_t g[3];
  uint8_t axis, tilt=0;

  if (calibratingG>0) 
  {
    for (axis = 0; axis < 3; axis++) 
    {
      // Reset g[axis] at start of calibration
      if (calibratingG == CALSTEPS) g[axis]=0;
      // Sum up 512 readings
      g[axis] += gyroADC[axis];
      // Clear global variables for next reading
      gyroADC[axis]=0;
      gyroZero[axis]=0;
      if (calibratingG == 1) 
      {
        if (g[axis]>=0) g[axis] += CALSTEPS/2;
        else            g[axis] -= CALSTEPS/2;
        gyroZero[axis] = g[axis]/CALSTEPS;
      }
    }
    calibratingG--;
  }

  for (axis = 0; axis < 3; axis++)
    gyroADC[axis] = gyroADC[axis] - gyroZero[axis];
}

// ****************
// ACC common part
// ****************

void ACC_Common() 
{
  static int32_t a[3];
  
  if (calibratingA>0) 
  {
    for (uint8_t axis = 0; axis < 3; axis++) 
    {
      // Reset a[axis] at start of calibration
      if (calibratingA == CALSTEPS) a[axis]=0;
      // Sum up 512 readings
      a[axis] += accADC[axis];
      // Clear global variables for next reading
      accADC[axis]=0;
      accZero[axis]=0;
    }
    // Calculate average, shift Z down by acc_1G and store values in EEPROM at end of calibration
    if (calibratingA == 1) 
    {
      if (a[0] >= 0) a[0] += CALSTEPS/2; else a[0] -= CALSTEPS/2;
      if (a[1] >= 0) a[1] += CALSTEPS/2; else a[1] -= CALSTEPS/2;
      if (a[2] >= 0) a[2] += CALSTEPS/2; else a[2] -= CALSTEPS/2;
      accZero[0] = a[0]/CALSTEPS;
      accZero[1] = a[1]/CALSTEPS;
      accZero[2] = a[2]/CALSTEPS - ACCRESO;   
      Serial.print("  "); Serial.print(accZero[0]); Serial.println();
      Serial.print("  "); Serial.print(accZero[1]); Serial.println();
      Serial.print("  "); Serial.print(accZero[2]); Serial.println();
    }
    calibratingA--;
  }
  accADC[0] -=  accZero[0];
  accADC[1] -=  accZero[1];
  accADC[2] -=  accZero[2];
}

uint8_t rawADC[6];

void Gyro_getADC () 
{
  i2cRead(MPU6050_ADDRESS, 0x43,6,rawADC);
  GYRO_ORIENTATION( ((rawADC[0]<<8) | rawADC[1]) , 
                    ((rawADC[2]<<8) | rawADC[3]) ,
                    ((rawADC[4]<<8) | rawADC[5]) );
  GYRO_Common();
}

void ACC_getADC () 
{
  i2cRead(MPU6050_ADDRESS, 0x3B,6,rawADC);
  ACC_ORIENTATION( ((rawADC[0]<<8) | rawADC[1]) ,
                   ((rawADC[2]<<8) | rawADC[3]) ,
                   ((rawADC[4]<<8) | rawADC[5]) );
  ACC_Common();
}

void MPU6050_readId() 
{
  uint8_t id;
  i2cRead(MPU6050_ADDRESS, 0x75, 1, &id);
  if (id == 0x68) Serial.println("6050 ID OK");
  else Serial.println("6050 ID Failed");
}

void MPU6050_init()
{
  Wire.begin();
  Wire.setClock(400000);

  //Gyro_init
  i2cWriteByte(MPU6050_ADDRESS, 0x6B, 0x80);             //PWR_MGMT_1    -- DEVICE_RESET 1
  delay(50);
  
  i2cWriteByte(MPU6050_ADDRESS, 0x6B, 0x03);             //PWR_MGMT_1    -- SLEEP 0; CYCLE 0; TEMP_DIS 0; CLKSEL 3 (PLL with Z Gyro reference)
  i2cWriteByte(MPU6050_ADDRESS, 0x1A, DLPF_CFG);         //CONFIG        -- EXT_SYNC_SET 0 (disable input pin for data sync) ; default DLPF_CFG = 0 => ACC bandwidth = 260Hz  GYRO bandwidth = 256Hz)
  i2cWriteByte(MPU6050_ADDRESS, 0x1B, 0x18);             //GYRO_CONFIG   -- FS_SEL = 3: Full scale set to 2000 deg/sec
  delay(50);
  
  //ACC_init 
  i2cWriteByte(MPU6050_ADDRESS, 0x1C, 0x10);             //ACCEL_CONFIG 
  delay(50);
}


MPU6050.ino


float yawRate = 5.0;
float rollPitchRate = 5.0;

float P_PID = 0.14;    // P8
float I_PID = 0.00;    // I8
float D_PID = 0.08;    // D8

//0.8 0.01 0.5 a little shaky, on the edge
//0.8 0.01 0.9 a little shaky, good to fly

float P_Level_PID = 0.40;   // P8
float I_Level_PID = 0.01;   // I8
float D_Level_PID = 0.05;   // D8

static int16_t axisPID[3];
static int16_t lastError[3] = {0,0,0};
static float errorGyroI[3] = {0,0,0};
static float errorAngleI[3] = {0,0,0};

//----------PID controller----------
    
#define GYRO_I_MAX 10000.0
#define ANGLE_I_MAX 6000.0

int plotct;
int16_t deltab[6][3];
int8_t  deltabpt = 0;
int32_t deltasum[3];
  
void pid()
{
  uint8_t axis;
  float errorAngle;
  float AngleRateTmp, RateError;
  float PTerm,ITerm,DTerm;
  int16_t delta;

  
      //----------PID controller----------
      for(axis=0;axis<3;axis++) 
      {
        if (axis == 2) 
        { //YAW is always gyro-controlled 
          AngleRateTmp = yawRate * rcCommand[YAW];
          RateError = AngleRateTmp - gyroData[axis];
          PTerm = RateError * P_PID;
          
          delta           = RateError - lastError[axis];  
          lastError[axis] = RateError;
          deltasum[axis] += delta;
          deltasum[axis] -= deltab[deltabpt][axis];
          deltab[deltabpt][axis] = delta;  
          DTerm = deltasum[axis] * D_PID;
         
          ITerm = 0.0;
          
          deltabpt++;
          if (deltabpt >= 6) deltabpt = 0;
        } 
        else 
        {
          if (flightmode == GYRO) // GYRO mode 
          { 
            //control is GYRO based (ACRO - direct sticks control is applied to rate PID
            AngleRateTmp = rollPitchRate * rcCommand[axis];
            RateError = AngleRateTmp - gyroData[axis];
            //-----calculate P-term
            PTerm = RateError * P_PID;
            //-----calculate D-term
            delta           = RateError - lastError[axis];  
            lastError[axis] = RateError;

            deltasum[axis] += delta;
            deltasum[axis] -= deltab[deltabpt][axis];
            deltab[deltabpt][axis] = delta;
            
            DTerm = deltasum[axis] * D_PID;
            //-----calculate I-term
            ITerm = 0.0;
          }
          else // STABI mode
          {
            // calculate error and limit the angle to 45 degrees max inclination
            errorAngle = constrain(rcCommand[axis],-400,+400) - angle[axis]; //16 bits is ok here           
            //it's the ANGLE mode - control is angle based, so control loop is needed
            //-----calculate P-term
            PTerm = errorAngle * P_Level_PID;
            //-----calculate D-term
            delta = - gyroData[axis]; 
            DTerm = delta * D_Level_PID; 
            //-----calculate I-term
            errorAngleI[axis]  += errorAngle * I_Level_PID;
            errorAngleI[axis]  = constrain(errorAngleI[axis], -ANGLE_I_MAX, +ANGLE_I_MAX);
            ITerm = errorAngleI[axis] * 0.01;
          } 
        }
         
        //-----calculate total PID output
        axisPID[axis] =  PTerm + ITerm + DTerm;

        /*
        if (axis==2)
        {
          Serial.print(AngleRateTmp); Serial.print("  ");
          Serial.print(RateError); Serial.print("  ");
          Serial.print(PTerm); Serial.print("  ");
          Serial.println();
        }
        */
        /*
        if (axis==0)
        {
          Serial.print(PTerm); Serial.print("  ");
          Serial.print(ITerm); Serial.print("  ");
          Serial.print(DTerm); Serial.print("  ");
          if      (plotct == 0) Serial.print(-2000); 
          else if (plotct == 1) Serial.print( 2000); 
          else                  Serial.print( 0);
          if (plotct == 300) plotct = 0; else plotct++; 
          Serial.println();
        }
        */     
      }
}

void zeroGyroAccI()
{
  for(int axis=0;axis<3;axis++) 
  {
    errorAngleI[axis] = 0.0;
    errorGyroI[axis] = 0.0;
  } 
}


pid.ino

// Spec of RC data

#define CHANNELS 8
#define RC_IN_PIN 27 
#define RC_IN_GPIO GPIO_NUM_27
#pragma pack(push,1)//Выравнивание полей в структурах.
typedef struct 
{
  uint16_t Ch1    ; 
  uint16_t Ch2    ;
  uint16_t Ch3    ;
  uint16_t Ch4     ;
  uint16_t Ch5     ;
  uint16_t Ch6     ;
  uint16_t Ch7     ;
  uint16_t Ch8     ;
  uint8_t spare  ;
}Payload;
#pragma pack(pop)//Выравнивание полей в структурах.
#define RCdataSize sizeof(Payload)

typedef union
{
  Payload chans;
  uint8_t data[RCdataSize];
 // int data[RCdataSize];
} RCdataTY;

RCdataTY RCdata;

int16_t rcValue[CHANNELS];  // in us, center = 1500
uint8_t seqno;
//int seqno;


rc.h


#if defined externRC
//------------------------------------------------
  #define PPMIN_CHANNELS 6  // dont raise this

  volatile uint32_t last = 0;
  volatile uint8_t  chan = 0;

  IRAM_ATTR void rxInt() 
  {
    uint32_t now,diff; 
    if (!gpio_get_level(RC_IN_GPIO)) return; // because edge triggering on esp32 doesent work yet
    
    now = micros();
    diff = now - last;
    last = now;

    if      (diff > 3000) { chan = 0; } // Sync gap
    else if (chan < CHANNELS)
    {
      if (950<diff && diff<2050)
      {
        rcValue[chan] = diff;
        chan++;
      }
      else chan = CHANNELS; // skip, corrupted signal.
    }
    if (chan == PPMIN_CHANNELS) recv = true;
  }
  
  void init_RC()
  {
    pinMode(RC_IN_PIN,INPUT);
    attachInterrupt(RC_IN_PIN,rxInt,CHANGE);
  }
  void end_RC()
  {
    detachInterrupt(RC_IN_PIN);
  }
  
//------------------------------------------------
#endif

void buf_to_rc()
{
  uint8_t seq;
  rcValue[0] = RCdata.chans.Ch1;
  rcValue[1] = RCdata.chans.Ch2;
  rcValue[2] = RCdata.chans.Ch3;
  rcValue[3] = RCdata.chans.Ch4;
  rcValue[4] = RCdata.chans.Ch5;
  rcValue[5] = RCdata.chans.Ch6;
  rcValue[6] = RCdata.chans.Ch7;
  rcValue[7] = RCdata.chans.Ch8;
  seqno = RCdata.chans.spare;
}

static uint16_t servo[4];

void mix()
{
  if (armed & (rcValue[THR] > MINTHROTTLE))
  {
    servo[0] = constrain(rcValue[THR] - axisPID[ROLL] + axisPID[PITCH] - axisPID[YAW],1000,2000);
    servo[1] = constrain(rcValue[THR] - axisPID[ROLL] - axisPID[PITCH] + axisPID[YAW],1000,2000);
    servo[2] = constrain(rcValue[THR] + axisPID[ROLL] + axisPID[PITCH] + axisPID[YAW],1000,2000);
    servo[3] = constrain(rcValue[THR] + axisPID[ROLL] - axisPID[PITCH] - axisPID[YAW],1000,2000);
  }
  else 
  { 
    axisPID[0] = 0; axisPID[1] = 0; axisPID[2] = 0;
    servo[0] = 1000; servo[1] = 1000; servo[2] = 1000; servo[3] = 1000;
  }
  /*
  Serial.print(servo[0]); Serial.print("  ");
  Serial.print(servo[1]); Serial.print("  ");
  Serial.print(servo[2]); Serial.print("  ");
  Serial.print(servo[3]); Serial.println();
  */
}


#if defined PWMOUT //----------------------------------------------

const int MotPin0 = 32;  //HR
const int MotPin1 = 33;  //VR
const int MotPin2 = 25;  //HL
const int MotPin3 = 26;  //VL
const int MotChannel0 = 0;
const int MotChannel1 = 1;   
const int MotChannel2 = 2;
const int MotChannel3 = 3;

void writeServo() 
{
  ledcWrite(MotChannel0, servo[0]);
  ledcWrite(MotChannel1, servo[1]);
  ledcWrite(MotChannel2, servo[2]);
  ledcWrite(MotChannel3, servo[3]);
}

void initServo() 
{
  ledcSetup(MotChannel0, 500, 11); // 500 hz PWM, 11-bit resolution
  ledcSetup(MotChannel1, 500, 11); // 500 hz PWM, 11-bit resolution
  ledcSetup(MotChannel2, 500, 11); // 500 hz PWM, 11-bit resolution
  ledcSetup(MotChannel3, 500, 11); // 500 hz PWM, 11-bit resolution
  ledcAttachPin(MotPin0, MotChannel0); 
  ledcAttachPin(MotPin1, MotChannel1); 
  ledcAttachPin(MotPin2, MotChannel2); 
  ledcAttachPin(MotPin3, MotChannel3); 
}

#else //----------------------------------------------

uint8_t outmsg[5];

void writeServo()
{
  outmsg[0] = 0xF5;
  outmsg[1] = constrain((servo[0]-1000)>>2,0,0xF4);
  outmsg[2] = constrain((servo[1]-1000)>>2,0,0xF4);
  outmsg[3] = constrain((servo[2]-1000)>>2,0,0xF4);
  outmsg[4] = constrain((servo[3]-1000)>>2,0,0xF4);
  Serial1.write(outmsg,5);
}

void initServo()
{
  Serial1.begin(128000);
}

#endif //----------------------------------------------


rc.ino

#include <WebServer.h>

#ifdef webServer

const char GYRO_PID[] PROGMEM = R"=====(
<!DOCTYPE html>
<html>
<head>
<style>
form,input,h2
{
  color: black;
  text-align: center;
  font-size:6vw;
  font-family: monospace;
}
p
{
  text-align: center;
  font-size:6vw;
}

body
{
  background-color: lightblue;
}
</style>
</head>
<body>
<h2>EspCopter Gyro PID</h2>
<form action="/action_page">
  Gyro_P:  <input type="number" name="pid_p" value="%d" max="200" min="0">
  <br>
  Gyro_I:  <input type="number" name="pid_i" value="%d" max="200" min="0">
  <br>
  Gyro_D:  <input type="number" name="pid_d" value="%d" max="200" min="0">
  <br><br>
  <input type="submit" value="Submit">
</form> 
<p>
<a href="/gyro_page">Gyro PID</a>
<a href="/level_page">Level PID</a>
</p>
</body>
</html>
)=====";

const char ACC_PID[] PROGMEM = R"=====(
<!DOCTYPE html>
<html>
<head>
<style>
form,input,h2
{
  color: black;
  text-align: center;
  font-size:6vw;
  font-family: monospace;
}
p
{
  text-align: center;
  font-size:6vw;
}
body
{
  background-color: lightblue;
}
</style>
</head>
<body>
<h2>EspCopter Level PID</h2>
<form action="/action_level">
  Level_P:  <input type="number" name="lev_p" value="%d" max="200" min="0">
  <br>
  Level_I:  <input type="number" name="lev_i" value="%d" max="200" min="0">
  <br>
  Level_D:  <input type="number" name="lev_d" value="%d" max="200" min="0">
  <br><br>
  <input type="submit" value="Submit">
</form> 
<p>
<a href="/gyro_page">Gyro PID</a>
<a href="/level_page">Level PID</a>
</p>
</body>
</html>
)=====";

//SSID and Password of your WiFi router
const char* ssid = "FSM";
const char* password = "0101010101";

WebServer server(80); //Server on port 80

//===============================================================
// This routine is executed when you open its IP in browser
//===============================================================
void handleRoot() 
{
 char temp[1000];
 snprintf(temp,1000,GYRO_PID, int(P_PID*100.0+0.4),int(I_PID*100.0+0.4),int(D_PID*100.0+0.4));
 server.send(200, "text/html", temp); //Send web page
 Serial.println("root page served");
}

void handleGyro() 
{
 char temp[1000];
 snprintf(temp,1000,GYRO_PID, int(P_PID*100.0+0.4),int(I_PID*100.0+0.4),int(D_PID*100.0+0.4));
 server.send(200, "text/html", temp); //Send web page
 Serial.println("gyro page served");
}

void handleLevel() 
{
 char temp[1000];
 snprintf(temp,1000,ACC_PID, int(P_Level_PID*100.0+0.4),int(I_Level_PID*100.0+0.4),int(D_Level_PID*100.0+0.4));
 server.send(200, "text/html", temp); //Send web page
 Serial.println("level page served");
}

//===============================================================
// This routine is executed when you press submit
//===============================================================

void action_pid() 
{
 int p = server.arg("pid_p").toInt(); 
 int i = server.arg("pid_i").toInt(); 
 int d = server.arg("pid_d").toInt(); 

 P_PID = float(p) * 0.01 + 0.004;
 I_PID = float(i) * 0.01 + 0.004;
 D_PID = float(d) * 0.01 + 0.004;

 PID_Store();
 Serial.println("Gyro pid stored");
 handleGyro();
}

void action_level() 
{
  int pl = server.arg("lev_p").toInt(); 
  int il = server.arg("lev_i").toInt(); 
  int dl = server.arg("lev_d").toInt(); 

  P_Level_PID = float(pl) * 0.01 + 0.004;
  I_Level_PID = float(il) * 0.01 + 0.004;
  D_Level_PID = float(dl) * 0.01 + 0.004;

  PID_Store();
  Serial.println("Level pid stored");
  handleLevel();
}

/*
void action_calib() 
{
  Serial.println("Doing ACC calib");
  calibratingA = CALSTEPS;
  while (calibratingA != 0)
  {
    delay(CYCLETIME);
    ACC_getADC(); 
  }
  ACC_Store();
  Serial.println("ACC calib Done");
  handleCalib();
}
*/

//==============================================================
//                  SETUP
//==============================================================
void setupwebserver(void)
{  
  WiFi.begin(ssid, password);     //Connect to your WiFi router
  Serial.println("");

  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(500);
    Serial.print(".");
  }

  //If connection successful show IP address in serial monitor
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println("WiFi");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());  //IP address assigned to your ESP

  server.on("/", handleRoot);               //Which routine to handle at root location
  server.on("/gyro_page", handleGyro);      //Which routine to handle at gyro location
  server.on("/level_page", handleLevel);    //Which routine to handle at level location
  server.on("/action_page", action_pid);    //form action is handled here
  server.on("/action_level", action_level); //form action is handled here
  //server.on("/action_calib", action_calib); //form action is handled here

  server.begin();                  //Start server
  Serial.println("HTTP server started");
}

//==============================================================
//                     LOOP
//==============================================================
void loopwebserver(void) { server.handleClient(); }
void stopwebserver(void) { server.stop(); }

#endif


webserver.ino

/*
  EEPROM.h -ported by Paolo Becchi to Esp32 from esp8266 EEPROM
           -Modified by Elochukwu Ifediora <ifedioraelochukwuc@gmail.com>
           -Converted to nvs lbernstone@gmail.com

  Uses a nvs byte array to emulate EEPROM

  Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
  This file is part of the esp8266 core for Arduino environment.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "EEPROM.h"
#include <nvs.h>
#include <esp_partition.h>
#include <esp_log.h>

EEPROMClass::EEPROMClass(void)
  : _handle(0)
  , _data(0)
  , _size(0)
  , _dirty(false)
  , _name("eeprom")
{
}

EEPROMClass::EEPROMClass(uint32_t sector)
// Only for compatiility, no sectors in nvs!
  : _handle(0)
  , _data(0)
  , _size(0)
  , _dirty(false)
  , _name("eeprom")
{
}

EEPROMClass::EEPROMClass(const char* name)
  : _handle(0)
  , _data(0)
  , _size(0)
  , _dirty(false)
  , _name(name)
{
}

EEPROMClass::~EEPROMClass() {
  end();
}

bool EEPROMClass::begin(size_t size) {
  if (!size) {
      return false;
  }

  esp_err_t res = nvs_open(_name, NVS_READWRITE, &_handle);
  if (res != ESP_OK) {
      log_e("Unable to open NVS namespace: %d", res);
      return false;
  }

  size_t key_size = 0;
  res = nvs_get_blob(_handle, _name, NULL, &key_size);
  if(res != ESP_OK && res != ESP_ERR_NVS_NOT_FOUND) {
      log_e("Unable to read NVS key: %d", res);
      return false;
  }
  if (size < key_size) { // truncate
      log_w("truncating EEPROM from %d to %d", key_size, size);
      uint8_t* key_data = (uint8_t*) malloc(key_size);
      if(!key_data) {
         log_e("Not enough memory to truncate EEPROM!");
         return false;
      }
      nvs_get_blob(_handle, _name, key_data, &key_size);
      nvs_set_blob(_handle, _name, key_data, size);
      nvs_commit(_handle);
      free(key_data);
  }
  else if (size > key_size) { // expand or new
      size_t expand_size = size - key_size;
      uint8_t* expand_key = (uint8_t*) malloc(expand_size);
      if(!expand_key) {
         log_e("Not enough memory to expand EEPROM!");
         return false;
      }
      // check for adequate free space
      if(nvs_set_blob(_handle, "expand", expand_key, expand_size)) {
        log_e("Not enough space to expand EEPROM from %d to %d", key_size, size);
        free(expand_key);
        return false;
      }
      free(expand_key);
      nvs_erase_key(_handle, "expand");
      uint8_t* key_data = (uint8_t*) malloc(size);
      if(!key_data) {
         log_e("Not enough memory to expand EEPROM!");
         return false;
      }
      memset(key_data, 0xFF, size);
      if(key_size) {
        log_i("Expanding EEPROM from %d to %d", key_size, size);
	// hold data while key is deleted
        nvs_get_blob(_handle, _name, key_data, &key_size);
        nvs_erase_key(_handle, _name);
      } else {
        log_i("New EEPROM of %d bytes", size);
      }
      nvs_commit(_handle);
      nvs_set_blob(_handle, _name, key_data, size);
      free(key_data);
      nvs_commit(_handle);
  }

  if (_data) {
    delete[] _data;
  }

  _data = (uint8_t*) malloc(size);
  if(!_data) {
    log_e("Not enough memory for %d bytes in EEPROM", size);
    return false;
  }
  _size = size;
  nvs_get_blob(_handle, _name, _data, &_size);
  return true;
}

void EEPROMClass::end() {
  if (!_size) {
    return;
  }

  commit();
  if (_data) {
    delete[] _data;
  }
  _data = 0;
  _size = 0;

  nvs_close(_handle);
  _handle = 0;
}

uint8_t EEPROMClass::read(int address) {
  if (address < 0 || (size_t)address >= _size) {
    return 0;
  }
  if (!_data) {
    return 0;
  }

  return _data[address];
}

void EEPROMClass::write(int address, uint8_t value) {
  if (address < 0 || (size_t)address >= _size)
    return;
  if (!_data)
    return;

  // Optimise _dirty. Only flagged if data written is different.
  uint8_t* pData = &_data[address];
  if (*pData != value)
  {
    *pData = value;
    _dirty = true;
  }
}

bool EEPROMClass::commit() {
  bool ret = false;
  if (!_size) {
    return false;
  }
  if (!_data) {
    return false;
  }
  if (!_dirty) {
    return true;
  }

  esp_err_t err = nvs_set_blob(_handle, _name, _data, _size);
  if (err != ESP_OK) {
    log_e("error in write: %s", esp_err_to_name(err));
  } else {
    _dirty = false;
    ret = true;
  }

  return ret;
}

uint8_t * EEPROMClass::getDataPtr() {
  _dirty = true;
  return &_data[0];
}

/*
   Get EEPROM total size in byte defined by the user
*/
uint16_t EEPROMClass::length ()
{
  return _size;
}

/* 
   Convert EEPROM partition into nvs blob
   Call convert before you call begin
*/
uint16_t EEPROMClass::convert (bool clear, const char* EEPROMname, const char* nvsname)
{
  uint16_t result = 0;
  const esp_partition_t* mypart = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, EEPROMname);
  if (mypart == NULL) {
    log_i("EEPROM partition not found for conversion");
    return result;
  }

  size_t size = mypart->size;
  uint8_t* data = (uint8_t*) malloc(size);
  if (!data) {
    log_e("Not enough memory to convert EEPROM!");
    goto exit;
  }

  if (esp_partition_read (mypart, 0, (void *) data, size) != ESP_OK) {
    log_e("Unable to read EEPROM partition");
    goto exit;
  }

  bool empty;
  empty = true;
  for (int x=0; x<size; x++) {
    if (data[x] != 0xFF) {
      empty = false;
      break;
    }
  }
  if (empty) {
    log_i("EEPROM partition is empty, will not convert");
    goto exit;
  }

  nvs_handle handle;
  if (nvs_open(nvsname, NVS_READWRITE, &handle) != ESP_OK) {
    log_e("Unable to open NVS");
    goto exit;
  }
  esp_err_t err;
  err = nvs_set_blob(handle, nvsname, data, size);
  if (err != ESP_OK) {
    log_e("Unable to add EEPROM data to NVS: %s", esp_err_to_name(err));
    goto exit;
  }
  result = size;
 
  if (clear) {
    if (esp_partition_erase_range (mypart, 0, size) != ESP_OK) {
      log_w("Unable to clear EEPROM partition");
    }
  } 
exit:
  free(data);
  return result;
}

/*
   Read 'value' from 'address'
*/
uint8_t EEPROMClass::readByte (int address)
{
  uint8_t value = 0;
  return EEPROMClass::readAll (address, value);
}

int8_t EEPROMClass::readChar (int address)
{
  int8_t value = 0;
  return EEPROMClass::readAll (address, value);
}

uint8_t EEPROMClass::readUChar (int address)
{
  uint8_t value = 0;
  return EEPROMClass::readAll (address, value);
}

int16_t EEPROMClass::readShort (int address)
{
  int16_t value = 0;
  return EEPROMClass::readAll (address, value);
}

uint16_t EEPROMClass::readUShort (int address)
{
  uint16_t value = 0;
  return EEPROMClass::readAll (address, value);
}

int32_t EEPROMClass::readInt (int address)
{
  int32_t value = 0;
  return EEPROMClass::readAll (address, value);
}

uint32_t EEPROMClass::readUInt (int address)
{
  uint32_t value = 0;
  return EEPROMClass::readAll (address, value);
}

int32_t EEPROMClass::readLong (int address)
{
  int32_t value = 0;
  return EEPROMClass::readAll (address, value);
}

uint32_t EEPROMClass::readULong (int address)
{
  uint32_t value = 0;
  return EEPROMClass::readAll (address, value);
}

int64_t EEPROMClass::readLong64 (int address)
{
  int64_t value = 0;
  return EEPROMClass::readAll (address, value);
}

uint64_t EEPROMClass::readULong64 (int address)
{
  uint64_t value = 0;
  return EEPROMClass::readAll (address, value);
}

float_t EEPROMClass::readFloat (int address)
{
  float_t value = 0;
  return EEPROMClass::readAll (address, value);
}

double_t EEPROMClass::readDouble (int address)
{
  double_t value = 0;
  return EEPROMClass::readAll (address, value);
}

bool EEPROMClass::readBool (int address)
{
  int8_t value = 0;
  return EEPROMClass::readAll (address, value) ? 1 : 0;
}

size_t EEPROMClass::readString (int address, char* value, size_t maxLen)
{
  if (!value)
    return 0;

  if (address < 0 || address + maxLen > _size)
    return 0;

  uint16_t len;
  for (len = 0; len <= _size; len++)
    if (_data[address + len] == 0)
      break;

  if (address + len > _size)
    return 0;

  if (len > maxLen)
    return 0; //Maybe return part of the string instead?

  memcpy((uint8_t*) value, _data + address, len);
  value[len] = 0;
  return len;
}

String EEPROMClass::readString (int address)
{
  if (address < 0 || address > _size)
    return String();

  uint16_t len;
  for (len = 0; len <= _size; len++)
    if (_data[address + len] == 0)
      break;

  if (address + len > _size)
    return String();

  char value[len+1];
  memcpy((uint8_t*) value, _data + address, len);
  value[len] = 0;
  return String(value);
}

size_t EEPROMClass::readBytes (int address, void* value, size_t maxLen)
{
  if (!value || !maxLen)
    return 0;

  if (address < 0 || address + maxLen > _size)
    return 0;

  memcpy((void*) value, _data + address, maxLen);
  return maxLen;
}

template <class T> T EEPROMClass::readAll (int address, T &value)
{
  if (address < 0 || address + sizeof(T) > _size)
    return value;

  memcpy((uint8_t*) &value, _data + address, sizeof(T));
  return value;
}

/*
   Write 'value' to 'address'
*/
size_t EEPROMClass::writeByte (int address, uint8_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeChar (int address, int8_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeUChar (int address, uint8_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeShort (int address, int16_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeUShort (int address, uint16_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeInt (int address, int32_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeUInt (int address, uint32_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeLong (int address, int32_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeULong (int address, uint32_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeLong64 (int address, int64_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeULong64 (int address, uint64_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeFloat (int address, float_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeDouble (int address, double_t value)
{
  return EEPROMClass::writeAll (address, value);
}

size_t EEPROMClass::writeBool (int address, bool value)
{
  int8_t Bool;
  value ? Bool = 1 : Bool = 0;
  return EEPROMClass::writeAll (address, Bool);
}

size_t EEPROMClass::writeString (int address, const char* value)
{
  if (!value)
    return 0;

  if (address < 0 || address > _size)
    return 0;

  uint16_t len;
  for (len = 0; len <= _size; len++)
    if (value[len] == 0)
      break;

  if (address + len > _size)
    return 0;

  memcpy(_data + address, (const uint8_t*) value, len + 1);
  _dirty = true;
  return strlen(value);
}

size_t EEPROMClass::writeString (int address, String value)
{
  return EEPROMClass::writeString (address, value.c_str());
}

size_t EEPROMClass::writeBytes (int address, const void* value, size_t len)
{
  if (!value || !len)
    return 0;

  if (address < 0 || address + len > _size)
    return 0;

  memcpy(_data + address, (const void*) value, len);
  _dirty = true;
  return len;
}

template <class T> T EEPROMClass::writeAll (int address, const T &value)
{
  if (address < 0 || address + sizeof(T) > _size)
    return value;

  memcpy(_data + address, (const uint8_t*) &value, sizeof(T));
  _dirty = true;

  return sizeof (value);
}

#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_EEPROM)
EEPROMClass EEPROM;
#endif


EEPROM.cpp

/*
  EEPROM.h -ported by Paolo Becchi to Esp32 from esp8266 EEPROM
           -Modified by Elochukwu Ifediora <ifedioraelochukwuc@gmail.com>
           -Converted to nvs lbernstone@gmail.com

  Uses a nvs byte array to emulate EEPROM

  Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
  This file is part of the esp8266 core for Arduino environment.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef EEPROM_h
#define EEPROM_h
#ifndef EEPROM_FLASH_PARTITION_NAME
#define EEPROM_FLASH_PARTITION_NAME "eeprom"
#endif
#include <Arduino.h>

typedef uint32_t nvs_handle;

class EEPROMClass {
  public:
    EEPROMClass(uint32_t sector);
    EEPROMClass(const char* name);
    EEPROMClass(void);
    ~EEPROMClass(void);

    bool begin(size_t size);
    uint8_t read(int address);
    void write(int address, uint8_t val);
    uint16_t length();
    bool commit();
    void end();

    uint8_t * getDataPtr();
    uint16_t convert(bool clear, const char* EEPROMname = "eeprom", const char* nvsname = "eeprom");

    template<typename T>
    T &get(int address, T &t) {
      if (address < 0 || address + sizeof(T) > _size)
        return t;

      memcpy((uint8_t*) &t, _data + address, sizeof(T));
      return t;
    }

    template<typename T>
    const T &put(int address, const T &t) {
      if (address < 0 || address + sizeof(T) > _size)
        return t;

      memcpy(_data + address, (const uint8_t*) &t, sizeof(T));
      _dirty = true;
      return t;
    }

    uint8_t readByte(int address);
    int8_t readChar(int address);
    uint8_t readUChar(int address);
    int16_t readShort(int address);
    uint16_t readUShort(int address);
    int32_t readInt(int address);
    uint32_t readUInt(int address);
    int32_t readLong(int address);
    uint32_t readULong(int address);
    int64_t readLong64(int address);
    uint64_t readULong64(int address);
    float_t readFloat(int address);
    double_t readDouble(int address);
    bool readBool(int address);
    size_t readString(int address, char* value, size_t maxLen);
    String readString(int address);
    size_t readBytes(int address, void * value, size_t maxLen);
    template <class T> T readAll (int address, T &);

    size_t writeByte(int address, uint8_t value);
    size_t writeChar(int address, int8_t value);
    size_t writeUChar(int address, uint8_t value);
    size_t writeShort(int address, int16_t value);
    size_t writeUShort(int address, uint16_t value);
    size_t writeInt(int address, int32_t value);
    size_t writeUInt(int address, uint32_t value);
    size_t writeLong(int address, int32_t value);
    size_t writeULong(int address, uint32_t value);
    size_t writeLong64(int address, int64_t value);
    size_t writeULong64(int address, uint64_t value);
    size_t writeFloat(int address, float_t value);
    size_t writeDouble(int address, double_t value);
    size_t writeBool(int address, bool value);
    size_t writeString(int address, const char* value);
    size_t writeString(int address, String value);
    size_t writeBytes(int address, const void* value, size_t len);
    template <class T> T writeAll (int address, const T &);

  protected:
    nvs_handle _handle;
    uint8_t* _data;
    size_t _size;
    bool _dirty;
    const char* _name;
};

#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_EEPROM)
extern EEPROMClass EEPROM;
#endif

#endif
