#include <Wire.h>
#include <INA3221.h>

#define SERIAL_SPEED     9600  // serial baud rate
#define PRINT_DEC_POINTS 3       // decimal points to print

// Set I2C address to 0x41 (A0 pin -> VCC)
INA3221 ina3221(INA3221_ADDR40_GND);

void setup() {
    Serial.begin(SERIAL_SPEED);

    while (!Serial) {
        delay(1);
    }

    ina3221.begin();
    ina3221.reset();

    // Set shunt resistors to 10 mOhm for all channels
    ina3221.setShuntRes(100, 100, 100);

    // Set series filter resistors to 10 Ohm for all channels.
    // Series filter resistors introduce error to the current measurement.
    // The error can be estimated and depends on the resitor values and the bus
    // voltage.
    ina3221.setFilterRes(100, 100, 100);
}

void loop() {
    float current[3];
    float current_compensated[3];
    float voltage[3];

    current[0]             = ina3221.getCurrent(INA3221_CH1);
    current_compensated[0] = ina3221.getCurrentCompensated(INA3221_CH1);
    voltage[0]             = ina3221.getVoltage(INA3221_CH1);

    current[1]             = ina3221.getCurrent(INA3221_CH2);
    current_compensated[1] = ina3221.getCurrentCompensated(INA3221_CH2);
    voltage[1]             = ina3221.getVoltage(INA3221_CH2);

    current[2]             = ina3221.getCurrent(INA3221_CH3);
    current_compensated[2] = ina3221.getCurrentCompensated(INA3221_CH3);
    voltage[2]             = ina3221.getVoltage(INA3221_CH3);

    Serial.print("Channel 1: \n Current: ");
    Serial.print(current[0], PRINT_DEC_POINTS);
    Serial.print("A\n Compensated current: ");
    Serial.print(current_compensated[0], PRINT_DEC_POINTS);
    Serial.print("\n Voltage: ");
    Serial.print(voltage[0], PRINT_DEC_POINTS);
    Serial.println("V");

    Serial.print("Channel 2: \n Current: ");
    Serial.print(current[1], PRINT_DEC_POINTS);
    Serial.print("A\n Compensated current: ");
    Serial.print(current_compensated[1], PRINT_DEC_POINTS);
    Serial.print("\n Voltage: ");
    Serial.print(voltage[1], PRINT_DEC_POINTS);
    Serial.println("V");

    Serial.print("Channel 3: \n Current: ");
    Serial.print(current[2], PRINT_DEC_POINTS);
    Serial.print("A\n Compensated current: ");
    Serial.print(current_compensated[2], PRINT_DEC_POINTS);
    Serial.print("\n Voltage: ");
    Serial.print(voltage[2], PRINT_DEC_POINTS);
    Serial.println("V\n");

    delay(1000);
}

#include <Wire.h>

#define ADDR 0b1110110

#define OSRS_T 0b101
// 000 Skipped (output set to 0x80000) –
// 001 ×1 16 bit / 0.0050 °C
// 010 ×2 17 bit / 0.0025 °C
// 011 ×4 18 bit / 0.0012 °C
// 100 ×8 19 bit / 0.0006 °C
// 101, 110, 111 ×16 20 bit / 0.0003 °C
#define OSRS_P 0b110
// 000 Skipped (output set to 0x80000) –
// 001 ×1 16 bit / 2.62 Pa
// 010 ×2 17 bit / 1.31 Pa
// 011 ×4 18 bit / 0.66 Pa
// 100 ×8 19 bit / 0.33 Pa
// 101, 110, 111 ×16 20 bit / 0.16 Pa
#define MODE 0b11
// 00 Sleep mode
// 01 and 10 Forced mode
// 11 Normal mode
#define FILTER 0b001
// 000 Filter off Full
// 001 2 0.223 × ODR
// 010 4 0.092 × ODR
// 011 8 0.042 × ODR
// 100, others 16 0.021 × ODR
#define STANDBY 0b110
// 000 0.5 ms
// 001 62.5 ms
// 010 125 ms
// 011 250 ms
// 100 500 ms
// 101 1000 ms
// 110 2000 ms
// 111 4000 ms

 uint32_t t1,p1, temp_dig,press_dig;
 int32_t t2,t3,p2,p3,p4,p5,p6,p7,p8,p9;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  I2C_write(0xE0, 0xB6);// reset
  I2C_write(0xF5, (STANDBY<<5) | (FILTER<<2));
  I2C_write(0xF4, (OSRS_T<<5)|(OSRS_P<<2)|MODE); // osrs_t settings
  delay(200);
  t1 = (int32_t)I2C_read(0x89) << 8 | I2C_read(0x88);
  t2 = I2C_read(0x8B) << 8 | I2C_read(0x8A);
  t3 = I2C_read(0x8D) << 8 | I2C_read(0x8C);
  p1 = (int32_t)I2C_read(0x8F) << 8 | I2C_read(0x8E);
  p2 = I2C_read(0x91) << 8 | I2C_read(0x90);
  p3 = I2C_read(0x93) << 8 | I2C_read(0x92);
  p4 = I2C_read(0x95) << 8 | I2C_read(0x94);
  p5 = I2C_read(0x97) << 8 | I2C_read(0x96);
  p6 = I2C_read(0x99) << 8 | I2C_read(0x98);
  p7 = I2C_read(0x9B) << 8 | I2C_read(0x9A);
  p8 = I2C_read(0x9D) << 8 | I2C_read(0x9C);
  p9 = I2C_read(0x9F) << 8 | I2C_read(0x9E);
  Serial.print("ID = 0x");Serial.println(I2C_read(0xD0), HEX); // ID 58
  Serial.print("t1 = ");Serial.println(t1);
  Serial.print("t2 = ");Serial.println(t2);
  Serial.print("t3 = ");Serial.println(t3);
  Serial.print("p1 = ");Serial.println(p1);
  Serial.print("p2 = ");Serial.println(p2);
  Serial.print("p3 = ");Serial.println(p3);
  Serial.print("p4 = ");Serial.println(p4);
  Serial.print("p5 = ");Serial.println(p5);
  Serial.print("p6 = ");Serial.println(p6);
  Serial.print("p7 = ");Serial.println(p7);
  Serial.print("p8 = ");Serial.println(p8);
  Serial.print("p9 = ");Serial.println(p9);
  Serial.println();
}

