Квант ARM

[KEN]

Один и тот-же пятак ношу с собой, один и тот-же датчик. Практически ни разу не видел что-бы меняли датчик во время копа, у каждого свой универсальный(имба) по его мнению датчик, он как родной, как аватар))) его понимаешь с полуслова). Под новый датчик надо привыкать, они ведь все по разному себя ведут.

Поисковые отряды это особая специфика поиска, свои приборы, свои методы, и тд.

[Boltyara]

Приборы все те же: Терки, Гареты 2500, Vallon"ы, АКА...

---

что-бы меняли датчик

А это и есть специфика копа. Я не по монеткам хожу...

[gal]

Вот такой Квант получился
   
справа внизу,  наушник беспроводной BT

[-vlad-]

Порог 31 ?

[p.lazarev]

Добрый день !
Очень понравился проект , хоче попробовать повторить ,но сам не в силах нарисовать layout !
Кому не жалко поделитесь layout .
Будет первый опыт с STM32 !

[-vlad-]

Моя в дипе, только ацп через переходник. Остальное все в дипе. Единственое,что очередность пайки деталей надо соблюдать, так как там 2 стороны. Первые паяются переходники сторон, потом детали с переходом(доступ жала паяльника) и бонус со штырями на ацп,stm и кнопки, так же первыми впаиваются.
Пришлось сначало штыри паять, потом на них уже одевать переходник с ацп и stm. Там 2 платки и обе 2-х сторонка, совмещать шаблоны надо перед травлением. Если не пугает все это , то выложу. 
Я не профи в рисовании и получилось как получилось...

[-vlad-]

Нагородил правда...

[gal]

---

поделитесь layout

посмотрите на страницу #10

---

Порог 31 ?

это когда проверял с пылесосом, а так то 7

[KEN]

У меня вообще на макетке, отходил с ним два сезона, без поломок и глюков.

[gal]

Кен
Можете помочь с программой Kvant Basic ARM ?
Вот кое что сделал, там надо исправить MENU и заменить EEPROM на внутренний

Код:

#include <EEPROM.h>
#include <libmaple/dma.h>
#include <libmaple/pwr.h>
#include <libmaple/scb.h>
#include <SPI.h>
#include <Wire.h>
#define F_CPU 72000000
#define DEVICE 0x50 //Адрес EEPROM
#include <LiquidCrystal.h>
//LiquidCrystal lcd(PA0, PA1, PA2, PA4, PA5, PB10);// ++++++++++++++++++++++++++++++++++++++++++
LiquidCrystal lcd(PB9, PA11, PB15, PB14, PB13, PB12); // o
#define SAMPLES_TX 64
#define dt (1.0/SAMPLES_TX)
#define F(x)(0.5*(1+sin(TWO_PI*x)))
#define VREF 2.048

//const int button_input[] = {PB11, PB13, PB14, PB15, PB12};//+++++++++++++++++++++++++++++++++++++++
const int button_input[] = {PB4, PB5, PB3, PA15, PA12}; //
bool Button_FLAG = false;

#define MENU_size 9

char* MENU_Strings[] =

{
//сделано
  "1# PHASE SET",   // ok 
  "2# TX CURRENT", //ok
  "3# RESONACE",   //ok
  // нужно
  "4# DC1",        //  lcd.print(U1);
  "5# Thr",        //  lcd.print(Thr);
  "6# Ubat",       //  lcd.print(bat, 1);
  "7# DC2",        //  lcd.print(U2);
  "8# icoil",      //  lcd.print(icoil / 50);
  "9# spare1",
  "10# spare2",
};
/////////
HardwareTimer Timer_4(4);// TX    PB8 T4C3
HardwareTimer Timer_3(3);// PB0 T3C3, PB1 T3C4

int Faza_b;
unsigned int micros_1, micros_2;
unsigned int millis_1, millis_2;
int adc_data_1, adc_data_2;
int val_TX[SAMPLES_TX];
int V_tic = 0;
int V_bat = 0;
int MENU_index = 1;

#define eeprom_adr 1
#define num_prof 4
#pragma pack(push, 1);
struct strMem    // EEPROM
{
  float amp_TX[num_prof];// amp TX
  int16_t F_TX[num_prof];            //F = 2000000 / (OCR1A = 1...65535)
  int16_t Comp_Phase[num_prof];
  int16_t need_phase[num_prof];
  int16_t Adjustment_Phase[num_prof];
  byte Threshold;
  byte Prof;               //1-2-3-4
  byte Mask;
  bool Otsechka1Sempla;
  bool LED_LCD;
} Mem;
#pragma pack(pop);


