Arduino.ru

Я так понимаю, что все 4 канала постоянно включены и работают, поэтому и получается такая шляпа с наложениями межвходной емкости, от этого происходит типа компенсации одной емкости и второй и они вычитаются, а показывается разница этих емкостей, как-то так...

Надо каким-то образом сделать, чтобы после измерения 1 канала, он отключался и включался 2 канал, и т.д.

ну так это неудивительно "абрам исакович" !!! как оно может работать если ты даже код по правилам форума вставить не можешь...

#include <SPI.h>
#include <Adafruit_GFX.h>      // include adafruit graphics library
#include <Adafruit_PCD8544.h>
 
// Software SPI (slower updates, more flexible pin options):
// pin 7 - Serial clock out (SCLK)
// pin 6 - Serial data out (DIN)
// pin 5 - Data/Command select (D/C)
// pin 4 - LCD chip select (CS)
// pin 3 - LCD reset (RST)
//Adafruit_PCD8544 display = Adafruit_PCD8544(7, 6, 5, 4, 3);
 
// Hardware SPI (faster, but must use certain hardware pins):
// SCK is LCD serial clock (SCLK) - this is pin 13 on Arduino Uno
// MOSI is LCD DIN - this is pin 11 on an Arduino Uno
// pin 5 - Data/Command select (D/C)
// pin 4 - LCD chip select (CS)
// pin 3 - LCD reset (RST)
Adafruit_PCD8544 display = Adafruit_PCD8544(5, 4, 3);
 
// ADC reference voltage / calibration value
#define V_REF    5.045 
 
const int IN_PIN = A3;
const int OUT_PIN = 6;
 
const int IN_PIN2 = A1;
const int OUT_PIN2 = 8;
 
const int IN_PIN3 = A2;
const int OUT_PIN3 = 7;
 
const int IN_PIN4 = A0;
const int OUT_PIN4 = 9;
 
const float IN_CAP_TO_GND  = 70.00;
const float R_PULLUP = 34.80;
const int MAX_ADC_VALUE = 1023;
 
void setup() {
  display.clearDisplay();              // Очищаем дисплей.
  display.begin();               // Инициализируем дисплея.
  display.display();
 
  pinMode(IN_PIN, OUTPUT);
  pinMode(OUT_PIN, OUTPUT);
 
  pinMode(IN_PIN2, OUTPUT);
  pinMode(OUT_PIN2, OUTPUT);
 
  pinMode(IN_PIN3, OUTPUT);
  pinMode(OUT_PIN3, OUTPUT);
 
  pinMode(IN_PIN4, OUTPUT);
  pinMode(OUT_PIN4, OUTPUT);
}
///////////////////////////////////КОНЕЦ(VOID SETUP)////////////////////////////
 
 
//-----------------------------НАЧАЛО(1СТР. ИЗМЕРЕНИЕ ЕМКОСТИ)--------------------------//
  void loop() 
  {
    display.setCursor(5, 0);
    display.print("TyT:");
    display.setCursor(5, 8);
    display.print("TaM:");
    display.setCursor(28, 0);
    display.print("1");
    display.setCursor(35, 0);
    display.print("2");
    display.setCursor(42, 0);
    display.print("3");
    display.setCursor(49, 0);
    display.print("4");
    display.setCursor(56, 0);
    display.print("5");
    display.setCursor(63, 0);
    display.print("6");
    display.setCursor(70, 0);
    display.print("7");
    display.setCursor(77, 0);
    display.print("8");
 
    display.setCursor(0, 16);
    display.print("(1-2)=");
    display.setCursor(0, 24);
    display.print("(3-6)=");
    display.setCursor(0, 32);
    display.print("(4-5)=");
    display.setCursor(0, 40);
    display.print("(7-8)=");
 
  /////////////////////////////////1 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ///////////////////////////////
  pinMode(IN_PIN, INPUT);
  digitalWrite(OUT_PIN, HIGH);
  int val = analogRead(IN_PIN);
  digitalWrite(OUT_PIN, LOW);
 
if (val < 1000)
  {
    pinMode(IN_PIN, OUTPUT);
 
    float capacitance = (float)val * IN_CAP_TO_GND / (float)(MAX_ADC_VALUE - val);
 
    display.setCursor(36, 16);
    display.print(capacitance, 0);
    display.setCursor(72, 16);
    display.print("pF");
 
    if (capacitance < 45) {
      display.setCursor(28, 8);
      display.print("-");
      display.setCursor(35, 8);
      display.print("-");
    }
 
    else if (capacitance > 45) {
      display.setCursor(28, 8);
      display.print("|");
      display.setCursor(35, 8);
      display.print("|");
    }
    
  }
  else
  {
    pinMode(IN_PIN, OUTPUT);
    pinMode(OUT_PIN, INPUT_PULLUP);
    unsigned long u1 = micros();
    unsigned long t;
    int digVal;
 
    do
    {
      digVal = digitalRead(OUT_PIN);
      unsigned long u2 = micros();
      t = u2 > u1 ? u2 - u1 : u1 - u2;
    }
 
    while ((digVal < 1) && (t < 40000L));
 
    pinMode(OUT_PIN, INPUT);
    val = analogRead(OUT_PIN);
    digitalWrite(IN_PIN, HIGH);
 
    int dischargeTime = (int)(t / 1000L) * 5;
    delay(dischargeTime);
    pinMode(OUT_PIN, OUTPUT);
    digitalWrite(OUT_PIN, LOW);
    digitalWrite(IN_PIN, LOW);
 
    float capacitance = +(float)t / R_PULLUP / log(2.84 - (float)val / (float)MAX_ADC_VALUE);
 
    if (capacitance > 10.0)
    {
      display.setCursor(36, 16);
      display.print("switch");
      display.setCursor(28, 8);
      display.print("1");
      display.setCursor(35, 8);
      display.print("2");
    }
    else
    {
      display.setCursor(36, 16);
      display.print(capacitance, 0);
      display.setCursor(72, 16);
      display.print("nF");
      display.setCursor(28, 8);
      display.print("|");
      display.setCursor(35, 8);
      display.print("|");
    }
  }
  ///////////////////////////////2 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ////////////////////////////
  pinMode(IN_PIN2, INPUT);
  digitalWrite(OUT_PIN2, HIGH);
  int val2 = analogRead(IN_PIN2);
  digitalWrite(OUT_PIN2, LOW);
 
  if (val2 < 1000)
  {
    pinMode(IN_PIN2, OUTPUT);
 
    float capacitance2 = (float)val2 * IN_CAP_TO_GND / (float)(MAX_ADC_VALUE - val2);
 
    display.setCursor(36, 24);
    display.print(capacitance2, 0);
    display.setCursor(72, 24);
    display.print("pF");
 
    if (capacitance2 < 45) {
      display.setCursor(42, 8);
      display.print("-");
      display.setCursor(63, 8);
      display.print("-");
    }
 
      else if (capacitance2 > 45) {
      display.setCursor(42, 8);
      display.print("|");
      display.setCursor(63, 8);
      display.print("|");
    }
    
  }
  else
  {
    pinMode(IN_PIN2, OUTPUT);
    pinMode(OUT_PIN2, INPUT_PULLUP);
    unsigned long u3 = micros();
    unsigned long t2;
    int digVal2;
 
    do
    {
      digVal2 = digitalRead(OUT_PIN2);
      unsigned long u4 = micros();
      t2 = u4 > u3 ? u4 - u3 : u3 - u4;
    }
 
    while ((digVal2 < 1) && (t2 < 40000L));
 
    pinMode(OUT_PIN2, INPUT);
    val2 = analogRead(OUT_PIN2);
    digitalWrite(IN_PIN2, HIGH);
 
    int dischargeTime2 = (int)(t2 / 1000L) * 5;
    delay(dischargeTime2);
    pinMode(OUT_PIN2, OUTPUT);
    digitalWrite(OUT_PIN2, LOW);
    digitalWrite(IN_PIN2, LOW);
 
    float capacitance2 = +(float)t2 / R_PULLUP / log(1.90 - (float)val2 / (float)MAX_ADC_VALUE);
 
    if (capacitance2 > 10.0)
    {
      display.setCursor(36, 24);
      display.print("switch");
      display.setCursor(42, 8);
      display.print("3");
      display.setCursor(63, 8);
      display.print("6");
    }
    else
    {
      display.setCursor(36, 24);
      display.print(capacitance2, 0);
      display.setCursor(72, 24);
      display.print("nF");
      display.setCursor(42, 8);
      display.print("|");
      display.setCursor(63, 8);
      display.print("|");
    }
  }
  ////////////////////////////////3 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ///////////////////////////////
  pinMode(IN_PIN3, INPUT);
  digitalWrite(OUT_PIN3, HIGH);
  int val3 = analogRead(IN_PIN3);
  digitalWrite(OUT_PIN3, LOW);
 
  if (val3 < 1000)
  {
    pinMode(IN_PIN3, OUTPUT);
 
    float capacitance3 = (float)val3 * IN_CAP_TO_GND / (float)(MAX_ADC_VALUE - val3);
 
    display.setCursor(36, 32);
    display.print(capacitance3, 0);
    display.setCursor(72, 32);
    display.print("pF");
    
    if (capacitance3 < 45) {
      display.setCursor(49, 8);
      display.print("-");
      display.setCursor(56, 8);
      display.print("-");
    }
 
      else if (capacitance3 > 45) {
      display.setCursor(49, 8);
      display.print("|");
      display.setCursor(56, 8);
      display.print("|");
    }
  }
  else
  {
    pinMode(IN_PIN3, OUTPUT);
    pinMode(OUT_PIN3, INPUT_PULLUP);
    unsigned long u5 = micros();
    unsigned long t3;
    int digVal3;
 
    do
    {
      digVal3 = digitalRead(OUT_PIN3);
      unsigned long u6 = micros();
      t3 = u6 > u5 ? u6 - u5 : u5 - u6;
    }
 
    while ((digVal3 < 1) && (t3 < 40000L));
 
    pinMode(OUT_PIN3, INPUT);
    val3 = analogRead(OUT_PIN3);
    digitalWrite(IN_PIN3, HIGH);
 
    int dischargeTime3 = (int)(t3 / 1000L) * 5;
    delay(dischargeTime3);
    pinMode(OUT_PIN3, OUTPUT);
    digitalWrite(OUT_PIN3, LOW);
    digitalWrite(IN_PIN3, LOW);
 
    float capacitance3 = +(float)t3 / R_PULLUP / log(2.90 - (float)val3 / (float)MAX_ADC_VALUE);
 
    if (capacitance3 > 10.0)
    {
      display.setCursor(36, 32);
      display.print("switch");
      display.setCursor(49, 8);
      display.print("4");
      display.setCursor(56, 8);
      display.print("5");
    }
    else
    {
      display.setCursor(36, 32);
      display.print(capacitance3, 0);
      display.setCursor(72, 32);
      display.print("nF");
      display.setCursor(49, 8);
      display.print("|");
      display.setCursor(56, 8);
      display.print("|");
    }
  }
  //////////////////////////////4 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ////////////////////////////////
  pinMode(IN_PIN4, INPUT);
  digitalWrite(OUT_PIN4, HIGH);
  int val4 = analogRead(IN_PIN4);
  digitalWrite(OUT_PIN4, LOW);
 
  if (val4 < 1000)
  {
    pinMode(IN_PIN4, OUTPUT);
 
    float capacitance4 = (float)val4 * IN_CAP_TO_GND / (float)(MAX_ADC_VALUE - val4);
 
    display.setCursor(36, 40);
    display.print(capacitance4, 0);
    display.setCursor(72, 40);
    display.print("pF");
    
    if (capacitance4 < 45) {
      display.setCursor(70, 8);
      display.print("-");
      display.setCursor(77, 8);
      display.print("-");
    }
 
      else if (capacitance4 > 45) {
      display.setCursor(70, 8);
      display.print("|");
      display.setCursor(77, 8);
      display.print("|");
    }
    
  }
  else
  {
    pinMode(IN_PIN4, OUTPUT);
    pinMode(OUT_PIN4, INPUT_PULLUP);
    unsigned long u7 = micros();
    unsigned long t4;
    int digVal4;
 
    do
    {
      digVal4 = digitalRead(OUT_PIN4);
      unsigned long u8 = micros();
      t4 = u8 > u7 ? u8 - u7 : u7 - u8;
    }
 
    while ((digVal4 < 1) && (t4 < 40000L));
 
    pinMode(OUT_PIN4, INPUT);
    val4 = analogRead(OUT_PIN4);
    digitalWrite(IN_PIN4, HIGH);
 
    int dischargeTime4 = (int)(t4 / 1000L) * 5;
    delay(dischargeTime4);
    pinMode(OUT_PIN4, OUTPUT);
    digitalWrite(OUT_PIN4, LOW);
    digitalWrite(IN_PIN4, LOW);
 
    float capacitance4 = +(float)t4 / R_PULLUP / log(1.97 - (float)val4 / (float)MAX_ADC_VALUE);
 
    if (capacitance4 > 10.0)
    {
      display.setCursor(36, 40);
      display.print("switch");
      display.setCursor(70, 8);
      display.print("7");
      display.setCursor(77, 8);
      display.print("8");
    }
    else
    {
      display.setCursor(36, 40);
      display.print(capacitance4, 0);
      display.setCursor(72, 40);
      display.print("nF");
      display.setCursor(70, 8);
      display.print("|");
      display.setCursor(77, 8);
      display.print("|");
    }
  }
 
    display.display();
    display.clearDisplay();
 
  }
  /////////////////////////////////////КОНЕЦ(1СТР. ИЗМЕРЕНИЕ ЕМКОСТИ)///////////////////////////////