void loop() {
  temp_dig = (int32_t)I2C_read(0xFA)<<12 | (int32_t)I2C_read(0xFB)<<4 | (I2C_read(0xFC) & 0xF0)>>4;

  double var1, var2, T;
  var1 = (((double)temp_dig)/16384.0 - ((double)t1)/1024.0) * ((double)t2);
  var2 = ((((double)temp_dig)/131072.0 - ((double)t1)/8192.0) *(((double)temp_dig)/131072.0 - ((double) t1)/8192.0)) * ((double)t3);
  int32_t t_fine = (int32_t)(var1 + var2);
  T = (var1 + var2) / 5120.0;

  int32_t qT;
  var1 = ((((temp_dig>>3) - ((uint32_t)t1<<1))) * ((uint32_t)t2)) >> 11;
  var2 = (((((temp_dig>>4) - ((uint32_t)t1)) * ((temp_dig>>4) - ((uint32_t)t1))) >> 12) *((int32_t)abs(t3))) >> 14;
  uint32_t qt_fine = var1 + var2;
  qT = (qt_fine * 5 + 128) >> 8;

  press_dig = (int32_t)I2C_read(0xF7)<<12 | (int32_t)I2C_read(0xF8)<<4 | (I2C_read(0xF9)&0xF0)>>4;

  double p;
  var1 = ((double)t_fine/2.0) - 64000.0;
  var2 = var1 * var1 * ((double)p6) / 32768.0;
  var2 = var2 + var1 * ((double)p5) * 2.0;
  var2 = (var2/4.0)+(((double)p4) * 65536.0);
  var1 = (((double)p3) * var1 * var1 / 524288.0 + ((double)p2) * var1) / 524288.0;
  var1 = (1.0 + var1 / 32768.0)*((double)p1);
  if (var1 == 0.0){return 0;}
  p = 1048576.0 - (double)press_dig;
  p = (p - (var2 / 4096.0)) * 6250.0 / var1;
  var1 = ((double)p9) * p * p / 2147483648.0;
  var2 = p * ((double)p8) / 32768.0;
  p = p + (var1 + var2 + ((double)p7)) / 16.0;

 
  int32_t zvar1, zvar2;
  uint32_t zp;
  zvar1 = (((int32_t)t_fine)>>1)-(int32_t)64000;
  zvar2 = (((zvar1>>2) * (zvar1>>2)) >> 11 ) * ((int32_t)p6);
  zvar2 = zvar2 + ((zvar1*((int32_t)p5))<<1);
  zvar2 = (zvar2>>2)+(((int32_t)p4)<<16);
  zvar1 = (((p3 * (((zvar1>>2) * (zvar1>>2)) >> 13 )) >> 3) + ((((int32_t)p2) * zvar1)>>1))>>18;
  zvar1 =((((32768+zvar1))*((int32_t)p1))>>15);
  if (zvar1 == 0){return 0; }
  zp = (((uint32_t)(((int32_t)1048576)-press_dig)-(zvar2>>12)))*3125;
  if (zp < 0x80000000){zp = (zp << 1) / ((uint32_t)zvar1);}
  else{zp = (zp / (uint32_t)zvar1) * 2;}
  zvar1 = (((int32_t)p9) * ((int32_t)(((zp>>3) * (zp>>3))>>13)))>>12;
  zvar2 = (((int32_t)(zp>>2)) * ((int32_t)p8))>>13;
  zp = (uint32_t)((int32_t)zp + ((zvar1 + zvar2 + p7) >> 4));

  Serial.print("T(float) = ");Serial.print(T,2);Serial.println(" °C");
  Serial.print("T(int32_t) = ");Serial.println(qT);
  Serial.print("P(float) = ");Serial.print(p,2); Serial.println(" Pa");
  Serial.print("P(int32_t) = ");Serial.print(zp); Serial.println(" Pa");
  Serial.print("P = ");Serial.print(p/133.3224,2); Serial.println(" mmHg");
  
  Serial.println();
  delay(2000);

}

byte I2C_read(byte reg){
  Wire.beginTransmission(ADDR);
  Wire.write(reg);
  Wire.endTransmission();
  Wire.requestFrom(ADDR,1);
  while(Wire.available()<1);
  byte value = Wire.read();
  return value;
  } 

void I2C_write(byte reg, byte data){  
  Wire.beginTransmission(ADDR);
  Wire.write(reg);
  Wire.write(data);
  Wire.endTransmission();
  }    

int servoPin = 9; // сигнальный провод от серво на порт 9
int val;

void setup()
{
  pinMode(servoPin, OUTPUT);
  Serial.begin(9600);
  Serial.println("Servo is ready");
}

void loop(){
      val = 0;
      for (int i = 0; i <= 50; i++){servoPulse(servoPin, val);}
      delay(1000);
      val = 90;
      for (int i = 0; i <= 50; i++){servoPulse(servoPin, val);}
      delay(1000);
      val = 180;
      for (int i = 0; i <= 50; i++){servoPulse(servoPin, val);}
      delay(1000);
      val = 90;
      for (int i = 0; i <= 50; i++){servoPulse(servoPin, val);}
      delay(1000);
}

// define a servo pulse function
void servoPulse(int pin, int angle){
  int pulseWidth = map(angle, 0, 180 , 544, 2480); 
  Serial.println(pulseWidth);
  digitalWrite(pin, HIGH); // set the level of servo pin as high
  delayMicroseconds(pulseWidth); // delay microsecond of pulse width
  digitalWrite(pin, LOW); // set the level of servo pin as low
  delayMicroseconds(20000 - pulseWidth);
}

/* Sweep
 by BARRAGAN <http://barraganstudio.com>
 This example code is in the public domain.

 modified 8 Nov 2013
 by Scott Fitzgerald
 http://www.arduino.cc/en/Tutorial/Sweep
*/

#include <Servo.h>