byte Speaker[] = {0b00011, 0b00101, 0b11001, 0b11001, 0b11001, 0b11001, 0b00101, 0b00011};
byte Battery[] = {0b01110, 0b11111, 0b10001, 0b10001, 0b10001, 0b10001, 0b10001, 0b11111};

const float Log_Tab[] = {0.09, 0.125, 0.18, 0.25, 0.35, 0.5, 0.7, 1.0};
const float Max_amp = 1.0F;
int  Old_A1, Old_B1, Old_A2, Old_B2, Old_M2;
int Max_M, Tic;
int Error;
int PP_Threshold = 10;
int Cut_Semp = 0;
int Max_m;
int old_G = 0;
int filtr_mem = 1;
int old_lev;
int vdi_mem;
int Xa, Ya;
unsigned int V_cut = 0;
/////////++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
float U1 = 0.0;
int analog_value;

float U2 = 0.0;
int analog_value2;
///////// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++===
const int OUT_TX = PB8;
dma_tube_config dma_cfg_TX, dma_cfg2;
timer_dev *dev_TX = PIN_MAP[OUT_TX].timer_device;//Timer4
uint8 cc_channel_TX = PIN_MAP[OUT_TX].timer_channel;//Channel3
void TX_conf()
{
  Timer_4.pause();
  Timer_3.pause();
  Timer_3.setCount(0);
  Timer_4.setCount(0);

  set_sin_tab(Mem.Comp_Phase[Mem.Prof], Mem.amp_TX[Mem.Prof]);

  timer_dma_set_base_addr(dev_TX,  TIMER_DMA_BASE_CCR3);
  timer_dma_set_burst_len(dev_TX, 1);
  timer_dma_enable_req(dev_TX, cc_channel_TX);
  timer_set_reload(dev_TX, Mem.F_TX[Mem.Prof]);
  timer_set_prescaler(dev_TX, 0);
  Timer_4.setMasterModeTrGo(TIMER_CR2_MMS_COMPARE_OC3REF);

  dma_init(DMA1);
  dma_disable(DMA1, DMA_CH5);
  dma_cfg_TX.tube_dst = &(dev_TX->regs.gen->DMAR);
  dma_cfg_TX.tube_dst_size = DMA_SIZE_32BITS;
  dma_cfg_TX.tube_src = val_TX;
  dma_cfg_TX.tube_src_size = DMA_SIZE_32BITS;
  dma_cfg_TX.tube_nr_xfers = SAMPLES_TX;
  dma_cfg_TX.tube_flags = DMA_CFG_SRC_INC | DMA_CFG_CIRC | DMA_CFG_CMPLT_IE;
  dma_cfg_TX.tube_req_src = DMA_REQ_SRC_TIM4_CH3;
  dma_cfg_TX.target_data = 0;
  dma_tube_cfg(DMA1, DMA_CH5, &dma_cfg_TX);
  dma_enable(DMA1, DMA_CH5);

  Timer_3.setPrescaleFactor(1);
  Timer_3.setOverflow((SAMPLES_TX / 2) - 1);
  timer_oc_set_mode(TIMER3, 3, TIMER_OC_MODE_TOGGLE, TIMER_OC_PE);
  timer_oc_set_mode(TIMER3, 4, TIMER_OC_MODE_TOGGLE, TIMER_OC_PE);
  Timer_3.setCompare(TIMER_CH3, 4);
  Timer_3.setCompare(TIMER_CH4, 20);
  Timer_3.setSlaveFlags( TIMER_SMCR_TS_ITR3 | TIMER_SMCR_SMS_EXTERNAL);

  Timer_3.refresh();
  Timer_4.refresh();
  Timer_3.resume();
  Timer_4.resume();
}

void set_sin_tab(int faze, float sin_amp)
{
  for (int i = 0; i < (SAMPLES_TX); i++)val_TX[i] = 1 + sin_amp * (Mem.F_TX[Mem.Prof] - 1) * F(dt * (i + faze));
}