Так ? :)

первую часть одолел, можно переходить ко второй части, теоретической, а каковы будут наводки на не нагруженном стандартном куске кабеля в упаковке 305 метров к примеру, то-есть правильно ли выбран принцип измерения длины кабеля

Ну смотрите, у меня есть максимум 34 метра витой пары на руках, наводки вроде как не мешают измерению. Кстати вот полная схема:

Кстати в процессе экспериментов, были нестабильные показания и ввел резисторы по 1 Мом на 4 цифровых пина, вот схема измененная:

ну во первых, если измерять ёмкость пары, достаточно остановиться на одной, к примеру зелёной, по ней и откалиброваться, все четыре пары имеют разный шаг повива, соответственно и разную длину 

Нет, вы не поняли суть проблемы. Одна пара измеряется без проблем. Проблема как раз в том, что при подключении одновременно 2 и более пар, измерения снижаются десятки раз, вместо 1500 пф показывают каждый из входов по 40-50 пф

Я в середине 2000-х как-то измерял параметры линков LAN в одной организации. Тестер был взят на прокат, мерил кажется 10 параметров, включая длину каждой пары. Длина измерялась посылкой импульсов и подсчётом времени их прохождения.
В кабеле всегда есть паразитные ёмкости между парами, это тоже тестируемый параметр.
Хотел вставить фотку, не вижу как.

наводки, это был мой изначальный посыл

Для начала бы справится с этой проблемой, а потом, если понадобится буду что-то думать с наводками

тогда 4х-канальный осциллограф тебе в помощь... и как реплика, ёмкость ты заряжаешь, а чем разряжаешь перед измерением?

Все, заработало как надо!

Полностью рабочий скетч и схема для самостоятельной сборки:

#include <SPI.h>
#include <Adafruit_GFX.h>      // include adafruit graphics library
#include <Adafruit_PCD8544.h>

// Hardware SPI (faster, but must use certain hardware pins):
// SCK is LCD serial clock (SCLK) - this is pin 13 on Arduino Uno
// MOSI is LCD DIN - this is pin 11 on an Arduino Uno
// pin 5 - Data/Command select (D/C)
// pin 4 - LCD chip select (CS)
// pin 3 - LCD reset (RST)
Adafruit_PCD8544 display = Adafruit_PCD8544(5, 4, 3);

const int IN_PIN = A3;
const int OUT_PIN = 6;
const int IN_PIN2 = A1;
const int OUT_PIN2 = 8;
const int IN_PIN3 = A2;
const int OUT_PIN3 = 7;
const int IN_PIN4 = A0;
const int OUT_PIN4 = 9;

const float IN_CAP_TO_GND1  =  70.00;
const float IN_CAP_TO_GND2  =  71.00;
const float IN_CAP_TO_GND3  =  68.00;
const float IN_CAP_TO_GND4  =  70.00;

const float R_PULLUP = 34.80;
const int MAX_ADC_VALUE = 1023;

void setup() {
  display.clearDisplay();              // Очищаем дисплей.
  display.begin();               // Инициализируем дисплея.
  display.display();
  //display.setContrast(50);             // Задаем контрастность дисплея.
  display.setRotation(0);              // Переворачиваем дисплей.
  display.invertDisplay(0);            // Инвертируем дисплей.
  //display.setTextSize(1);            // Задаем размер текста дисплея.
  //display.setTextColor(BLACK,WHITE);       // Задаем цвет шрифта дисплея.
}
//////////////////////////////КОНЕЦ(VOID SETUP)//////////////////////////////////