Servo myservo;  // create servo object to control a servo

void setup() {
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object
}

void loop() {

    myservo.write(0);    
    delay(1000);  
    myservo.write(90);    
    delay(1000); 
    myservo.write(180);    
    delay(1000);  
    myservo.write(90);    
    delay(1000);     
  
 
}

#define S0  2
#define S1  3
#define S2  4
#define S3  5

void setup(){
  Serial.begin(9600);
  pinMode(S0, OUTPUT);
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
}

void loop(){
  for (int i = 0; i < 16; i++){
    read4067(i);
    float izm = 5.00/1023*analogRead(A0);
    Serial.println(String(i)+" = "+String(izm)+" V");
  }
  delay(5000);
  Serial.println();
}

int read4067(byte ch){
  digitalWrite(S0, (ch & 0b0001));
  digitalWrite(S1, (ch & 0b0010)>>1);
  digitalWrite(S2, (ch & 0b0100)>>2);
  digitalWrite(S3, (ch & 0b1000)>>3);
}

// LGT8F328

#define AN1     2
#define AN2     3
#define AN3     4
#define AN4     5
#define AN5     6

#define ID1     11
#define ID2     10
#define ID4     7
#define ID8     8

#define SET     A0 // BUTTON SET
#define UP      A2 // BUTTON +++
#define DW      A1 // BUTTON ---

#define BR      300  // 400-3000 яркость

#include <Wire.h> 
#include <DS3231.h> //http://rcl-radio.ru/wp-content/uploads/2022/10/DS3231.zip
  DS3231 clock;
  RTCDateTime DateTime;
  int an, segm,i;
  byte a[5];
  int dp,h,m,set,tic;
  unsigned long times0;
  bool x;

void setup() {
  Wire.begin();clock.begin();
  Serial.begin(9600);
  Serial.println("ok");
  pinMode(9,OUTPUT);// PWM TIMER_1
  pinMode(AN1,OUTPUT);pinMode(AN2,OUTPUT);pinMode(AN3,OUTPUT);pinMode(AN4,OUTPUT);pinMode(AN5,OUTPUT);
  pinMode(ID1,OUTPUT);pinMode(ID2,OUTPUT);pinMode(ID4,OUTPUT);pinMode(ID8,OUTPUT);
  pinMode(SET,INPUT_PULLUP);pinMode(UP,INPUT_PULLUP);pinMode(DW,INPUT_PULLUP);
  
 //  clock.setDateTime(__DATE__, __TIME__); // Устанавливаем время на часах, основываясь на времени компиляции скетча
  cli();
  //TIMER_1 PWM +170V
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1 = 0;
  TCCR1A |= (1<<COM1A1);
  TCCR1B |= (1<<WGM12);
  TCCR1A |= (1<<WGM11);
  TCCR1B |= (1 << CS10); 
  ICR1 = 511; 
  OCR1A = 350;
  //TIMER_2
  TCCR2A = 0;
  TCCR2B = 0;
  TCNT2 = 0;
  OCR2A = 120;
  TCCR2A |= (1 << WGM21);
  TCCR2B |= (1 << CS22) | (1 << CS21) | (1 << CS20);
  TIMSK2 |= (1 << OCIE2A);
  sei();
  }
  
void loop() { 
  DateTime=clock.getDateTime();// опрос времени
  h = DateTime.hour;
  m = DateTime.minute;

  if(digitalRead(SET)==LOW){set++;if(set>2){set=0;}delay(200);}

  if(set==1){
  if(digitalRead(UP)==LOW){x=1;tic=0;h++;if(h>23){h=23;}delay(200);}
  if(digitalRead(DW)==LOW){x=1;tic=0;h--;if(h<0){h=0;}delay(200);}
  if(tic==0){a[0]=h/10%10;}else{a[0]=10;}
  if(tic==0){a[1]=h%10;}else{a[1]=10;}
  a[2]=7;
  a[3]=m/10%10;
  a[4]=m%10;
  }

  if(set==2){
  if(digitalRead(UP)==LOW){x=1;tic=0;m++;if(m>59){m=59;}delay(200);}
  if(digitalRead(DW)==LOW){x=1;tic=0;m--;if(m<0){m=0;}delay(200);}
  a[0]=h/10%10;
  a[1]=h%10;
  a[2]=7;
  if(tic==0){a[3]=m/10%10;}else{a[3]=10;}
  if(tic==0){a[4]=m%10;}else{a[4]=10;}
  }

  if(x==1){x=0;clock.setDateTime(2024, 1, 1, h, m, 0);}

  if(set==0){
  if(millis()-times0<500){dp=8;}
  if(millis()-times0>=500){dp=10;}
  if(millis()-times0>1000){times0=millis();}
  a[0]=h/10;
  a[1]=h%10;
  a[2]=dp;
  a[3]=m/10%10;
  a[4]=m%10;
  }
  
  tic++;
  if(tic>1){tic=0;}
  delay(100);
}

void segment(){
  switch(segm){                                                                 
    case 0: digitalWrite(ID1,LOW);digitalWrite(ID2,LOW);digitalWrite(ID4,LOW);digitalWrite(ID8,LOW);break;     // DEC 0 = 0b0000
    case 1: digitalWrite(ID1,LOW);digitalWrite(ID2,LOW);digitalWrite(ID4,LOW);digitalWrite(ID8,HIGH);break;    // DEC 1 = 0b0001
    case 2: digitalWrite(ID1,LOW);digitalWrite(ID2,LOW);digitalWrite(ID4,HIGH);digitalWrite(ID8,LOW);break;    // DEC 2 = 0b0010
    case 3: digitalWrite(ID1,LOW);digitalWrite(ID2,LOW);digitalWrite(ID4,HIGH);digitalWrite(ID8,HIGH);break;   // DEC 3 = 0b0011
    case 4: digitalWrite(ID1,LOW);digitalWrite(ID2,HIGH);digitalWrite(ID4,LOW);digitalWrite(ID8,LOW);break;    // DEC 4 = 0b0100
    case 5: digitalWrite(ID1,LOW);digitalWrite(ID2,HIGH);digitalWrite(ID4,LOW);digitalWrite(ID8,HIGH);break;   // DEC 5 = 0b0101
    case 6: digitalWrite(ID1,LOW);digitalWrite(ID2,HIGH);digitalWrite(ID4,HIGH);digitalWrite(ID8,LOW);break;   // DEC 6 = 0b0110
    case 7: digitalWrite(ID1,LOW);digitalWrite(ID2,HIGH);digitalWrite(ID4,HIGH);digitalWrite(ID8,HIGH);break;  // DEC 7 = 0b0111
    case 8: digitalWrite(ID1,HIGH);digitalWrite(ID2,LOW);digitalWrite(ID4,LOW);digitalWrite(ID8,LOW);break;    // DEC 8 = 0b1000
    case 9: digitalWrite(ID1,HIGH);digitalWrite(ID2,LOW);digitalWrite(ID4,LOW);digitalWrite(ID8,HIGH);break;   // DEC 9 = 0b0110
   case 10: digitalWrite(ID1,HIGH);digitalWrite(ID2,HIGH);digitalWrite(ID4,HIGH);digitalWrite(ID8,HIGH);break;
  }}