//======================================================setup()==============================================================
void setup()
{
  Wire.begin(); delay (30);
  pinMode(PB11, OUTPUT_OPEN_DRAIN); digitalWrite(PB11, HIGH);
  pinMode(OUT_TX, PWM); //TX
  pinMode(PB0, PWM); //Yy
  pinMode(PB1, PWM); //Xy
  pinMode(PA0, INPUT_ANALOG);//V-bat
  pinMode(PA3, INPUT_ANALOG);//i-coil

  afio_cfg_debug_ports(AFIO_DEBUG_SW_ONLY);
  Serial.end();
  for (int i = 0; i < 5; i++) pinMode(button_input[i], INPUT_PULLUP);
  lcd.begin(16, 2);
  lcd.createChar(2, Speaker);
  lcd.createChar(1, Battery);
  lcd.setCursor(0, 0);
  lcd.print("Kvant ");

//  init_eeprom_mem();
  eepromRead_Str_Mem(eeprom_adr, DEVICE);

  TX_conf();
  LCD_start();
}

//=====================================================loop()============================================================
void loop()
{

  micros_2 = micros();
  if ( micros_2 - micros_1 >= 16666)
  {
    micros_1 = micros_2;
    {

    }

    V_bat_ind();

    millis_2 = millis() - millis_1;

    int button_check = check_button();
    if (button_check > 0 && Button_FLAG == false) {
      Button_CLK(button_check);
    }
    if (button_check == 0)Button_FLAG = false;
  }

  //DC
  /////////////////////
  analog_value = analogRead(PA6);
  U1 = (analog_value * 3.3) / 4.096;

  analog_value2 = analogRead(PA7);
  U2 = (analog_value2 * 3.3) / 4.096;


  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(" U1 ");
  lcd.print(U1, 0);  //DC1

  // Move it to #4 of menu instead of "4# FILTR SEL", currently not used
  lcd.setCursor(0, 1);
  lcd.print(" U2 ");
  lcd.print(U2, 0);  //DC2

  lcd.setCursor(10, 0);
  lcd.print(" T ");
  lcd.print(Mem.Threshold);
  delay(30);
  ////////////////////

}

//=======================================================================================================================

//--------------------------------------------------Servis_ind()----------------------------------------------------------------------
void Servis_ind()
{
  int icoil = 0;
  V_cut = 0;
  lcd.clear();
  while (true)
  {
    // amplitude up/down
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++

    if ( check_button() == false) {
      Button_FLAG = false;
    }
    if ( Button_read(1)) {
      Button_enter();
      Mem.F_TX[Mem.Prof]++;
      timer_set_reload(dev_TX, Mem.F_TX[Mem.Prof]);
      set_sin_tab(Mem.Comp_Phase[Mem.Prof], Mem.amp_TX[Mem.Prof]);
    }
    if ( Button_read(3)) {
      Button_enter();
      Mem.F_TX[Mem.Prof]--;
      timer_set_reload(dev_TX, Mem.F_TX[Mem.Prof]);
      set_sin_tab(Mem.Comp_Phase[Mem.Prof], Mem.amp_TX[Mem.Prof]);
    }
    if ( Button_read(4)) {
      Button_enter();
      break;
    }
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    lcd.setCursor(0, 0);
    lcd.print(F_CPU / ((Mem.F_TX[Mem.Prof] + 1)*SAMPLES_TX));
    lcd.print(" Hz ");

    icoil += I_coil();
    if (V_tic == 49)
    {
      lcd.setCursor(9, 0);
      lcd.print("b=");
      //       lcd.print(ads1220());
      lcd.print("   ");

      lcd.setCursor(0, 1);
      lcd.print(icoil / 50);
      lcd.print("mA  ");
      icoil = 0;

      lcd.setCursor(6, 1);
      if (Faza_b > 0)lcd.print("+");
      lcd.print(Faza_b); lcd.print(char(223));
      if (Faza_b < 10 && Faza_b > -10)lcd.print("  ");
      if (Faza_b < 100 && Faza_b > -100)lcd.print(" ");
    }
    V_bat_ind();
    delay (10);
  }
}

//---------------------------------------------------V_bat_ind()-------------------------------------------------------------------------
void V_bat_ind()
{
  V_bat += analogRead(PA0);
  V_tic++;
  if (V_tic == 50)
  {
    float bat = V_bat / 14724.0;
    lcd.setCursor(12, 1); lcd.print(bat, 1);
    V_cut++;

    V_tic = 0;
    V_bat = 0;
  }
}