//--------------------------------НАЧАЛО(VOID LOOP)-------------------------------//
void loop() {
  display.setCursor(5, 0);
  display.print("TyT:");
  display.setCursor(5, 8);
  display.print("TaM:");
  display.setCursor(28, 0);
  display.print("1");
  display.setCursor(35, 0);
  display.print("2");
  display.setCursor(42, 0);
  display.print("3");
  display.setCursor(49, 0);
  display.print("4");
  display.setCursor(56, 0);
  display.print("5");
  display.setCursor(63, 0);
  display.print("6");
  display.setCursor(70, 0);
  display.print("7");
  display.setCursor(77, 0);
  display.print("8");

  display.setCursor(0, 16);
  display.print("(1-2)=");
  display.setCursor(0, 24);
  display.print("(3-6)=");
  display.setCursor(0, 32);
  display.print("(4-5)=");
  display.setCursor(0, 40);
  display.print("(7-8)=");


  //----------------------------НАЧАЛО(1СТР. ИЗМЕРЕНИЕ ЕМКОСТИ)--------------------------//

  /////////////////////////////1 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ/////////////////////////
  pinMode(IN_PIN, INPUT);
  digitalWrite(OUT_PIN, HIGH);
  int val = analogRead(IN_PIN);
  digitalWrite(OUT_PIN, LOW);

  if (val < 970)
  {
    pinMode(IN_PIN, OUTPUT);

    float capacitance = (float)val * IN_CAP_TO_GND1 / (float)(MAX_ADC_VALUE - val);
    delay (50);
    display.setCursor(36, 16);
    display.print(capacitance / 90, 0);
    display.setCursor(65, 16);
    display.print("M*C");

    if (capacitance < 100) {
      display.setCursor(28, 8);
      display.print("-");
      display.setCursor(35, 8);
      display.print("-");
    }

    else if (capacitance > 100) {
      display.setCursor(28, 8);
      display.print("|");
      display.setCursor(35, 8);
      display.print("|");
    }
  }
  else
  {
    pinMode(IN_PIN, OUTPUT);

    pinMode(OUT_PIN, INPUT_PULLUP);
    unsigned long u1 = micros();
    unsigned long t;
    int digVal;

    do
    {
      digVal = digitalRead(OUT_PIN);
      unsigned long u2 = micros();
      t = u2 > u1 ? u2 - u1 : u1 - u2;
    }

    while ((digVal < 1) && (t < 400000L));

    pinMode(OUT_PIN, INPUT);
    val = analogRead(OUT_PIN);
    digitalWrite(IN_PIN, HIGH);
    int dischargeTime = (int)(t / 10L) * 5;
    delay(dischargeTime);
    pinMode(OUT_PIN, OUTPUT);
    digitalWrite(OUT_PIN, LOW);
    digitalWrite(IN_PIN, LOW);

    float capacitance = +(float)t / R_PULLUP / log(2.94  - (float)val / (float)MAX_ADC_VALUE);

      display.setCursor(36, 16);
      display.print(capacitance / 0.041, 0);
      display.setCursor(65, 16);
      display.print("M*C");
      display.setCursor(28, 8);
      display.print("|");
      display.setCursor(35, 8);
      display.print("|");
  }
  pinMode(IN_PIN, INPUT);
  pinMode(OUT_PIN, INPUT);
  
  /////////////////////////////2 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ/////////////////////////////
  pinMode(IN_PIN2, INPUT);
  digitalWrite(OUT_PIN2, HIGH);
  int val2 = analogRead(IN_PIN2);
  digitalWrite(OUT_PIN2, LOW);

  if (val2 < 970)
  {
    pinMode(IN_PIN2, OUTPUT);

    float capacitance2 = (float)val2 * IN_CAP_TO_GND2 / (float)(MAX_ADC_VALUE - val2);
    delay (50);
    display.setCursor(36, 24);
    display.print(capacitance2 / 90, 0);
    display.setCursor(65, 24);
    display.print("M*C");

    if (capacitance2 < 100) {
      display.setCursor(42, 8);
      display.print("-");
      display.setCursor(63, 8);
      display.print("-");
    }

    else if (capacitance2 > 100) {
      display.setCursor(42, 8);
      display.print("|");
      display.setCursor(63, 8);
      display.print("|");
    }
  }
  else
  {
    pinMode(IN_PIN2, OUTPUT);

    pinMode(OUT_PIN2, INPUT_PULLUP);
    unsigned long u3 = micros();
    unsigned long t2;
    int digVal2;

    do
    {
      digVal2 = digitalRead(OUT_PIN2);
      unsigned long u4 = micros();
      t2 = u4 > u3 ? u4 - u3 : u3 - u4;
    }

    while ((digVal2 < 1) && (t2 < 400000L));

    pinMode(OUT_PIN2, INPUT);
    val2 = analogRead(OUT_PIN2);
    digitalWrite(IN_PIN2, HIGH);

    int dischargeTime2 = (int)(t2 / 10L) * 5;
    delay(dischargeTime2);

    pinMode(OUT_PIN2, OUTPUT);
    digitalWrite(OUT_PIN2, LOW);
    digitalWrite(IN_PIN2, LOW);

    float capacitance2 = +(float)t2 / R_PULLUP / log(2.22 - (float)val2 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 24);
      display.print(capacitance2 / 0.041, 0);
      display.setCursor(65, 24);
      display.print("M*C");
      display.setCursor(42, 8);
      display.print("|");
      display.setCursor(63, 8);
      display.print("|");
  }
  pinMode(IN_PIN2, INPUT);
  pinMode(OUT_PIN2, INPUT);
  
  //////////////////////////////3 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ//////////////////////////////
  pinMode(IN_PIN3, INPUT);
  digitalWrite(OUT_PIN3, HIGH);
  int val3 = analogRead(IN_PIN3);
  digitalWrite(OUT_PIN3, LOW);

  if (val3 < 970)
  {
    pinMode(IN_PIN3, OUTPUT);

    float capacitance3 = (float)val3 * IN_CAP_TO_GND3 / (float)(MAX_ADC_VALUE - val3);
    delay (50);
    display.setCursor(36, 32);
    display.print(capacitance3 / 90, 0);
    display.setCursor(65, 32);
    display.print("M*C");

    if (capacitance3 < 100) {
      display.setCursor(49, 8);
      display.print("-");
      display.setCursor(56, 8);
      display.print("-");
    }

    else if (capacitance3 > 100) {
      display.setCursor(49, 8);
      display.print("|");
      display.setCursor(56, 8);
      display.print("|");
    }
  }
  else
  {
    pinMode(IN_PIN3, OUTPUT);

    pinMode(OUT_PIN3, INPUT_PULLUP);
    unsigned long u5 = micros();
    unsigned long t3;
    int digVal3;

    do
    {
      digVal3 = digitalRead(OUT_PIN3);
      unsigned long u6 = micros();
      t3 = u6 > u5 ? u6 - u5 : u5 - u6;
    }

    while ((digVal3 < 1) && (t3 < 400000L));

    pinMode(OUT_PIN3, INPUT);
    val3 = analogRead(OUT_PIN3);
    digitalWrite(IN_PIN3, HIGH);

    int dischargeTime3 = (int)(t3 / 10L) * 5;
    delay(dischargeTime3);
    pinMode(OUT_PIN3, OUTPUT);
    digitalWrite(OUT_PIN3, LOW);
    digitalWrite(IN_PIN3, LOW);

    float capacitance3 = +(float)t3 / R_PULLUP / log(2.93 - (float)val3 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 32);
      display.print(capacitance3 / 0.041, 0);
      display.setCursor(65, 32);
      display.print("M*C");
      display.setCursor(49, 8);
      display.print("|");
      display.setCursor(56, 8);
      display.print("|");
  }
  pinMode(IN_PIN3, INPUT);
  pinMode(OUT_PIN3, INPUT);
  
  ////////////////////////////////4 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ///////////////////////////
  pinMode(IN_PIN4, INPUT);
  digitalWrite(OUT_PIN4, HIGH);
  int val4 = analogRead(IN_PIN4);
  digitalWrite(OUT_PIN4, LOW);

  if (val4 < 970)
  {
    pinMode(IN_PIN4, OUTPUT);

    float capacitance4 = (float)val4 * IN_CAP_TO_GND4 / (float)(MAX_ADC_VALUE - val4);
    delay (50);
    display.setCursor(36, 40);
    display.print(capacitance4 / 90, 0);
    display.setCursor(65, 40);
    display.print("M*C");

    if (capacitance4 < 100) {
      display.setCursor(70, 8);
      display.print("-");
      display.setCursor(77, 8);
      display.print("-");
    }

    else if (capacitance4 > 100) {
      display.setCursor(70, 8);
      display.print("|");
      display.setCursor(77, 8);
      display.print("|");
    }

  }
  else
  {
    pinMode(IN_PIN4, OUTPUT);

    pinMode(OUT_PIN4, INPUT_PULLUP);
    unsigned long u7 = micros();
    unsigned long t4;
    int digVal4;

    do
    {
      digVal4 = digitalRead(OUT_PIN4);
      unsigned long u8 = micros();
      t4 = u8 > u7 ? u8 - u7 : u7 - u8;
    }

    while ((digVal4 < 1) && (t4 < 400000L));

    pinMode(OUT_PIN4, INPUT);
    val4 = analogRead(OUT_PIN4);
    digitalWrite(IN_PIN4, HIGH);

    int dischargeTime4 = (int)(t4 / 10L) * 5;
    delay(dischargeTime4);
    pinMode(OUT_PIN4, OUTPUT);
    digitalWrite(OUT_PIN4, LOW);
    digitalWrite(IN_PIN4, LOW);

    float capacitance4 = +(float)t4 / R_PULLUP / log(2.23 - (float)val4 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 40);
      display.print(capacitance4 / 0.041, 0);
      display.setCursor(65, 40);
      display.print("M*C");
      display.setCursor(70, 8);
      display.print("|");
      display.setCursor(77, 8);
      display.print("|");
  }
  pinMode(IN_PIN4, INPUT);
  pinMode(OUT_PIN4, INPUT);
  
  ////////////////////////////////КОНЕЦ(1СТР. ИЗМЕРЕНИЕ ЕМКОСТИ)////////////////////////////////

  display.display();
  display.clearDisplay();
}
/////////////////////////////////КОНЕЦ(VOID LOOP)////////////////////////////////////