void anod(){
  switch(an){                                                             
    case 0: digitalWrite(AN1,HIGH);digitalWrite(AN2,LOW);digitalWrite(AN3,LOW);digitalWrite(AN4,LOW);digitalWrite(AN5,LOW);break;    
    case 1: digitalWrite(AN1,LOW);digitalWrite(AN2,HIGH);digitalWrite(AN3,LOW);digitalWrite(AN4,LOW);digitalWrite(AN5,LOW);break;   
    case 2: digitalWrite(AN1,LOW);digitalWrite(AN2,LOW);digitalWrite(AN3,HIGH);digitalWrite(AN4,LOW);digitalWrite(AN5,LOW);break;   
    case 3: digitalWrite(AN1,LOW);digitalWrite(AN2,LOW);digitalWrite(AN3,LOW);digitalWrite(AN4,HIGH);digitalWrite(AN5,LOW);break; 
    case 4: digitalWrite(AN1,LOW);digitalWrite(AN2,LOW);digitalWrite(AN3,LOW);digitalWrite(AN4,LOW);digitalWrite(AN5,HIGH);break;   
  }}

ISR(TIMER2_COMPA_vect) {
  switch(i){
    case 0: segm=a[0]; an=0;cl();delayMicroseconds(BR); anod(); segment();break;
    case 1: segm=a[1]; an=1;cl();delayMicroseconds(BR); anod(); segment();break;
    case 2: segm=a[2]; an=2;cl();delayMicroseconds(BR); anod(); segment();break;
    case 3: segm=a[3]; an=3;cl();delayMicroseconds(BR); anod(); segment();break;
    case 4: segm=a[4]; an=4;cl();delayMicroseconds(BR); anod(); segment();break;
    }
    i++;if(i>4){i=0;}}

void cl(){digitalWrite(AN1,LOW);digitalWrite(AN2,LOW);digitalWrite(AN3,LOW);digitalWrite(AN4,LOW);digitalWrite(AN5,LOW);
          digitalWrite(ID1,HIGH);digitalWrite(ID2,HIGH);digitalWrite(ID4,HIGH);digitalWrite(ID8,HIGH);
          }
 

/*              
                 Общий анод
--------------------------------------------------|                
Цифра|dp | G | F | E | D | C | B | A | Десятичный |
-----|---|---|---|---|---|---|---|---|------------|
  0  | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |    192     |
  1  | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 1 |    249     |
  2  | 1 | 0 | 1 | 0 | 0 | 1 | 0 | 0 |    164     |
  3  | 1 | 0 | 1 | 1 | 0 | 0 | 0 | 0 |    176     |
  4  | 1 | 0 | 0 | 1 | 1 | 0 | 0 | 1 |    153     |
  5  | 1 | 0 | 0 | 1 | 0 | 0 | 1 | 0 |    146     |
  6  | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |    130     |
  7  | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 0 |    248     |
  8  | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |    128     |
  9  | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 |    144     |
 dp  | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |    127     |
-----*---*---*---*---*---*---*---*---*------------*
*/

#define RCLK 3
#define SCLK 4
#define DIO1 2
#define DIO2 6
 
byte razr[4] = {0b1110,0b1101,0b1011,0b0111};// 0123         
byte digit[13] = {192,249,164,176,153,146,130,248,128,144,127,255,191}; // 0 1 2 3 4 5 6 7 8 9 dp пусто -
int k;
byte a[4];
int i0,dp;
 
void setup(){
  Serial.begin(9600);
  noInterrupts();
  TCCR2B = 1 << CS22 | 1 << CS21;
  TIMSK2 = 1 << OCIE2A;
  OCR2A = 150;
  interrupts();
  pinMode(RCLK, OUTPUT);  // RCLK
  pinMode(SCLK, OUTPUT);  // SCLK
  pinMode(DIO1, OUTPUT);  // DIO1
  pinMode(DIO2, OUTPUT);  // DIO2
}

 
void loop(){
  k++;
  delay(100);
}

ISR(TIMER2_COMPA_vect) {
  a[0]=k/1000%10;
  a[1]=k/100%10;
  a[2]=k/10%10;
  a[3]=k%10;
 if(i0>3){i0=0;}
 if(i0==1){dp=0x80;}else{dp=0;}// i0=1 - запятая в 1 индикаторе (0123 === 01.23)
  digitalWrite(RCLK, LOW);
    for(int i1 = 7; i1 >=0; i1--){
     digitalWrite(SCLK,LOW);
     digitalWrite(DIO2, (razr[i0] >> i1) & 1); 
     digitalWrite(DIO1, ((digit[a[i0]]-dp) >> i1) & 1); 
     digitalWrite(SCLK,HIGH);
     } 
  digitalWrite(RCLK, HIGH);
  i0++;
} 

#define DELAY 200

#define CE  3
#define CL  4
#define DI  2

unsigned long t=0b10000000000000000000000000000000;// 32 bit
unsigned long t1=0b1000000000000000000000000000;   // 28 bit