void DC1DC2()
{
analog_value = analogRead(PA6);
  U1 = (analog_value * 3.3) / 4.096;

  analog_value2 = analogRead(PA7);
  U2 = (analog_value2 * 3.3) / 4.096;


  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(" U1 ");
  lcd.print(U1, 0);  //DC1

  lcd.setCursor(0, 1);
  lcd.print(" U2 ");
  lcd.print(U2, 0);  //DC2

  lcd.setCursor(10, 0);
  lcd.print(" T ");
  lcd.print(Mem.Threshold);
  delay(30);

}

//-----------------------------------------------------I_coil()----------------------------------------------------------------------------

int I_coil()
{
#define smp 250
  unsigned int *adc = new unsigned int[smp];
  unsigned int mid = 0;
  int i_tx = 0;
  int adc_red;

  adc_dev *dev = PIN_MAP[PA3].adc_device; // input AC
  adc_reg_map *regs = dev->regs;
  adc_set_reg_seqlen(dev, 1);
  regs->SQR3 = PIN_MAP[PA3].adc_channel;

  for (int i = 0; i < smp; i++)
  {
    regs->CR2 |= ADC_CR2_SWSTART;
    while (!(regs->SR & ADC_SR_EOC));
    adc_red = (uint16)(regs->DR & ADC_DR_DATA);

    mid += adc_red;
    adc[i] = adc_red;
  }
  mid /= smp;
  for (int i = 0; i < smp; i++)
  {
    adc_red = abs(adc[i] - mid);
    if (adc_red > i_tx)i_tx = adc_red;
  }
  i_tx /= 2;

  delete[] adc;
  return i_tx;
}

//-------------------------------------------------F_scan()-------------------------------------------------------------
void F_scan()
{
  Mem.Comp_Phase[Mem.Prof] = 0;
  Mem.amp_TX[Mem.Prof] = 0.7;
  int i_max = 0;
  int i_tx;
  int mem_i;
  lcd.clear();
  lcd.setCursor(0, 0); lcd.print("TX:");
  lcd.setCursor(0, 1); lcd.print("resonance search");

  for (int i = 285; i > 60; i--)
  {
    timer_set_reload(dev_TX, i);
    Mem.F_TX[Mem.Prof] = i;
    set_sin_tab(Mem.Comp_Phase[Mem.Prof], Mem.amp_TX[Mem.Prof]);
    delay(3);
    i_tx = I_coil();
    if (i_tx > i_max) {
      i_max = i_tx;
      mem_i = i;
      lcd.setCursor(3, 0);
      lcd.print( F_CPU / ((i + 1)*SAMPLES_TX) );
    }
  }

  Mem.F_TX[Mem.Prof] = mem_i;
  timer_set_reload(dev_TX, Mem.F_TX[Mem.Prof]);
  set_sin_tab(Mem.Comp_Phase[Mem.Prof], Mem.amp_TX[Mem.Prof]);

  lcd.clear();
  Servis_ind();
  coil_current();
  ferit_cal();
  eepromWrite_Str_Mem(eeprom_adr, DEVICE); //  EEPROM
  delay(10);

}
//-------------------------------------------------coil_current-----------------------------------------------------------

void coil_current()
{
  int tic = 0;
  int icoil;
  lcd.clear();
  lcd.setCursor(0, 0); lcd.print("TX current=");
  //////////
  //if ( digitalRead(button_input[1]) == false && Button_FLAG == false)
  if (digitalRead(PB5) == LOW)
  {
    //    BEEP(1000);
    //Button_FLAG = true;
    Mem.amp_TX[Mem.Prof] -= 0.0625;      
    if (Mem.amp_TX[Mem.Prof] < 0.1)Mem.amp_TX[Mem.Prof] = 0.1;
    set_sin_tab(Mem.Comp_Phase[Mem.Prof], Mem.amp_TX[Mem.Prof]);
  }
  /////////
  while (true)
  {

    if ( check_button() == false) {
      Button_FLAG = false;
    }

    if ( digitalRead(button_input[1]) == false && Button_FLAG == false)
    {
      //    BEEP(1000);
      Button_FLAG = true;
      Mem.amp_TX[Mem.Prof] -= 0.0625;       
      if (Mem.amp_TX[Mem.Prof] < 0.1)Mem.amp_TX[Mem.Prof] = 0.1;
      set_sin_tab(Mem.Comp_Phase[Mem.Prof], Mem.amp_TX[Mem.Prof]);
    }
    //beep
    //+++++++++++++++++++++++++++++++
    //if( digitalRead(button_input[4])==false&&Button_FLAG==false) {BEEP(1000);Button_FLAG=true; break;}
    if ( digitalRead(button_input[4]) == false && Button_FLAG == false) {
      Button_FLAG = true;
      break;
    }
    //+++++++++++++++++++++++++++++++++++++++++++
    if ( digitalRead(button_input[3]) == false && Button_FLAG == false)

    {
      //    BEEP(1000);
      Button_FLAG = true;
      Mem.amp_TX[Mem.Prof] += 0.0625;        
      if (Mem.amp_TX[Mem.Prof] > 1.0)Mem.amp_TX[Mem.Prof] = 1.0;
      set_sin_tab(Mem.Comp_Phase[Mem.Prof], Mem.amp_TX[Mem.Prof]);
    }

    icoil += I_coil();

    if (tic == 256)
    {
      lcd.setCursor(11, 0);
      icoil /= 256;
      lcd.print(icoil); lcd.print("mA ");
      int curent_bar = Mem.amp_TX[Mem.Prof] / 0.0625F;
      lcd.setCursor(0, 1);
      for (int i = 0; i < curent_bar; i++) {
        lcd.print(char(255));
      }
      for (int i = curent_bar; i < 16; i++) lcd.print(' ');
      tic = 0;
      icoil = 0;
    }
    tic++;
  }
  lcd.clear();
}