мой пинок помог )))

Как говорится - С миру по нитке :))

1) Такую "простынку" надо прятать под "спойлер"

2) Чуть напильником пильнуть и со свистом в 168ю мегу влезет.

Вот так уже (даже с бутлоадером) влазит:

#include <SPI.h>
#include <Adafruit_GFX.h>      // include adafruit graphics library
#include <Adafruit_PCD8544.h>

// Hardware SPI (faster, but must use certain hardware pins):
// SCK is LCD serial clock (SCLK) - this is pin 13 on Arduino Uno
// MOSI is LCD DIN - this is pin 11 on an Arduino Uno
// pin 5 - Data/Command select (D/C)
// pin 4 - LCD chip select (CS)
// pin 3 - LCD reset (RST)
Adafruit_PCD8544 display = Adafruit_PCD8544(5, 4, 3);

const uint8_t IN_PIN = A3;
const uint8_t OUT_PIN = 6;
const uint8_t IN_PIN2 = A1;
const uint8_t OUT_PIN2 = 8;
const uint8_t IN_PIN3 = A2;
const uint8_t OUT_PIN3 = 7;
const uint8_t IN_PIN4 = A0;
const uint8_t OUT_PIN4 = 9;

const float IN_CAP_TO_GND1  =  70.00;
const float IN_CAP_TO_GND2  =  71.00;
const float IN_CAP_TO_GND3  =  68.00;
const float IN_CAP_TO_GND4  =  70.00;

const float R_PULLUP = 34.80;
const int MAX_ADC_VALUE = 1023;

void setup() {
  display.clearDisplay();              // Очищаем дисплей.
  display.begin();               // Инициализируем дисплея.
  display.display();
  //display.setContrast(50);             // Задаем контрастность дисплея.
  display.setRotation(0);              // Переворачиваем дисплей.
  display.invertDisplay(0);            // Инвертируем дисплей.
  //display.setTextSize(1);            // Задаем размер текста дисплея.
  //display.setTextColor(BLACK,WHITE);       // Задаем цвет шрифта дисплея.
}
//////////////////////////////КОНЕЦ(VOID SETUP)//////////////////////////////////

//--------------------------------НАЧАЛО(VOID LOOP)-------------------------------//
void loop() {
  display.setCursor(5, 0);
  display.print(F("TyT:"));
  display.setCursor(5, 8);
  display.print(F("TaM:"));
  display.setCursor(28, 0);
  display.print(F("1"));
  display.setCursor(35, 0);
  display.print(F("2"));
  display.setCursor(42, 0);
  display.print(F("3"));
  display.setCursor(49, 0);
  display.print(F("4"));
  display.setCursor(56, 0);
  display.print(F("5"));
  display.setCursor(63, 0);
  display.print(F("6"));
  display.setCursor(70, 0);
  display.print(F("7"));
  display.setCursor(77, 0);
  display.print(F("8"));

  display.setCursor(0, 16);
  display.print(F("(1-2)="));
  display.setCursor(0, 24);
  display.print(F("(3-6)="));
  display.setCursor(0, 32);
  display.print(F("(4-5)="));
  display.setCursor(0, 40);
  display.print(F("(7-8)="));


  //----------------------------НАЧАЛО(1СТР. ИЗМЕРЕНИЕ ЕМКОСТИ)--------------------------//

  /////////////////////////////1 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ/////////////////////////
  pinMode(IN_PIN, INPUT);
  digitalWrite(OUT_PIN, HIGH);
  int val = analogRead(IN_PIN);
  digitalWrite(OUT_PIN, LOW);

  if (val < 970)
  {
    pinMode(IN_PIN, OUTPUT);

    float capacitance = (float)val * IN_CAP_TO_GND1 / (float)(MAX_ADC_VALUE - val);
    delay (50);
    display.setCursor(36, 16);
    display.print(capacitance / 90, 0);
    display.setCursor(65, 16);
    display.print(F("M*C"));

    if (capacitance < 100) {
      display.setCursor(28, 8);
      display.print(F("-"));
      display.setCursor(35, 8);
      display.print(F("-"));
    }

    else if (capacitance > 100) {
      display.setCursor(28, 8);
      display.print(F("|"));
      display.setCursor(35, 8);
      display.print(F("|"));
    }
  }
  else
  {
    pinMode(IN_PIN, OUTPUT);

    pinMode(OUT_PIN, INPUT_PULLUP);
    unsigned long u1 = micros();
    unsigned long t;
    int digVal;

    do
    {
      digVal = digitalRead(OUT_PIN);
      unsigned long u2 = micros();
      t = u2 > u1 ? u2 - u1 : u1 - u2;
    }

    while ((digVal < 1) && (t < 400000L));

    pinMode(OUT_PIN, INPUT);
    val = analogRead(OUT_PIN);
    digitalWrite(IN_PIN, HIGH);
    int dischargeTime = (int)(t / 10L) * 5;
    delay(dischargeTime);
    pinMode(OUT_PIN, OUTPUT);
    digitalWrite(OUT_PIN, LOW);
    digitalWrite(IN_PIN, LOW);

    float capacitance = +(float)t / R_PULLUP / log(2.94  - (float)val / (float)MAX_ADC_VALUE);

      display.setCursor(36, 16);
      display.print(capacitance / 0.041, 0);
      display.setCursor(65, 16);
      display.print(F("M*C"));
      display.setCursor(28, 8);
      display.print(F("|"));
      display.setCursor(35, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN, INPUT);
  pinMode(OUT_PIN, INPUT);
  
  /////////////////////////////2 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ/////////////////////////////
  pinMode(IN_PIN2, INPUT);
  digitalWrite(OUT_PIN2, HIGH);
  int val2 = analogRead(IN_PIN2);
  digitalWrite(OUT_PIN2, LOW);

  if (val2 < 970)
  {
    pinMode(IN_PIN2, OUTPUT);

    float capacitance2 = (float)val2 * IN_CAP_TO_GND2 / (float)(MAX_ADC_VALUE - val2);
    delay (50);
    display.setCursor(36, 24);
    display.print(capacitance2 / 90, 0);
    display.setCursor(65, 24);
    display.print(F("M*C"));

    if (capacitance2 < 100) {
      display.setCursor(42, 8);
      display.print(F("-"));
      display.setCursor(63, 8);
      display.print(F("-"));
    }

    else if (capacitance2 > 100) {
      display.setCursor(42, 8);
      display.print(F("|"));
      display.setCursor(63, 8);
      display.print(F("|"));
    }
  }
  else
  {
    pinMode(IN_PIN2, OUTPUT);

    pinMode(OUT_PIN2, INPUT_PULLUP);
    unsigned long u3 = micros();
    unsigned long t2;
    int digVal2;

    do
    {
      digVal2 = digitalRead(OUT_PIN2);
      unsigned long u4 = micros();
      t2 = u4 > u3 ? u4 - u3 : u3 - u4;
    }

    while ((digVal2 < 1) && (t2 < 400000L));

    pinMode(OUT_PIN2, INPUT);
    val2 = analogRead(OUT_PIN2);
    digitalWrite(IN_PIN2, HIGH);

    int dischargeTime2 = (int)(t2 / 10L) * 5;
    delay(dischargeTime2);

    pinMode(OUT_PIN2, OUTPUT);
    digitalWrite(OUT_PIN2, LOW);
    digitalWrite(IN_PIN2, LOW);

    float capacitance2 = +(float)t2 / R_PULLUP / log(2.22 - (float)val2 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 24);
      display.print(capacitance2 / 0.041, 0);
      display.setCursor(65, 24);
      display.print(F("M*C"));
      display.setCursor(42, 8);
      display.print(F("|"));
      display.setCursor(63, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN2, INPUT);
  pinMode(OUT_PIN2, INPUT);
  
  //////////////////////////////3 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ//////////////////////////////
  pinMode(IN_PIN3, INPUT);
  digitalWrite(OUT_PIN3, HIGH);
  int val3 = analogRead(IN_PIN3);
  digitalWrite(OUT_PIN3, LOW);

  if (val3 < 970)
  {
    pinMode(IN_PIN3, OUTPUT);

    float capacitance3 = (float)val3 * IN_CAP_TO_GND3 / (float)(MAX_ADC_VALUE - val3);
    delay (50);
    display.setCursor(36, 32);
    display.print(capacitance3 / 90, 0);
    display.setCursor(65, 32);
    display.print(F("M*C"));

    if (capacitance3 < 100) {
      display.setCursor(49, 8);
      display.print(F("-"));
      display.setCursor(56, 8);
      display.print(F("-"));
    }

    else if (capacitance3 > 100) {
      display.setCursor(49, 8);
      display.print(F("|"));
      display.setCursor(56, 8);
      display.print(F("|"));
    }
  }
  else
  {
    pinMode(IN_PIN3, OUTPUT);

    pinMode(OUT_PIN3, INPUT_PULLUP);
    unsigned long u5 = micros();
    unsigned long t3;
    int digVal3;

    do
    {
      digVal3 = digitalRead(OUT_PIN3);
      unsigned long u6 = micros();
      t3 = u6 > u5 ? u6 - u5 : u5 - u6;
    }

    while ((digVal3 < 1) && (t3 < 400000L));

    pinMode(OUT_PIN3, INPUT);
    val3 = analogRead(OUT_PIN3);
    digitalWrite(IN_PIN3, HIGH);

    int dischargeTime3 = (int)(t3 / 10L) * 5;
    delay(dischargeTime3);
    pinMode(OUT_PIN3, OUTPUT);
    digitalWrite(OUT_PIN3, LOW);
    digitalWrite(IN_PIN3, LOW);

    float capacitance3 = +(float)t3 / R_PULLUP / log(2.93 - (float)val3 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 32);
      display.print(capacitance3 / 0.041, 0);
      display.setCursor(65, 32);
      display.print(F("M*C"));
      display.setCursor(49, 8);
      display.print(F("|"));
      display.setCursor(56, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN3, INPUT);
  pinMode(OUT_PIN3, INPUT);
  
  ////////////////////////////////4 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ///////////////////////////
  pinMode(IN_PIN4, INPUT);
  digitalWrite(OUT_PIN4, HIGH);
  int val4 = analogRead(IN_PIN4);
  digitalWrite(OUT_PIN4, LOW);

  if (val4 < 970)
  {
    pinMode(IN_PIN4, OUTPUT);

    float capacitance4 = (float)val4 * IN_CAP_TO_GND4 / (float)(MAX_ADC_VALUE - val4);
    delay (50);
    display.setCursor(36, 40);
    display.print(capacitance4 / 90, 0);
    display.setCursor(65, 40);
    display.print(F("M*C"));

    if (capacitance4 < 100) {
      display.setCursor(70, 8);
      display.print(F("-"));
      display.setCursor(77, 8);
      display.print(F("-"));
    }

    else if (capacitance4 > 100) {
      display.setCursor(70, 8);
      display.print(F("|"));
      display.setCursor(77, 8);
      display.print(F("|"));
    }

  }
  else
  {
    pinMode(IN_PIN4, OUTPUT);

    pinMode(OUT_PIN4, INPUT_PULLUP);
    unsigned long u7 = micros();
    unsigned long t4;
    int digVal4;

    do
    {
      digVal4 = digitalRead(OUT_PIN4);
      unsigned long u8 = micros();
      t4 = u8 > u7 ? u8 - u7 : u7 - u8;
    }

    while ((digVal4 < 1) && (t4 < 400000L));

    pinMode(OUT_PIN4, INPUT);
    val4 = analogRead(OUT_PIN4);
    digitalWrite(IN_PIN4, HIGH);

    int dischargeTime4 = (int)(t4 / 10L) * 5;
    delay(dischargeTime4);
    pinMode(OUT_PIN4, OUTPUT);
    digitalWrite(OUT_PIN4, LOW);
    digitalWrite(IN_PIN4, LOW);

    float capacitance4 = +(float)t4 / R_PULLUP / log(2.23 - (float)val4 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 40);
      display.print(capacitance4 / 0.041, 0);
      display.setCursor(65, 40);
      display.print(F("M*C"));
      display.setCursor(70, 8);
      display.print(F("|"));
      display.setCursor(77, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN4, INPUT);
  pinMode(OUT_PIN4, INPUT);
  
  ////////////////////////////////КОНЕЦ(1СТР. ИЗМЕРЕНИЕ ЕМКОСТИ)////////////////////////////////

  display.display();
  display.clearDisplay();
}
/////////////////////////////////КОНЕЦ(VOID LOOP)////////////////////////////////////

Скетч использует 14762 байт (93%) памяти устройства. Всего доступно 15872 байт.
Глобальные переменные используют 727 байт (70%) динамической памяти, оставляя 297 байт для локальных переменных. Максимум: 1024 байт.

А если учесть, что 4 раза практически один и тот же код повторяется, то можно ещё сократить. Но не сильно. Библиотеки тяжёлые.

классика жанра...

Как написать код для 4х-канального измерителя емкости? - написать для 1-канального и потом скопировать 4 раза...

Gladiator - чтобы в следующий раз не выкладывать подобную х-ню вместо кода, почитайте что-нибудь про циклы и процедуры.

да, код написан в лоб, не умеет пока человек, но это исправимо )))

Я вообще не программист, и не знаю ни одного языка программирования, я электрощик :) Но очень интересно ковыряться с ардуиной и совмещать с электроникой, пробовать делать то, что необходимо. И мне кажется не важно, что я кучу кода написал может ненужного, зато работает :) Сейчас этот приборчик использую на работе, а работаю интернетчиком. 