void setup() {
  Serial.begin(9600);
  pinMode(CE, OUTPUT);
  pinMode(CL, OUTPUT);
  pinMode(DI, OUTPUT);
  digitalWrite(CE,LOW);
  digitalWrite(CL,LOW);
  delay(200);
      //  1                             32
//byte_1  00000000000000000000000000000000
      //  33                            64
//byte_2  00000000000000000000000000000000
      //  65                            96
//byte_3  00000000000000000000000000000000
      //  97                           128
//byte_4  00000000000000000000000000000000
      //  129                      156
//byte_5  0000000000000000000000000000

}

void loop() {
 write_byte(0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0B1111111111111111111111111111,0b0000);
  delay(5000);

  for(int j=0;j<=31;j++){
    write_byte(t>>j,0,0,0,0,0b0000);
    Serial.print(t>>j,BIN); Serial.print("  bit "); Serial.println(j+1);
    delay(DELAY);
    }
  for(int j=0;j<=31;j++){  
    write_byte(0,t>>j,0,0,0,0b0000);
    Serial.print(t>>j,BIN); Serial.print("  bit "); Serial.println(j+33);
    delay(DELAY);
    }
  for(int j=0;j<=31;j++){  
    write_byte(0,0,t>>j,0,0,0b0000);
    Serial.print(t>>j,BIN); Serial.print("  bit "); Serial.println(j+65);
    delay(DELAY);
    }  
  for(int j=0;j<=31;j++){  
    write_byte(0,0,0,t>>j,0,0b0000);
    Serial.print(t>>j,BIN); Serial.print("  bit "); Serial.println(j+97);
    delay(DELAY);
    }   
  for(int j=0;j<=27;j++){  
    write_byte(0,0,0,0,t>>j,0b0000);
    Serial.print(t1>>j,BIN); Serial.print("  bit "); Serial.println(j+129);
    delay(DELAY);
    }         
}

void write_byte( unsigned long b0, unsigned long b1, unsigned long b2, unsigned long b3, unsigned long b4, byte contr){
  /// addr 8 bit
     digitalWrite(CE,LOW);delayMicroseconds(10);
   for(int i = 0; i <= 7; i++){
     digitalWrite(CL,LOW);delayMicroseconds(10);
     digitalWrite(DI, (0x41 >> i) & 1); 
     digitalWrite(CL,HIGH);delayMicroseconds(10);
     } 
     digitalWrite(CL,LOW);delayMicroseconds(10);
     digitalWrite(CE,HIGH);delayMicroseconds(10);

// data 156 bit
  // 1-24 seg
     for(int i = 31;i >= 0; i--){ 
     digitalWrite(CL,LOW);delayMicroseconds(10);
     digitalWrite(DI, (b0 >> i) & 1);
     digitalWrite(CL,HIGH);delayMicroseconds(10);
     } 

     for(int i = 31;i >= 0; i--){ 
     digitalWrite(CL,LOW);delayMicroseconds(10);
     digitalWrite(DI, (b1 >> i) & 1);
     digitalWrite(CL,HIGH);delayMicroseconds(10);
     } 

     for(int i = 31;i >= 0; i--){ 
     digitalWrite(CL,LOW);delayMicroseconds(10);
     digitalWrite(DI, (b2 >> i) & 1);
     digitalWrite(CL,HIGH);delayMicroseconds(10);
     } 

     for(int i = 31;i >= 0; i--){ 
     digitalWrite(CL,LOW);delayMicroseconds(10);
     digitalWrite(DI, (b3 >> i) & 1);
     digitalWrite(CL,HIGH);delayMicroseconds(10);
     } 

     for(int i = 27;i >= 0; i--){ 
     digitalWrite(CL,LOW);delayMicroseconds(10);
     digitalWrite(DI, (b4 >> i) & 1);
     digitalWrite(CL,HIGH);delayMicroseconds(10);
     } 
    
// control data 4 bit     
for(int i = 3; i >= 0; i--){
     digitalWrite(CL,LOW);delayMicroseconds(10);
     digitalWrite(DI, (contr >> i) & 1);
     digitalWrite(CL,HIGH);delayMicroseconds(10);
     } 
     digitalWrite(CE,LOW);
     digitalWrite(CL,LOW);
     delay(1);
  }  

#define DELAY 1000

#define CE  3
#define CL  4
#define DI  2

long t=0b100000000000000000000;

void setup(){
  Serial.begin(9600);
  pinMode(CE, OUTPUT);
  pinMode(CL, OUTPUT);
  pinMode(DI, OUTPUT);
  digitalWrite(CE,LOW);
  digitalWrite(CL,LOW);
  delay(200);
  write_byte(0,0,0,0,0,0);
  }
  /*
  b1 1                   21
   0b111111111111111111111 
  b2 22                  42
   0b111111111111111111111  
  b3 43                  63
   0b111111111111111111111  
  b4 64                  84
   0b111111111111111111111 
  b5 85                  105
   0b111111111111111111111 
  b6 106                 126
   0b111111111111111111111    
   */

void loop(){
  write_byte(0b111111111111111111111,0b111111111111111111111, 0b111111111111111111111,0b111111111111111111111, 0b111111111111111111111,0b111111111111111111111);
  delay(5000);

  for(int j=0;j<=20;j++){
    write_byte(t>>j,0,0,0,0,0);
    Serial.print(t>>j,BIN); Serial.print("  bit "); Serial.println(j+1);
    delay(DELAY);
    }
    for(int j=0;j<=20;j++){
    write_byte(0,t>>j,0,0,0,0);
    Serial.print(t>>j,BIN); Serial.print("  bit "); Serial.println(j+22);
    delay(DELAY);
    }  
    for(int j=0;j<=20;j++){
    write_byte(0,0,t>>j,0,0,0);
    Serial.print(t>>j,BIN); Serial.print("  bit "); Serial.println(j+43);
    delay(DELAY);
    }   
    for(int j=0;j<=20;j++){
    write_byte(0,0,0,t>>j,0,0);
    Serial.print(t>>j,BIN); Serial.print("  bit "); Serial.println(j+64);
    delay(DELAY);
    }   
    for(int j=0;j<=20;j++){
    write_byte(0,0,0,0,t>>j,0);
    Serial.print(t>>j,BIN); Serial.print("  bit "); Serial.println(j+85);
    delay(DELAY);
    } 
for(int j=0;j<=20;j++){
    write_byte(0,0,0,0,0,t>>j);
    Serial.print(t>>j,BIN); Serial.print("  bit "); Serial.println(j+106);
    delay(DELAY);
    }                
  }