//------------------------------------------------phase_sett()---------------------------------------------------------------------------
void phase_sett()
{
  lcd.clear();
  while (true)
  {

    lcd.setCursor(0, 0); lcd.print("Fer");

    if ( check_button() == false) {
      Button_FLAG = false;
    }
    if ( Button_read(0)) {
      Button_enter();
      ferit_cal();

    }

    if ( Button_read(4)) {
      Button_enter();
      break;
    }
  }
}

//---------------------------------------------ferit_cal()----------------------------------------------------------------------
void ferit_cal()
{
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Ferit.Phase#***");
  lcd.setCursor(0, 1);
  lcd.print("Adj.Phase#");
  lcd.print(Mem.Adjustment_Phase[Mem.Prof]);

  bool Flag = false;
#define k 0.1

  while (true)
  {
    micros_2 = micros();
    if ( micros_2 - micros_1 >= 20000)
    {
      micros_1 = micros_2;
      if ( check_button() == false) {
        Button_FLAG = false;
      }
      if ( Button_read(0)) {
        Button_enter();
        Mem.Comp_Phase[Mem.Prof] = 0;
        set_sin_tab(Mem.Comp_Phase[Mem.Prof], Mem.amp_TX[Mem.Prof]);
        delay (500);
      }
      if ( Button_read(1)) {
        Button_enter();
        // Mem.amp_TX[Mem.Prof] += 0.0625;
        Mem.Comp_Phase[Mem.Prof]++;         //++++++++++++++++++++++++++++++++  phase up
        // Mem.Comp_Phase[Mem.Prof] += 0;
        //  Mem.Comp_Phase[Mem.Prof]++ = 1;

        set_sin_tab(Mem.Comp_Phase[Mem.Prof], Mem.amp_TX[Mem.Prof]);
        delay (100);
      }
      if ( Button_read(2)) {
        Button_enter();
        //        comp_phase(VDI_Fer);
      }
      if ( Button_read(3)) {
        Button_enter();
        Mem.Comp_Phase[Mem.Prof]--;       //++++++++++++++++++++++++++++++++++  phase down
        set_sin_tab(Mem.Comp_Phase[Mem.Prof], Mem.amp_TX[Mem.Prof]);
        delay (100);
      }
      if ( Button_read(4)) {
        Button_enter();
        break;
      }

    }
  }

  lcd.clear();
}
//------------------------------------check_button()-------------------------------------------------------------------------------------------
int check_button()
{
  int n = 0;
  for (int i = 0; i < 5; i++)if (digitalRead(button_input[i]) == false)n = i + 1;
  return n;
}
//---------------------------------------Button_CLK-------------------------------------------------------------------------------------
void Button_CLK(int Button_n)
{
  lcd.clear();
  lcd.setCursor(0, 0);
  int Tic = 0;

  while (digitalRead(button_input[4]) == false)
  {
    delay(100);
    Tic++;
    lcd.print(char(255));
    if (Tic > 10)
    {
      lcd.clear();
      lcd.setCursor(0, 0);
      Button_FLAG = true;

      Tic = 0;
      while (digitalRead(button_input[4]) == false);
      break;
    }
  }

  if (Button_FLAG == false)
  {

    if (Button_n == 2) {
      Mem.Threshold--;
      if (Mem.Threshold < 1 )Mem.Threshold = 1;
    }
    if (Button_n == 4) {
      Mem.Threshold++;
    }
    if (Button_n == 5) {
      Menu();
    }
    Button_FLAG = true;
  }
  eepromWrite_Str_Mem(eeprom_adr, DEVICE); //  EEPROM
  LCD_start();
}
//--------------------------------------LCD_start()------------------------------------------------------------------------------------
void LCD_start()
{
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("VDI***    Thr:"); lcd.print(Mem.Threshold);
  lcd.setCursor(11, 1); lcd.write(1);
  lcd.setCursor(15, 1); lcd.print('v');

}