И кстати, это только часть кода, которую я запихнул в ардуинку нано.  У меня скетч с меню на одной кнопке, где 7 подпрограмм:

1 - это 4 канальный измеритель длины витой пары по емкости . С индикацией по каждой паре, в случае подключенного кабеля к свитчу или роутеру.

2 - это 4 канальный измеритель длины витой пары по сопротивлению, с сигнализацией (пищалка) перекоса между парами на 1 Ом (можно настраивать). 

3 - это 4 канальный измеритель длины витой пары по сопротивлению, со звуковой сигнализацией (пищалка) целостности каждой пары с разными тонами.

4 - это 4 канальный измеритель длины витой пары по сопротивлению, с переводом в метраж.

5 - Двухканальный Тон генератор на 1 Кгц

6 - Двухканальный Тон генератор на 9 Кгц

7 - Двухканальный Тон генератор на 18 Кгц

Тональные генераторы для поиска нужного кабеля в пучке кабелей.

Сегодня кстати испытал Тональный генератор на 18Кгц и приборчик отлично справился с поиском нужного мне кабеля. Вместо приемника использовал смартфон с прогой Анализатор спектра и приблудой (на полевом транзисторе) втыкаемой в разьем для гарнитуры.

И на счет выкладывания... я бы и не выкладывал, но не мог справится с той проблемой, что описывал в самом начале. Поэтому и решил спросить у народа подсказку.

Ну ок, больше не буду ничего выкладывать :)) Буду для себя изобретать :)

#include <SPI.h>
#include <Adafruit_GFX.h>      // include adafruit graphics library
#include <Adafruit_PCD8544.h>

// Hardware SPI (faster, but must use certain hardware pins):
// SCK is LCD serial clock (SCLK) - this is pin 13 on Arduino Uno
// MOSI is LCD DIN - this is pin 11 on an Arduino Uno
// pin 5 - Data/Command select (D/C)
// pin 4 - LCD chip select (CS)
// pin 3 - LCD reset (RST)
Adafruit_PCD8544 display = Adafruit_PCD8544(5, 4, 3);

const uint8_t IN_PIN = A3;
const uint8_t OUT_PIN = 6;
const uint8_t IN_PIN2 = A1;
const uint8_t OUT_PIN2 = 8;
const uint8_t IN_PIN3 = A2;
const uint8_t OUT_PIN3 = 7;
const uint8_t IN_PIN4 = A0;
const uint8_t OUT_PIN4 = 9;

const float IN_CAP_TO_GND1  =  70.00;
const float IN_CAP_TO_GND2  =  71.00;
const float IN_CAP_TO_GND3  =  68.00;
const float IN_CAP_TO_GND4  =  70.00;

const float R_PULLUP = 34.80;
const int MAX_ADC_VALUE = 1023;

void setup() {
  display.clearDisplay();              // Очищаем дисплей.
  display.begin();               // Инициализируем дисплея.
  display.display();
  //display.setContrast(50);             // Задаем контрастность дисплея.
  display.setRotation(0);              // Переворачиваем дисплей.
  display.invertDisplay(0);            // Инвертируем дисплей.
  //display.setTextSize(1);            // Задаем размер текста дисплея.
  //display.setTextColor(BLACK,WHITE);       // Задаем цвет шрифта дисплея.
}
//////////////////////////////КОНЕЦ(VOID SETUP)//////////////////////////////////