void write_byte(long b1, long b2, long b3, long b4, long b5, long b6){
     write_addr();
     write_21(b1);
     write_21(b2);
     write_conf(0b00000000000100);
     write_addr();
     write_21(b3);
     write_21(b4);
     write_conf(0b00000000000001);
     write_addr();
     write_21(b5);
     write_21(b6);
     write_conf(0b00000000000010);    
  }   


void write_addr(){
     digitalWrite(CE,LOW);delayMicroseconds(10);
   for(int i = 7; i >= 0; i--){
     digitalWrite(CL,LOW);delayMicroseconds(10);
     digitalWrite(DI, (0x42 >> i) & 1); 
     digitalWrite(CL,HIGH);delayMicroseconds(10);
     } 
     digitalWrite(CL,LOW);
     digitalWrite(CE,HIGH);
     delayMicroseconds(10);
  } 

 void write_21(long bb){
  for(int i = 20;i >= 0; i--){ 
     digitalWrite(CL,LOW);delayMicroseconds(10);
     digitalWrite(DI, (bb >> i) & 1);
     digitalWrite(CL,HIGH);delayMicroseconds(10);
     } 
  }  
   
void write_conf(long data_conf){
    for(int i = 13;i >= 0; i--){ 
     digitalWrite(CL,LOW);delayMicroseconds(10);
     digitalWrite(DI, (data_conf >> i) & 1);
     digitalWrite(CL,HIGH);delayMicroseconds(10);
     } 
     digitalWrite(CE,LOW);delayMicroseconds(10);
  }
  

#include <Wire.h> 
#include <U8glib.h>            // https://github.com/olikraus/u8glib/
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);
U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE);  // I2C / TWI 

#define CAL 31249; 
#define CAP    1000.0 // pF

extern uint8_t SmallFont[],BigNumbers[];
unsigned long f_out,tic;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  PORTD |= (1 << PD5); // подтягивающий резистор на PD5 (вход T1)
  // TIMER_1 INPUT T1
  TCCR1A = 0;TCCR1B = 0;TCNT1=0;
  TCCR1B = (1 << CS12) | (1 << CS11) | (1 << CS10);
  TIMSK1 = (1 << TOIE1);
  TCKCSR = (1 << F2XEN) | (1 << TC2XS1);
// TIMER_3 1 SEC
// (32000000/((31249+1)x1024))=1 Hz
  TCCR3A = 0;
  TCCR3B = 0;
  TCNT3=0;
  TCCR3B = (1 << CS32) |(1 << CS30) | (1 << WGM32);
  TIMSK3 = (1 << OCIE3A);
  OCR3A = CAL;
// TIMER_2 OUTPUT 8 MHz
TCCR2A = 0;TCCR2B = 0;TCNT2=0;
  TCCR2A = 1 << COM2A0 |1 << WGM21;
  TCCR2B = 1 << CS20;
  OCR2A = 0;
  C0SR = 0;C0XR=0;
  C0XR |=(1<<C0OE); // C0OE[7] = 1, выход компаратора AC0 для внешнего порта PD2
  // ВЫБОР ИНВЕРСНОГО ВХОДА
  ADCSRB = 0b01000000;// ADMUX
  /*
  CME01[7] CME00[6] Источник входного сигнала AC0
  0        0        ACXN
  0        1        ADMUX
  1        0        DFFO
  */
  ADMUX = 0b00000000; // CHMUX[3:0] = 0000 Источник входного сигнала PC0 (A0)
  // ВЫБОР НЕИНВЕРСНОГО ВХОДА
  C0SR &=~(1<<C0BG);C0XR &=~(1<<C0PS0);
  /*
  C0BG C0PS0 Источник входного сигнала AC0
  0    0     AC0P
  0    1     ACXP
  1    0     DAO
  */
  delay(100);
}

void loop() {
 float l_iz = 1/(4*3.14*3.14*f_out*f_out*CAP*pow(10,-12))*1000000.0;
 if(l_iz>100000||l_iz<0){l_iz=0;}
 Serial.print(l_iz,2);Serial.println(" uH");
 Serial.print(f_out);Serial.println(" Hz");
  u8g.firstPage(); do {
  u8g.setFont(u8g_font_profont29r);u8g.setPrintPos(0,25);
    if(l_iz<1000){u8g.print(l_iz,2);u8g.drawStr(97,25,"uH");}
    if(l_iz>=1000){u8g.print(l_iz/1000,2);u8g.drawStr(97,25,"mH");}
  }while( u8g.nextPage() );
 delay(1000);
}


ISR(TIMER1_OVF_vect) {tic++;}

ISR(TIMER3_vect) {
  if (TIFR3 & (1 << OCF3A)){
      TIFR3 = 1 << OCF3A;
      f_out = tic*0xFFFF + TCNT1;
      tic=0;TCNT1=0;
  }} 

#define CALL_UF   6.10
#define CALL_NF   6.58

#include <Wire.h> 
#include <U8glib.h>            // https://github.com/olikraus/u8glib/
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);
U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE);  // I2C / TWI 

volatile  int x;
float null_c;
bool mk;
unsigned long c_f,times0,times1;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  PORTB |=(1<<PB5);
// TIMER_1 /////////////////////////  
  TCNT1 = 0;TCCR1A = 0;TCCR1C = 0;TCCR1B = 2;TIMSK1 |= (1 << TOIE1);
// COMPARATOR_0 ////////////////////  
  C0SR = 0;C0XR=0;ADMUX=0;ADCSRB=0;
  ADCSRB = 0b01000000;// ADMUX
  ADMUX = 0b00000000; // A0 A1 A2
  C0SR &=~(1<<C0BG);C0XR |=(1<<C0PS0);// ACXP