//-------------------------------------Menu()-------------------------------------------------------------------------------------
void Menu()
{
  lcd.clear();
  while (true)
  {
    if ( check_button() == false) {
      Button_FLAG = false;
    }
    if ( Button_read(1)) {
      Button_enter();
      MENU_index--;
    }
    if ( Button_read(2)) {
      Button_enter();
      MENU_entr(MENU_index);
      break;
    }
    if ( Button_read(3)) {
      Button_enter();
      MENU_index++;
    }
    if ( Button_read(4)) {
      Button_enter();
      lcd.clear();
      break;
    }
    if (MENU_index < 0)MENU_index = MENU_size;
    if (MENU_index > MENU_size)MENU_index = 0;
    lcd.clear();
    lcd.print('>'); lcd.print(MENU_Strings[MENU_index]);
    lcd.setCursor(0, 1); lcd.print(' ');
    if (MENU_index == 0)lcd.print(MENU_Strings[MENU_size]);
    else lcd.print(MENU_Strings[MENU_index - 1]);
    delay (100);
  }
}
//-----------------------------------------MENU_entr-----------------------------------------------------------------------------------
void MENU_entr(int index)
{
  int Threshold;
  if (index == 0)phase_sett(); //
  if (index == 1)coil_current(); //
  if (index == 2)F_scan(); //
//++++++++++++++++++++++++++++++++++++++++++
  if (index==3)V_bat_ind();
 
  //  if (index==4)GAIN();//
  //  if (index==5)other_options();//
  //if (index==6)coil_current();//

// / if (index == 7)F_scan(); //

  //if (index==8)phase_sett();//
  if (index==8)V_bat_ind();

  //  if (index==9)Mask_Svitch();//
  ///////////////
//+++++++++++++++++++++++++++++++++++
}
//----------------------------------------------Button_enter()-----------------------------------------------------------------------------
void Button_enter()
{

}

//------------------------------------------------------------------------------------------------------------------------------
bool Button_read(int But)
{
  return (digitalRead(button_input[But]) == false && Button_FLAG == false) ? true : false;
}


//________________________________ EEPROM _________________________________________


//внешний EEPROM необходимо заменить внутренним EEPROM,
//#include <EEPROM.h>
////////////++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
byte buff[sizeof(Mem)];//
//------------------------------ EEPROM----------------------------

void eepromRead_Str_Mem(int addr, int Dev)
{
  for (int i = 0; i < sizeof(buff); i++) buff[i] = eeprom_read_byte(addr + i, Dev);
  memcpy(&Mem, buff, sizeof(Mem));
}
//------------------------------------------------------------------------------------
void eepromWrite_Str_Mem(int addr, int Dev)
{
  memcpy(buff, &Mem, sizeof(buff));
  for (int i = 0; i < sizeof(buff); i++)
  {
    if (eeprom_read_byte(addr + i, Dev) != buff[i])eeprom_write_byte(addr + i, buff[i], Dev);
  }
}
//-----------------------------------------------------------------------------------


byte eeprom_read_byte(int eeaddress, int Dev)
{
  byte rdata = 0;
  Wire.beginTransmission(Dev);
  Wire.write(eeaddress);
  Wire.endTransmission();
  Wire.requestFrom(Dev, 1);
  if (Wire.available()) rdata = Wire.read();
  return rdata;
}
//----------------------------------------------------------------------------------
void eeprom_write_byte(int eeaddress, byte data, int Dev)
{
  int rdata = data;
  Wire.beginTransmission(Dev);
  Wire.write(eeaddress);
  Wire.write(rdata);
  Wire.endTransmission();
  delay(5);
}
//----------------------------------------------------------------------------------

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