//--------------------------------НАЧАЛО(VOID LOOP)-------------------------------//
void loop() {
  display.setCursor(5, 0);
  display.print(F("TyT:"));
  display.setCursor(5, 8);
  display.print(F("TaM:"));
  display.setCursor(28, 0);
  display.print(F("1"));
  display.setCursor(35, 0);
  display.print(F("2"));
  display.setCursor(42, 0);
  display.print(F("3"));
  display.setCursor(49, 0);
  display.print(F("4"));
  display.setCursor(56, 0);
  display.print(F("5"));
  display.setCursor(63, 0);
  display.print(F("6"));
  display.setCursor(70, 0);
  display.print(F("7"));
  display.setCursor(77, 0);
  display.print(F("8"));

  display.setCursor(0, 16);
  display.print(F("(1-2)="));
  display.setCursor(0, 24);
  display.print(F("(3-6)="));
  display.setCursor(0, 32);
  display.print(F("(4-5)="));
  display.setCursor(0, 40);
  display.print(F("(7-8)="));


  //----------------------------НАЧАЛО(1СТР. ИЗМЕРЕНИЕ ЕМКОСТИ)--------------------------//

  /////////////////////////////1 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ/////////////////////////
  pinMode(IN_PIN, INPUT);
  digitalWrite(OUT_PIN, HIGH);
  int val = analogRead(IN_PIN);
  digitalWrite(OUT_PIN, LOW);

  if (val < 970)
  {
    pinMode(IN_PIN, OUTPUT);

    float capacitance = (float)val * IN_CAP_TO_GND1 / (float)(MAX_ADC_VALUE - val);
    delay (50);
    display.setCursor(36, 16);
    display.print(capacitance / 90, 0);
    display.setCursor(65, 16);
    display.print(F("M*C"));

    if (capacitance < 100) {
      display.setCursor(28, 8);
      display.print(F("-"));
      display.setCursor(35, 8);
      display.print(F("-"));
    }

    else if (capacitance > 100) {
      display.setCursor(28, 8);
      display.print(F("|"));
      display.setCursor(35, 8);
      display.print(F("|"));
    }
  }
  else
  {
    pinMode(IN_PIN, OUTPUT);

    pinMode(OUT_PIN, INPUT_PULLUP);
    unsigned long u1 = micros();
    unsigned long t;
    int digVal;

    do
    {
      digVal = digitalRead(OUT_PIN);
      unsigned long u2 = micros();
      t = u2 > u1 ? u2 - u1 : u1 - u2;
    }

    while ((digVal < 1) && (t < 400000L));

    pinMode(OUT_PIN, INPUT);
    val = analogRead(OUT_PIN);
    digitalWrite(IN_PIN, HIGH);
    int dischargeTime = (int)(t / 10L) * 5;
    delay(dischargeTime);
    pinMode(OUT_PIN, OUTPUT);
    digitalWrite(OUT_PIN, LOW);
    digitalWrite(IN_PIN, LOW);

    float capacitance = +(float)t / R_PULLUP / log(2.94  - (float)val / (float)MAX_ADC_VALUE);

      display.setCursor(36, 16);
      display.print(capacitance / 0.041, 0);
      display.setCursor(65, 16);
      display.print(F("M*C"));
      display.setCursor(28, 8);
      display.print(F("|"));
      display.setCursor(35, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN, INPUT);
  pinMode(OUT_PIN, INPUT);
  
  /////////////////////////////2 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ/////////////////////////////
  pinMode(IN_PIN2, INPUT);
  digitalWrite(OUT_PIN2, HIGH);
  int val2 = analogRead(IN_PIN2);
  digitalWrite(OUT_PIN2, LOW);

  if (val2 < 970)
  {
    pinMode(IN_PIN2, OUTPUT);

    float capacitance2 = (float)val2 * IN_CAP_TO_GND2 / (float)(MAX_ADC_VALUE - val2);
    delay (50);
    display.setCursor(36, 24);
    display.print(capacitance2 / 90, 0);
    display.setCursor(65, 24);
    display.print(F("M*C"));

    if (capacitance2 < 100) {
      display.setCursor(42, 8);
      display.print(F("-"));
      display.setCursor(63, 8);
      display.print(F("-"));
    }

    else if (capacitance2 > 100) {
      display.setCursor(42, 8);
      display.print(F("|"));
      display.setCursor(63, 8);
      display.print(F("|"));
    }
  }
  else
  {
    pinMode(IN_PIN2, OUTPUT);

    pinMode(OUT_PIN2, INPUT_PULLUP);
    unsigned long u3 = micros();
    unsigned long t2;
    int digVal2;

    do
    {
      digVal2 = digitalRead(OUT_PIN2);
      unsigned long u4 = micros();
      t2 = u4 > u3 ? u4 - u3 : u3 - u4;
    }

    while ((digVal2 < 1) && (t2 < 400000L));

    pinMode(OUT_PIN2, INPUT);
    val2 = analogRead(OUT_PIN2);
    digitalWrite(IN_PIN2, HIGH);

    int dischargeTime2 = (int)(t2 / 10L) * 5;
    delay(dischargeTime2);

    pinMode(OUT_PIN2, OUTPUT);
    digitalWrite(OUT_PIN2, LOW);
    digitalWrite(IN_PIN2, LOW);

    float capacitance2 = +(float)t2 / R_PULLUP / log(2.22 - (float)val2 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 24);
      display.print(capacitance2 / 0.041, 0);
      display.setCursor(65, 24);
      display.print(F("M*C"));
      display.setCursor(42, 8);
      display.print(F("|"));
      display.setCursor(63, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN2, INPUT);
  pinMode(OUT_PIN2, INPUT);
  
  //////////////////////////////3 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ//////////////////////////////
  pinMode(IN_PIN3, INPUT);
  digitalWrite(OUT_PIN3, HIGH);
  int val3 = analogRead(IN_PIN3);
  digitalWrite(OUT_PIN3, LOW);

  if (val3 < 970)
  {
    pinMode(IN_PIN3, OUTPUT);

    float capacitance3 = (float)val3 * IN_CAP_TO_GND3 / (float)(MAX_ADC_VALUE - val3);
    delay (50);
    display.setCursor(36, 32);
    display.print(capacitance3 / 90, 0);
    display.setCursor(65, 32);
    display.print(F("M*C"));

    if (capacitance3 < 100) {
      display.setCursor(49, 8);
      display.print(F("-"));
      display.setCursor(56, 8);
      display.print(F("-"));
    }

    else if (capacitance3 > 100) {
      display.setCursor(49, 8);
      display.print(F("|"));
      display.setCursor(56, 8);
      display.print(F("|"));
    }
  }
  else
  {
    pinMode(IN_PIN3, OUTPUT);

    pinMode(OUT_PIN3, INPUT_PULLUP);
    unsigned long u5 = micros();
    unsigned long t3;
    int digVal3;

    do
    {
      digVal3 = digitalRead(OUT_PIN3);
      unsigned long u6 = micros();
      t3 = u6 > u5 ? u6 - u5 : u5 - u6;
    }

    while ((digVal3 < 1) && (t3 < 400000L));

    pinMode(OUT_PIN3, INPUT);
    val3 = analogRead(OUT_PIN3);
    digitalWrite(IN_PIN3, HIGH);

    int dischargeTime3 = (int)(t3 / 10L) * 5;
    delay(dischargeTime3);
    pinMode(OUT_PIN3, OUTPUT);
    digitalWrite(OUT_PIN3, LOW);
    digitalWrite(IN_PIN3, LOW);

    float capacitance3 = +(float)t3 / R_PULLUP / log(2.93 - (float)val3 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 32);
      display.print(capacitance3 / 0.041, 0);
      display.setCursor(65, 32);
      display.print(F("M*C"));
      display.setCursor(49, 8);
      display.print(F("|"));
      display.setCursor(56, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN3, INPUT);
  pinMode(OUT_PIN3, INPUT);
  
  ////////////////////////////////4 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ///////////////////////////
  pinMode(IN_PIN4, INPUT);
  digitalWrite(OUT_PIN4, HIGH);
  int val4 = analogRead(IN_PIN4);
  digitalWrite(OUT_PIN4, LOW);

  if (val4 < 970)
  {
    pinMode(IN_PIN4, OUTPUT);

    float capacitance4 = (float)val4 * IN_CAP_TO_GND4 / (float)(MAX_ADC_VALUE - val4);
    delay (50);
    display.setCursor(36, 40);
    display.print(capacitance4 / 90, 0);
    display.setCursor(65, 40);
    display.print(F("M*C"));

    if (capacitance4 < 100) {
      display.setCursor(70, 8);
      display.print(F("-"));
      display.setCursor(77, 8);
      display.print(F("-"));
    }

    else if (capacitance4 > 100) {
      display.setCursor(70, 8);
      display.print(F("|"));
      display.setCursor(77, 8);
      display.print(F("|"));
    }

  }
  else
  {
    pinMode(IN_PIN4, OUTPUT);

    pinMode(OUT_PIN4, INPUT_PULLUP);
    unsigned long u7 = micros();
    unsigned long t4;
    int digVal4;

    do
    {
      digVal4 = digitalRead(OUT_PIN4);
      unsigned long u8 = micros();
      t4 = u8 > u7 ? u8 - u7 : u7 - u8;
    }

    while ((digVal4 < 1) && (t4 < 400000L));

    pinMode(OUT_PIN4, INPUT);
    val4 = analogRead(OUT_PIN4);
    digitalWrite(IN_PIN4, HIGH);

    int dischargeTime4 = (int)(t4 / 10L) * 5;
    delay(dischargeTime4);
    pinMode(OUT_PIN4, OUTPUT);
    digitalWrite(OUT_PIN4, LOW);
    digitalWrite(IN_PIN4, LOW);

    float capacitance4 = +(float)t4 / R_PULLUP / log(2.23 - (float)val4 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 40);
      display.print(capacitance4 / 0.041, 0);
      display.setCursor(65, 40);
      display.print(F("M*C"));
      display.setCursor(70, 8);
      display.print(F("|"));
      display.setCursor(77, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN4, INPUT);
  pinMode(OUT_PIN4, INPUT);
  
  ////////////////////////////////КОНЕЦ(1СТР. ИЗМЕРЕНИЕ ЕМКОСТИ)////////////////////////////////

  display.display();
  display.clearDisplay();
}
/////////////////////////////////КОНЕЦ(VOID LOOP)////////////////////////////////////

Скетч использует 14762 байт (93%) памяти устройства. Всего доступно 15872 байт.
Глобальные переменные используют 727 байт (70%) динамической памяти, оставляя 297 байт для локальных переменных. Максимум: 1024 байт.

Не влезет :) У меня же не только измеритель длины кабеля по емкости, а приборчик 10 в 1. Я выше писал :) Хотя профи я думаю сможет всунуть и такой код в 168 атмегу :) У меня сейчас код занимает 23 840 байт

кстати тональный генератор с приёмником весьма хорошая вещь для монтажников, надысь пришлось из полсотни кабелей два десятка отбирать, генератора не было, обошлось разделкой всех кабелей на две патч-панели, с последующей переразделкой на рабочую, а был бы генератор кучу времени сэкономил бы

На Али имеется, надо будет заказать )))