// ADC //////////////////////////// 
  ADCSRD |= (1<<REFS2); // 4.096 ИОН
  ADCSRA |= 1 << ADEN | 1 << ADSC | 1 << ADATE | 0b111;
  delay(200);
  PORTB |=(1<<PB0);DDRB &=~ (1<<PB0);
  DDRD |=(1<<PD6);PORTD &=~ (1<<PD6);delay(300);
  DDRB &=~ (1<<PB0);PORTB &=~(1<<PB0);
  times1=millis();
  while(analogRead(A0)>10);
  delay(100); 
  TCNT1=0;x=0;PORTD |= (1<<PD6);
  while(((C0SR >> 5) & 1)==1);null_c = (x * 65535 + TCNT1)/CALL_NF;
  u8g.firstPage(); do {u8g.setFont(u8g_font_profont17r);u8g.drawStr(20,11,"CALL_0");
  u8g.setPrintPos(20,28);u8g.print(null_c,1);u8g.drawStr(80,28,"pF");
  } while( u8g.nextPage() );
  delay(2000);
}

void loop() {
///// uF ////////////////////////////////////////////////  
  PORTD &=~(1<<PD6);DDRD &=~(1<<PD6);
  DDRB |= (1<<PB0);PORTB &=~ (1<<PB0);delay(10);
  while(analogRead(A0)>10);
  TCNT1=0;x=0;PORTB |= (1<<PB0);
  while(((C0SR >> 5) & 1)==1){c_f = x * 65535 + TCNT1;PORTB|=(1<<PB5);}
  PORTB&=~(1<<PB5);
/////////////////////////////////////////////////////////
  if((c_f/CALL_UF)/1000.0<0.3){mk=1;}else{mk=0;}  
///// nF //////////////////////////////////////////////// 
if(mk==1){  
  PORTB |=(1<<PB0);DDRB &=~ (1<<PB0);
  DDRD |=(1<<PD6);PORTD &=~ (1<<PD6);delay(300);
  DDRB &=~ (1<<PB0);PORTB &=~(1<<PB0);
  times1=millis();
  while(analogRead(A0)>10){if(millis()-times1>2000){mk=0;break;}};
  delay(100); 
  TCNT1=0;x=0;PORTD |= (1<<PD6);
  while(((C0SR >> 5) & 1)==1){PORTB|=(1<<PB5);if(x>50){mk=0;break;}}
  PORTB&=~(1<<PB5);c_f = x * 65535 + TCNT1;
}

/////////////////////////////////////////////////////////
  u8g.firstPage(); do {
  u8g.setFont(u8g_font_profont29r);u8g.setPrintPos(0,25);
  if(mk==1){
    if((c_f/CALL_NF-null_c)<9999){
      u8g.print(abs(c_f/CALL_NF-null_c),0);u8g.drawStr(100,25,"pF");
      }else{
    u8g.print((c_f/CALL_NF-null_c)/1000.0,2);u8g.drawStr(100,25,"nF");}
  }
  if(mk==0){
    if((c_f/CALL_UF)/1000.0<9.99){
      u8g.print((c_f/CALL_UF)/1000.0,2);u8g.drawStr(100,25,"uF");
      }else{
    u8g.print((c_f/CALL_UF)/1000.0,1);u8g.drawStr(100,25,"uF");
      }
    }

    } while( u8g.nextPage() );
Serial.println((c_f/CALL_UF)/1000.0);
}

ISR(TIMER1_OVF_vect){x++;}

#define KALL_I_IZ 1.200 
#define KALL_U_IZ 0.730 

#include <Wire.h> 
#include <U8glib.h>            // https://github.com/olikraus/u8glib/
  
  U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_DEV_0|U8G_I2C_OPT_FAST);

  int n,m,m1;
  float i_dig,u_dig,i_dig1;
  float u_iz,i_iz,i_iz1;
  long i_sum,u_sum,i_sum1;
  bool w=1;

void setup(){
  delay(200);
  Wire.begin();
  analogReadResolution(12);// АЦП 12 БИТ
  analogReference(DEFAULT);
  pinMode(A0,INPUT);
  pinMode(A1,INPUT);
  pinMode(A2,INPUT);
  pinMode(13,OUTPUT);
  u8g.firstPage();  
   do {
  u8g.setFont(u8g_font_profont12r); 
  u8g.drawStr(30,10,"POWER SUPPLY");
  u8g.drawStr(30,25,"0-30V 0-3A");
  u8g.drawStr(30,55,"rcl-radio.ru");
  } while( u8g.nextPage() );
  delay(2000);
  }

void loop(){
  i_dig = analogRead(A0);
  i_sum = i_sum+i_dig;
  n++;if(n>9){n=0;i_iz=i_sum/10;i_sum=0;} 


  u_dig = analogRead(A1);
  u_sum = u_sum+u_dig;
  m++;if(m>9){m=0;u_iz=u_sum/10;u_sum=0;w=1;} 

  i_dig1 = analogRead(A2);
  i_sum1 = i_sum1+i_dig1;
  m1++;if(m1>9){m1=0;i_iz1=i_sum1/10;i_sum1=0;} 

  if(i_iz*1.05>=i_iz1){digitalWrite(13,HIGH);}else{digitalWrite(13,LOW);}

  if(w==1){
  u8g.firstPage();  
   do {
  u8g.drawLine(0, 26, 128, 26);u8g.drawLine(0, 53, 128, 53);
  u8g.setFont(u8g_font_profont29r); 
  u8g.drawStr(0,22,"U");u8g.setPrintPos(35, 22);u8g.print(u_iz*KALL_U_IZ/100.0,1);u8g.drawStr(110,22,"V");
  u8g.drawStr(0,50,"I");u8g.setPrintPos(35, 50);u8g.print(i_iz*KALL_I_IZ/1000.0,2);u8g.drawStr(110,50,"A");
  u8g.setFont(u8g_font_profont12r);
  u8g.setPrintPos(75, 64);u8g.print(i_iz1*KALL_I_IZ/1000.0,2);
  u8g.drawStr(15,64,"I stab = ");u8g.drawStr(105,64,"A");

  } while( u8g.nextPage() );
  }
  }    