Можно покумекать, как засунуть/улучшить. Штука полезная, если действительно работает.
Напишите мне на wrk.sadman@gmail.com, если хотите - на выходных посмотрю, что сделать можно.

#include <SPI.h>
#include <Adafruit_GFX.h>      // include adafruit graphics library
#include <Adafruit_PCD8544.h>

// Hardware SPI (faster, but must use certain hardware pins):
// SCK is LCD serial clock (SCLK) - this is pin 13 on Arduino Uno
// MOSI is LCD DIN - this is pin 11 on an Arduino Uno
// pin 5 - Data/Command select (D/C)
// pin 4 - LCD chip select (CS)
// pin 3 - LCD reset (RST)
Adafruit_PCD8544 display = Adafruit_PCD8544(5, 4, 3);

const uint8_t IN_PIN = A3;
const uint8_t OUT_PIN = 6;
const uint8_t IN_PIN2 = A1;
const uint8_t OUT_PIN2 = 8;
const uint8_t IN_PIN3 = A2;
const uint8_t OUT_PIN3 = 7;
const uint8_t IN_PIN4 = A0;
const uint8_t OUT_PIN4 = 9;

const float IN_CAP_TO_GND1  =  70.00;
const float IN_CAP_TO_GND2  =  71.00;
const float IN_CAP_TO_GND3  =  68.00;
const float IN_CAP_TO_GND4  =  70.00;

const float R_PULLUP = 34.80;
const int MAX_ADC_VALUE = 1023;

void setup() {
  display.clearDisplay();              // Очищаем дисплей.
  display.begin();               // Инициализируем дисплея.
  display.display();
  //display.setContrast(50);             // Задаем контрастность дисплея.
  display.setRotation(0);              // Переворачиваем дисплей.
  display.invertDisplay(0);            // Инвертируем дисплей.
  //display.setTextSize(1);            // Задаем размер текста дисплея.
  //display.setTextColor(BLACK,WHITE);       // Задаем цвет шрифта дисплея.
}
//////////////////////////////КОНЕЦ(VOID SETUP)//////////////////////////////////

//--------------------------------НАЧАЛО(VOID LOOP)-------------------------------//
void loop() {
  display.setCursor(5, 0);
  display.print(F("TyT:"));
  display.setCursor(5, 8);
  display.print(F("TaM:"));
  display.setCursor(28, 0);
  display.print(F("1"));
  display.setCursor(35, 0);
  display.print(F("2"));
  display.setCursor(42, 0);
  display.print(F("3"));
  display.setCursor(49, 0);
  display.print(F("4"));
  display.setCursor(56, 0);
  display.print(F("5"));
  display.setCursor(63, 0);
  display.print(F("6"));
  display.setCursor(70, 0);
  display.print(F("7"));
  display.setCursor(77, 0);
  display.print(F("8"));

  display.setCursor(0, 16);
  display.print(F("(1-2)="));
  display.setCursor(0, 24);
  display.print(F("(3-6)="));
  display.setCursor(0, 32);
  display.print(F("(4-5)="));
  display.setCursor(0, 40);
  display.print(F("(7-8)="));


  //----------------------------НАЧАЛО(1СТР. ИЗМЕРЕНИЕ ЕМКОСТИ)--------------------------//

  /////////////////////////////1 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ/////////////////////////
  pinMode(IN_PIN, INPUT);
  digitalWrite(OUT_PIN, HIGH);
  int val = analogRead(IN_PIN);
  digitalWrite(OUT_PIN, LOW);

  if (val < 970)
  {
    pinMode(IN_PIN, OUTPUT);

    float capacitance = (float)val * IN_CAP_TO_GND1 / (float)(MAX_ADC_VALUE - val);
    delay (50);
    display.setCursor(36, 16);
    display.print(capacitance / 90, 0);
    display.setCursor(65, 16);
    display.print(F("M*C"));

    if (capacitance < 100) {
      display.setCursor(28, 8);
      display.print(F("-"));
      display.setCursor(35, 8);
      display.print(F("-"));
    }

    else if (capacitance > 100) {
      display.setCursor(28, 8);
      display.print(F("|"));
      display.setCursor(35, 8);
      display.print(F("|"));
    }
  }
  else
  {
    pinMode(IN_PIN, OUTPUT);

    pinMode(OUT_PIN, INPUT_PULLUP);
    unsigned long u1 = micros();
    unsigned long t;
    int digVal;

    do
    {
      digVal = digitalRead(OUT_PIN);
      unsigned long u2 = micros();
      t = u2 > u1 ? u2 - u1 : u1 - u2;
    }

    while ((digVal < 1) && (t < 400000L));

    pinMode(OUT_PIN, INPUT);
    val = analogRead(OUT_PIN);
    digitalWrite(IN_PIN, HIGH);
    int dischargeTime = (int)(t / 10L) * 5;
    delay(dischargeTime);
    pinMode(OUT_PIN, OUTPUT);
    digitalWrite(OUT_PIN, LOW);
    digitalWrite(IN_PIN, LOW);

    float capacitance = +(float)t / R_PULLUP / log(2.94  - (float)val / (float)MAX_ADC_VALUE);

      display.setCursor(36, 16);
      display.print(capacitance / 0.041, 0);
      display.setCursor(65, 16);
      display.print(F("M*C"));
      display.setCursor(28, 8);
      display.print(F("|"));
      display.setCursor(35, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN, INPUT);
  pinMode(OUT_PIN, INPUT);
  
  /////////////////////////////2 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ/////////////////////////////
  pinMode(IN_PIN2, INPUT);
  digitalWrite(OUT_PIN2, HIGH);
  int val2 = analogRead(IN_PIN2);
  digitalWrite(OUT_PIN2, LOW);

  if (val2 < 970)
  {
    pinMode(IN_PIN2, OUTPUT);

    float capacitance2 = (float)val2 * IN_CAP_TO_GND2 / (float)(MAX_ADC_VALUE - val2);
    delay (50);
    display.setCursor(36, 24);
    display.print(capacitance2 / 90, 0);
    display.setCursor(65, 24);
    display.print(F("M*C"));

    if (capacitance2 < 100) {
      display.setCursor(42, 8);
      display.print(F("-"));
      display.setCursor(63, 8);
      display.print(F("-"));
    }

    else if (capacitance2 > 100) {
      display.setCursor(42, 8);
      display.print(F("|"));
      display.setCursor(63, 8);
      display.print(F("|"));
    }
  }
  else
  {
    pinMode(IN_PIN2, OUTPUT);

    pinMode(OUT_PIN2, INPUT_PULLUP);
    unsigned long u3 = micros();
    unsigned long t2;
    int digVal2;

    do
    {
      digVal2 = digitalRead(OUT_PIN2);
      unsigned long u4 = micros();
      t2 = u4 > u3 ? u4 - u3 : u3 - u4;
    }

    while ((digVal2 < 1) && (t2 < 400000L));

    pinMode(OUT_PIN2, INPUT);
    val2 = analogRead(OUT_PIN2);
    digitalWrite(IN_PIN2, HIGH);

    int dischargeTime2 = (int)(t2 / 10L) * 5;
    delay(dischargeTime2);

    pinMode(OUT_PIN2, OUTPUT);
    digitalWrite(OUT_PIN2, LOW);
    digitalWrite(IN_PIN2, LOW);

    float capacitance2 = +(float)t2 / R_PULLUP / log(2.22 - (float)val2 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 24);
      display.print(capacitance2 / 0.041, 0);
      display.setCursor(65, 24);
      display.print(F("M*C"));
      display.setCursor(42, 8);
      display.print(F("|"));
      display.setCursor(63, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN2, INPUT);
  pinMode(OUT_PIN2, INPUT);
  
  //////////////////////////////3 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ//////////////////////////////
  pinMode(IN_PIN3, INPUT);
  digitalWrite(OUT_PIN3, HIGH);
  int val3 = analogRead(IN_PIN3);
  digitalWrite(OUT_PIN3, LOW);

  if (val3 < 970)
  {
    pinMode(IN_PIN3, OUTPUT);

    float capacitance3 = (float)val3 * IN_CAP_TO_GND3 / (float)(MAX_ADC_VALUE - val3);
    delay (50);
    display.setCursor(36, 32);
    display.print(capacitance3 / 90, 0);
    display.setCursor(65, 32);
    display.print(F("M*C"));

    if (capacitance3 < 100) {
      display.setCursor(49, 8);
      display.print(F("-"));
      display.setCursor(56, 8);
      display.print(F("-"));
    }

    else if (capacitance3 > 100) {
      display.setCursor(49, 8);
      display.print(F("|"));
      display.setCursor(56, 8);
      display.print(F("|"));
    }
  }
  else
  {
    pinMode(IN_PIN3, OUTPUT);

    pinMode(OUT_PIN3, INPUT_PULLUP);
    unsigned long u5 = micros();
    unsigned long t3;
    int digVal3;

    do
    {
      digVal3 = digitalRead(OUT_PIN3);
      unsigned long u6 = micros();
      t3 = u6 > u5 ? u6 - u5 : u5 - u6;
    }

    while ((digVal3 < 1) && (t3 < 400000L));

    pinMode(OUT_PIN3, INPUT);
    val3 = analogRead(OUT_PIN3);
    digitalWrite(IN_PIN3, HIGH);

    int dischargeTime3 = (int)(t3 / 10L) * 5;
    delay(dischargeTime3);
    pinMode(OUT_PIN3, OUTPUT);
    digitalWrite(OUT_PIN3, LOW);
    digitalWrite(IN_PIN3, LOW);

    float capacitance3 = +(float)t3 / R_PULLUP / log(2.93 - (float)val3 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 32);
      display.print(capacitance3 / 0.041, 0);
      display.setCursor(65, 32);
      display.print(F("M*C"));
      display.setCursor(49, 8);
      display.print(F("|"));
      display.setCursor(56, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN3, INPUT);
  pinMode(OUT_PIN3, INPUT);
  
  ////////////////////////////////4 КАНАЛ ВЫЧИСЛЕНИЯ И ЦИФРЫ///////////////////////////
  pinMode(IN_PIN4, INPUT);
  digitalWrite(OUT_PIN4, HIGH);
  int val4 = analogRead(IN_PIN4);
  digitalWrite(OUT_PIN4, LOW);

  if (val4 < 970)
  {
    pinMode(IN_PIN4, OUTPUT);

    float capacitance4 = (float)val4 * IN_CAP_TO_GND4 / (float)(MAX_ADC_VALUE - val4);
    delay (50);
    display.setCursor(36, 40);
    display.print(capacitance4 / 90, 0);
    display.setCursor(65, 40);
    display.print(F("M*C"));

    if (capacitance4 < 100) {
      display.setCursor(70, 8);
      display.print(F("-"));
      display.setCursor(77, 8);
      display.print(F("-"));
    }

    else if (capacitance4 > 100) {
      display.setCursor(70, 8);
      display.print(F("|"));
      display.setCursor(77, 8);
      display.print(F("|"));
    }

  }
  else
  {
    pinMode(IN_PIN4, OUTPUT);

    pinMode(OUT_PIN4, INPUT_PULLUP);
    unsigned long u7 = micros();
    unsigned long t4;
    int digVal4;

    do
    {
      digVal4 = digitalRead(OUT_PIN4);
      unsigned long u8 = micros();
      t4 = u8 > u7 ? u8 - u7 : u7 - u8;
    }

    while ((digVal4 < 1) && (t4 < 400000L));

    pinMode(OUT_PIN4, INPUT);
    val4 = analogRead(OUT_PIN4);
    digitalWrite(IN_PIN4, HIGH);

    int dischargeTime4 = (int)(t4 / 10L) * 5;
    delay(dischargeTime4);
    pinMode(OUT_PIN4, OUTPUT);
    digitalWrite(OUT_PIN4, LOW);
    digitalWrite(IN_PIN4, LOW);

    float capacitance4 = +(float)t4 / R_PULLUP / log(2.23 - (float)val4 / (float)MAX_ADC_VALUE);

      display.setCursor(36, 40);
      display.print(capacitance4 / 0.041, 0);
      display.setCursor(65, 40);
      display.print(F("M*C"));
      display.setCursor(70, 8);
      display.print(F("|"));
      display.setCursor(77, 8);
      display.print(F("|"));
  }
  pinMode(IN_PIN4, INPUT);
  pinMode(OUT_PIN4, INPUT);
  
  ////////////////////////////////КОНЕЦ(1СТР. ИЗМЕРЕНИЕ ЕМКОСТИ)////////////////////////////////

  display.display();
  display.clearDisplay();
}
/////////////////////////////////КОНЕЦ(VOID LOOP)////////////////////////////////////

Скетч использует 14762 байт (93%) памяти устройства. Всего доступно 15872 байт.
Глобальные переменные используют 727 байт (70%) динамической памяти, оставляя 297 байт для локальных переменных. Максимум: 1024 байт.

Да я же даже не разбирался в коде, просто «пильнул чтобы влезло», садмана послушай (если интересно).

Вместо приемника использовал смартфон с прогой Анализатор спектра и приблудой (на полевом транзисторе) втыкаемой в разьем для гарнитуры.

Что именно засунуть/улучшить ? :)

там все можно улучшить, отпишись Садману, пока у него интерес не пропал

Вот кстати я снял видео обзор моего приборчика со всеми функциями - https://www.youtube.com/watch?v=P69QBf6Dyfo

Возможно делать измерения по одному входу как здесь https://vrtp.ru/index.php?s=0b11e4a95abe4123cc7f0b60b53c49da&showtopic=26444&st=0

Нет, один вход для измерения длины кабеля по емкости, также поиск обрыва.

Второй вход - для измерения длины кабеля по сопротивлению + звуковая сигнализация некачественного кабеля , окисленных контактов RJ45 и плохого обжима коннекторов.

Третий выход для поиска кабеля в пучке кабелей тон генератором и анализатором спектра на смартфоне.

Возможно выложить вашу полную схему и скетч? Есть у вас защита по входах? Есть практика применения подобных устройств и бывали случаи что на линиях было напряжение больше 5В.

Passive POE может поджарить атмегу - это верно.

Приборчик пока ещё в процессе разработки и экспериментов, что-то добавляется, что-то убирается. Защиты по входу еще не ставил. Пока не было случаев, чтобы на линии связи было более 5 вольт. В основном пассивные, управляемые свитчи, роутеры, все без POE

Схемка пока такая:

Можно увидеть схему детектора на полевом транзисторе резисторе и конденсаторе и кусок кода, который формирует для них сигнал ?

Кусок кода - простой tone на определенных частотах.

void str_5()
{
  display.setCursor(2, 1);
  display.print("<- GENERATOR");
  display.setCursor(15, 12);
  display.print("13 KHZ(1-2)");

  tone(6, 13000);  // ТОН на пине 6 (13 кГц)
}

void str_6()
{
  display.setCursor(2, 1);
  display.print("<- GENERATOR");
  display.setCursor(15, 12);
  display.print("18 KHZ(3-6)");

  noTone(6);
  tone(9, 18000);  // ТОН на пине 9 (18 кГц)
}

вот такой прибор можно использовать для некоторых функций -

всем привет! накидал в редакторе плату и заказал ее изготовление в китае, вдохновившись успехом автора, но допустил ошибку в проектировании и не задействовал функционал кнопки. теперь у меня получилось хоть и функциональное (на что я надеюсь) устройство, но без кнопки. сейчас стал разбираться в рисунке схемы подключения автора оригинального поста и вижу, что пин D2 подтягивается резистором к земле, и дальше уходит пунктирная линия, но, я не понимаю куда. хотел бы попросить помощи: как можно подключить кнопку, чтобы не сильно вмешиваться в печатную плату, пусть даже навесным монтажом? еще очень было бы интересно посмотреть, как выглядит устройство у тех, кто его уже собрал

На +5 через кнопку. Контакты замкнуты на пине HIGH, разомкнуты - LOW...

Пин D2 замыкается через кнопку на +5 вольт, тем самым осуществляется переключение подпунктов меню. 

Но вы рано плату заказали, ещё ведутся экспериментальные работы по модернизации прошивки и схемы измерителя. На данный момент ведутся работы по устранению межканального влияния витой пары (межпарная емкость) на корректность показаний.

к такой плате просится цветной дисплейчик на st7735

ничего страшного, меня интересует только возможность поиска провода (режим генератора) и прозвонка розеток на предмет перепутанных пар

Я пробовал на st7735, но потребляемый ток намного больше и на солнце плохо видно, зато красиво )

Ну скажем так, поиск кабеля получится только в том случае, если с другой стороны кабель никуда не подключен, иначе через свитч этот сигнал будет наводится на все кабеля, которые вставлены в свитч или роутер.

Перепутанность пар этот приборчик не определит. Задумка была сделать приборчик только для измерения длины кабеля каждой пары по емкости и по сопротивлению. По емкости - для поиска обрыва кабеля. По сопротивлению - для определения качества обжима коннекторов и определения длины кабеля до свитча. 

На предмет перепутанности пар можно использовать самый дешевый тестер на светодиодах.

Не совсем понял по схеме как подключать провод для измерения его емкости. Прошу пояснить.