#define STB 4
#define DIN 2
#define CLK 3

#define SET 5
#define UP  6
#define DW  7

#include <Wire.h>
#include <DS3231.h> // http://rcl-radio.ru/wp-content/uploads/2022/10/DS3231.zip
DS3231 clock;RTCDateTime DateTime;

int a[5];
int hour,minut,set;
long times,times0;
bool d,mig;

void setup(){
  Serial.begin(9600);clock.begin();
  ///clock.setDateTime(__DATE__, __TIME__); // Устанавливаем время на часах, основываясь на времени компиляции скетча
  pinMode(STB,OUTPUT);
  pinMode(DIN,OUTPUT);
  pinMode(CLK,OUTPUT);
  pinMode(SET,INPUT_PULLUP);  
  pinMode(UP,INPUT_PULLUP);
  pinMode(DW,INPUT_PULLUP);  
  delay(100);
  digitalWrite(STB,HIGH);delay(200);
  // PWM OUTPUT D9 TIMER 1 
  TCCR1A = 0;TCCR1B = 0;
  TCCR1A = (1 << COM1A1)|(1 << WGM11);
  TCCR1B = (1 << WGM13)|(1 << WGM12)|(1 << CS10);
  DDRB =  1 << DDB1; // OUTPUT PWM (OCR1A)
  OCR1A = 15;
  ICR1 = 40;
  write_byte1_PT6312(0b01000100);// command 2
  write_byte1_PT6312(0b00000100);// command 1 8dig/14seg
  write_byte1_PT6312(0b10001111);// command 4 display on
  }

void loop(){
  DateTime = clock.getDateTime();
  hour = DateTime.hour;
  minut = DateTime.minute; 

  if(digitalRead(SET)==LOW){set++;if(set>2){set=0;} delay(300);} 
  if(digitalRead(UP)==LOW&&set==1){hour++;if(hour>23){hour=23;} clock.setDateTime(2024, 2, 22, hour, minut, 0);delay(100);} 
  if(digitalRead(DW)==LOW&&set==1){hour--;if(hour<0){hour=0;} clock.setDateTime(2024, 2, 22, hour, minut, 0);delay(100);} 
  if(digitalRead(UP)==LOW&&set==2){minut++;if(minut>59){minut=59;} clock.setDateTime(2024, 2, 22, hour, minut, 0);delay(100);} 
  if(digitalRead(DW)==LOW&&set==2){minut--;if(minut<0){minut=0;} clock.setDateTime(2024, 2, 22, hour, minut, 0);delay(100);} 
  
  if(millis()-times0<200){mig=1;}
  if(millis()-times0>200){mig=0;}
  if(millis()-times0>400){times0=millis();}

  if(millis()-times<500){d=1;}
  if(millis()-times>500){d=0;}
  if(millis()-times>1000){times=millis();}
  
  if(set==0){
  a[0]=minut%10;
  a[1]=minut/10%10;
  a[2]=hour%10;
  a[3]=hour/10%10;}

  if(set!=2){a[0]=minut%10;}
  if(set!=2){a[1]=minut/10%10;}
  if(set==2&&mig==0){a[0]=minut%10;}
  if(set==2&&mig==0){a[1]=minut/10%10;}
  if(set==2&&mig==1){a[0]=10;}
  if(set==2&&mig==1){a[1]=10;}

  if(set!=1){a[2]=hour%10;}
  if(set!=1){a[3]=hour/10%10;}
  if(set==1&&mig==0){a[2]=hour%10;}
  if(set==1&&mig==0){a[3]=hour/10%10;}
  if(set==1&&mig==1){a[2]=10;}
  if(set==1&&mig==1){a[3]=10;}
  
 
             //dp g f e d c b a 
  write_byte2_PT6312(0b11000000,seg(a[0],0));//GR1
  write_byte2_PT6312(0b11000010,seg(a[1],0));//GR2
  write_byte2_PT6312(0b11000100,seg(a[2],0));//GR3
  write_byte2_PT6312(0b11000110,seg(a[3],0));//GR4
  write_byte2_PT6312(0b11001000,seg(0,d));//GR5
  delay(100);
}

byte seg(int a, bool dp){
  byte segm;
  switch(a){
    case 0: segm=0b00111111+(dp<<7);break;
    case 1: segm=0b00000110+(dp<<7);break;
    case 2: segm=0b01011011+(dp<<7);break;
    case 3: segm=0b01001111+(dp<<7);break;
    case 4: segm=0b01100110+(dp<<7);break;
    case 5: segm=0b01101101+(dp<<7);break;
    case 6: segm=0b01111101+(dp<<7);break;
    case 7: segm=0b00000111+(dp<<7);break;
    case 8: segm=0b01111111+(dp<<7);break;
    case 9: segm=0b01101111+(dp<<7);break;
    case 10:segm=0b00000000;break;// пусто
    case 11:segm=0b01000000;break;// -
    case 12:segm=0b01100011;break;// градус
    case 13:segm=0b00111001;break;// С
    }
    return segm;
  }

void write_byte1_PT6312(byte data){
     digitalWrite(STB,LOW);
   for(int i = 0; i <= 7; i++){
     digitalWrite(CLK,LOW);
     digitalWrite(DIN, (data >> i) & 1);
     digitalWrite(CLK,HIGH);
     }  
     digitalWrite(STB,HIGH);delay(1);
  }  

void write_byte2_PT6312(byte reg, byte data){
     digitalWrite(STB,LOW);
   for(int i = 0; i <= 7; i++){
     digitalWrite(CLK,LOW);
     digitalWrite(DIN, (reg >> i) & 1);
     digitalWrite(CLK,HIGH);
     }  
     delay(1);
   for(int i = 0; i <= 7; i++){
     digitalWrite(CLK,LOW);
     digitalWrite(DIN, (data >> i) & 1);
     digitalWrite(CLK,HIGH);
     }    
     digitalWrite(STB,HIGH);delay(1);
  }