Два ds18b20 управление с пульта (нужна помощь)

S

S_Sergey_G

✩✩✩✩✩✩✩
23 Фев 2021
165
3
Здравствуйте. Нужна помощь. Есть рабочий скетч, просто термометра MAX7219 и ds18b20. Нравится отображением, изменения шрифта прямо в скетче, быстрая подгонка под 4,3,2 матрицы. Хочется подключить два датчика ds18b20 и переключаться между ними пультом. Пробовал сам ни чего не получается.
C++: 
#include "Arduino.h"      //CS 10; CLK 11; DIN 12.
#include "LedControl.h"
#include "OneWire.h"

OneWire ds(8);

LedControl lc = LedControl(12, 11, 10, 4);

byte Num0[8] =
{ B0000000,
B01110000,
B10001000,
B10001000,
B10001000,
B10001000,
B10001000,
B01110000 };

byte Num1[8] =
{ B00000000,
B01000000,
B11000000,
B01000000,
B01000000,
B01000000,
B01000000,
B11100000 };

byte Num2[8] =
{ B00000000,
B01110000,
B10001000,
B00001000,
B00010000,
B00100000,
B01000000,
B11111000 };

byte Num3[8] =
{ B00000000,
B11111000,
B00010000,
B00100000,
B00010000,
B00001000,
B10001000,
B01110000 };

byte Num4[8] =
{ B00000000,
B00010000,
B00110000,
B01010000,
B10010000,
B11111000,
B00010000,
B00010000 };

byte Num5[8] =
{ B00000000,
B11111000,
B10000000,
B11110000,
B00001000,
B00001000,
B10001000,
B01110000 };

byte Num6[8] =
{ B00000000,
B00110000,
B01000000,
B10000000,
B11110000,
B10001000,
B10001000,
B01110000 };

byte Num7[8] =
{ B00000000,
B11111000,
B00001000,
B00001000,
B00010000,
B00100000,
B01000000,
B01000000 };

byte Num8[8] =
{ B00000000,
B01110000,
B10001000,
B10001000,
B01110000,
B10001000,
B10001000,
B01110000 };

byte Num9[8] =
{ B00000000,
B01110000,
B10001000,
B10001000,
B01111000,
B00001000,
B00010000,
B01100000 };

byte Minus[8] =
{ B00000000,
B00000000,
B00000000,
B00000000,
B11100000,
B00000000,
B00000000,
B00000000 };

byte Plus[8] =
{ B00000000,
B00000000,
B00000000,
B01000000,
B11100000,
B01000000,
B00000000,
B00000000 };

byte Dot[8] =
{ B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B10000000 };

byte DegreeC[8] =
{ B01100000,
B10010000,
B10010110,
B01101001,
B00001000,
B00001000,
B00001001,
B00000110 };

byte Empty[8] =
{ B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};

byte ReadyDigit2[8]; // Include fragment of 1 digit and full 2 digit
byte BufferedDigit[8]; // Push to buffer 1 digit
uint8_t CurrentDigit2, intensity;

int HighByte, LowByte, TReading, SignBit, Tc_100, Whole, Fract;

unsigned long currentMillis, nowMillis;

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

    intensity = 5;

    lc.shutdown(0, false);
    lc.setIntensity(0, intensity);
    lc.clearDisplay(0);

    lc.shutdown(1, false);
    lc.setIntensity(1, intensity);
    lc.clearDisplay(1);

    lc.shutdown(2, false);
    lc.setIntensity(2, intensity);
    lc.clearDisplay(2);

    lc.shutdown(3, false);
    lc.setIntensity(3, intensity);
    lc.clearDisplay(3);

    Degree();
}

void loop()
{
    String Sign;
    uint8_t ReadyFract;
    byte i;
    byte present = 0;
    byte data[12];
    byte addr[8];

  nowMillis = millis();

    if (nowMillis - currentMillis >= 100)
    {
        ds.reset_search();
        if (!ds.search(addr))
        {
            ds.reset_search();
            return;
        }
        ds.reset();
        ds.select(addr);
        ds.write(0x44, 1);

        currentMillis = millis();
    }

    present = ds.reset();
    ds.select(addr);
    ds.write(0xBE);

    for (i = 0; i < 9; i++)
    {
        data[i] = ds.read();
    }

    LowByte = data[0];
    HighByte = data[1];
    TReading = (HighByte << 8) + LowByte;
    SignBit = TReading & 0x8000;

    if (SignBit)
    {
        TReading = (TReading ^ 0xffff) + 1;
    }
    Tc_100 = (6 * TReading) + TReading / 4;
    Whole = Tc_100 / 100;
    Fract = Tc_100 % 100;

    if (SignBit)
    {
        Sign = "Minus";
    }
    else if (!SignBit && TReading != 0)
    {
        Sign = "Plus";
    }
    else if (TReading == 0)
    {
        Sign = "None";
    }

    if (Fract < 10)
    {
        ReadyFract = 0;
    }
    else if (Fract % 10 < 5)
    {
        ReadyFract = Fract / 10;
    }
    else if (Fract % 10 >= 5)
    {
        ReadyFract = (Fract / 10) + 1;
    }

    Digit1(Whole / 10, Sign);
    Digit2(Whole % 10);
    Digit3(ReadyFract, true);
}

void Digit1(uint8_t Dig, String Sign)
{
    switch (Dig)
    {
    case 0:
    {
        for (uint8_t i = 0; i < 8; i++)
        {
            BufferedDigit[i] = Empty[i];

          if (CurrentDigit2 == 0 && CurrentDigit2 != 0)
          {
            lc.setRow(2, i, BufferedDigit[i] << 4);
          }

          if (Sign == "Plus")
          {
            lc.setRow(3, i, Plus[i] >> 5);
          }
          else if (Sign == "Minus")
          {
            lc.setRow(3, i, Minus[i] >> 5);
          }
          else if (Sign == "None")
          {
            lc.setRow(3, i, Num0[i] >> 4);
          }
        }
        break;
    }
    case 1:
    {
        for (uint8_t i = 0; i < 8; i++)
        {
            BufferedDigit[i] = Num1[i] >> 2;

            if (CurrentDigit2 == 1 && CurrentDigit2 != 1)
            {
                lc.setRow(2, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(3, i, Num1[i] >> 6 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(3, i, Num1[i] >> 6 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(3, i, Num1[i] >> 6);
            }
        }
        break;
    }
    case 2:
    {
        for (uint8_t i = 0; i < 8; i++)
        {
            BufferedDigit[i] = Num2[i];

            if (CurrentDigit2 == 2 && CurrentDigit2 != 2)
            {
                lc.setRow(2, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(3, i, Num2[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(3, i, Num2[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(3, i, Num2[i] >> 4);
            }
        }
        break;
    }
    case 3:
    {
        for (uint8_t i = 0; i < 8; i++)
        {
            BufferedDigit[i] = Num3[i];

            if (CurrentDigit2 == 3 && CurrentDigit2 != 3)
            {
                lc.setRow(2, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(3, i, Num3[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(3, i, Num3[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(3, i, Num3[i] >> 4);
            }
        }
        break;
    }
    case 4:
    {
        for (uint8_t i = 0; i < 8; i++)
        {
            BufferedDigit[i] = Num4[i];

            if (CurrentDigit2 == 4 && CurrentDigit2 != 4)
            {
                lc.setRow(2, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(3, i, Num4[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(3, i, Num4[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(3, i, Num4[i] >> 4);
            }
        }
        break;
    }
    case 5:
    {
        for (uint8_t i = 0; i < 8; i++)
        {
            BufferedDigit[i] = Num5[i];

            if (CurrentDigit2 == 5 && CurrentDigit2 != 5)
            {
                lc.setRow(2, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(3, i, Num5[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(3, i, Num5[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(3, i, Num5[i] >> 4);
            }
        }
        break;
    }
    case 6:
    {
        for (uint8_t i = 0; i < 8; i++)
        {
            BufferedDigit[i] = Num6[i];

            if (CurrentDigit2 == 6 && CurrentDigit2 != 6)
            {
                lc.setRow(2, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(3, i, Num6[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(3, i, Num6[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(3, i, Num6[i] >> 4);
            }
        }
        break;
    }
    case 7:
    {
        for (uint8_t i = 0; i < 8; i++)
        {
            BufferedDigit[i] = Num7[i];

            if (CurrentDigit2 == 7 && CurrentDigit2 != 7)
            {
                lc.setRow(2, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(3, i, Num7[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(3, i, Num7[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(3, i, Num7[i] >> 4);
            }
        }
        break;
    }
    case 8:
    {
        for (uint8_t i = 0; i < 8; i++)
        {
            BufferedDigit[i] = Num8[i];

            if (CurrentDigit2 == 8 && CurrentDigit2 != 8)
            {
                lc.setRow(2, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(3, i, Num8[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(3, i, Num8[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(3, i, Num8[i] >> 4);
            }
        }
        break;
    }
    case 9:
    {
        for (uint8_t i = 0; i < 8; i++)
        {
            BufferedDigit[i] = Num9[i];

            if (CurrentDigit2 == 9 && CurrentDigit2 != 9)
            {
                lc.setRow(2, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(3, i, Num9[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(3, i, Num9[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(3, i, Num9[i] >> 4);
            }
        }
        break;
        default:
        Dig = 0;
    }
    }
}

void Digit2(uint8_t Dig)
{
    switch (Dig)
    {
    case 0:
    {
        CurrentDigit2 = 0;
        for (uint8_t i = 0; i < 8; i++)
        {
            ReadyDigit2[i] = (BufferedDigit[i] << 4) | (Num0[i] >> 2);
            lc.setRow(2, i, ReadyDigit2[i]);
        }
        break;
    }
    case 1:
    {
        CurrentDigit2 = 1;
        for (uint8_t i = 0; i < 8; i++)
        {
            ReadyDigit2[i] = (BufferedDigit[i] << 4) | (Num1[i] >> 3);
            lc.setRow(2, i, ReadyDigit2[i]);
        }
        break;
    }
    case 2:
    {
        CurrentDigit2 = 2;
        for (uint8_t i = 0; i < 8; i++)
        {
            ReadyDigit2[i] = (BufferedDigit[i] << 4) | (Num2[i] >> 2);
            lc.setRow(2, i, ReadyDigit2[i]);
        }
        break;
    }
    case 3:
    {
        CurrentDigit2 = 3;
        for (uint8_t i = 0; i < 8; i++)
        {
            ReadyDigit2[i] = (BufferedDigit[i] << 4) | (Num3[i] >> 2);
            lc.setRow(2, i, ReadyDigit2[i]);
        }
        break;
    }
    case 4:
    {
        CurrentDigit2 = 4;
        for (uint8_t i = 0; i < 8; i++)
        {
            ReadyDigit2[i] = (BufferedDigit[i] << 4) | (Num4[i] >> 2);
            lc.setRow(2, i, ReadyDigit2[i]);
        }
        break;
    }
    case 5:
    {
        CurrentDigit2 = 5;
        for (uint8_t i = 0; i < 8; i++)
        {
            ReadyDigit2[i] = (BufferedDigit[i] << 4) | (Num5[i] >> 2);
            lc.setRow(2, i, ReadyDigit2[i]);
        }
        break;
    }
    case 6:
    {
        CurrentDigit2 = 6;
        for (uint8_t i = 0; i < 8; i++)
        {
            ReadyDigit2[i] = (BufferedDigit[i] << 4) | (Num6[i] >> 2);
            lc.setRow(2, i, ReadyDigit2[i]);
        }
        break;
    }
    case 7:
    {
        CurrentDigit2 = 7;
        for (uint8_t i = 0; i < 8; i++)
        {
            ReadyDigit2[i] = (BufferedDigit[i] << 4) | (Num7[i] >> 2);
            lc.setRow(2, i, ReadyDigit2[i]);
        }
        break;
    }
    case 8:
    {
        CurrentDigit2 = 8;
        for (uint8_t i = 0; i < 8; i++)
        {
            ReadyDigit2[i] = (BufferedDigit[i] << 4) | (Num8[i] >> 2);
            lc.setRow(2, i, ReadyDigit2[i]);
        }
        break;
    }
    case 9:
    {
        CurrentDigit2 = 9;
        for (uint8_t i = 0; i < 8; i++)
        {
            ReadyDigit2[i] = (BufferedDigit[i] << 4) | (Num9[i] >> 2);
            lc.setRow(2, i, ReadyDigit2[i]);
        }
        break;
        default:
        Dig = 0;
    }
    }
}

void Digit3(uint8_t Dig, bool DotBool)
{
    switch (Dig)
    {
    case 0:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(1, i, Num0[i] >> 2);
            }
        }
        else
            for (uint8_t i = 0; i < 8; i++)
            {
                byte Num0Dot[8];
                Num0Dot[i] = (Num0[i] >> 2) | (Dot[i]);
                lc.setRow(1, i, Num0Dot[i]);
            }
        break;
    }
    case 1:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(1, i, Num1[i] >> 3);
            }
        }
        else
            for (uint8_t i = 0; i < 8; i++)
            {
                byte Num1Dot[8];
                Num1Dot[i] = (Num1[i] >> 3) | (Dot[i]);
                lc.setRow(1, i, Num1Dot[i]);
            }
        break;
    }
    case 2:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(1, i, Num2[i] >> 2);
            }
        }
        else
            for (uint8_t i = 0; i < 8; i++)
            {
                byte Num2Dot[8];
                Num2Dot[i] = (Num2[i] >> 2) | (Dot[i]);
                lc.setRow(1, i, Num2Dot[i]);
            }
        break;
    }
    case 3:
    {
        if (!DotBool)
        {

            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(1, i, Num3[i] >> 2);
            }
        }
        else
            for (uint8_t i = 0; i < 8; i++)
            {
                byte Num3Dot[8];
                Num3Dot[i] = (Num3[i] >> 2) | (Dot[i]);
                lc.setRow(1, i, Num3Dot[i]);
            }
        break;
    }
    case 4:
    {
        if (!DotBool)
        {

            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(1, i, Num4[i] >> 2);
            }
        }
        else
            for (uint8_t i = 0; i < 8; i++)
            {
                byte Num4Dot[8];
                Num4Dot[i] = (Num4[i] >> 2) | (Dot[i]);
                lc.setRow(1, i, Num4Dot[i]);
            }
        break;
    }
    case 5:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(1, i, Num5[i] >> 2);
            }
        }
        else
            for (uint8_t i = 0; i < 8; i++)
            {
                byte Num5Dot[8];
                Num5Dot[i] = (Num5[i] >> 2) | (Dot[i]);
                lc.setRow(1, i, Num5Dot[i]);
            }
        break;
    }
    case 6:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(1, i, Num6[i] >> 2);
            }
        }
        else
            for (uint8_t i = 0; i < 8; i++)
            {
                byte Num6Dot[8];
                Num6Dot[i] = (Num6[i] >> 2) | (Dot[i]);
                lc.setRow(1, i, Num6Dot[i]);
            }
        break;
    }
    case 7:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(1, i, Num7[i] >> 2);
            }
        }
        else
            for (uint8_t i = 0; i < 8; i++)
            {
                byte Num7Dot[8];
                Num7Dot[i] = (Num7[i] >> 2) | (Dot[i]);
                lc.setRow(1, i, Num7Dot[i]);
            }
        break;
    }
    case 8:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(1, i, Num8[i] >> 2);
            }
        }
        else
            for (uint8_t i = 0; i < 8; i++)
            {
                byte Num8Dot[8];
                Num8Dot[i] = (Num8[i] >> 2) | (Dot[i]);
                lc.setRow(1, i, Num8Dot[i]);
            }
        break;
    }
    case 9:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(1, i, Num9[i] >> 2);
            }
        }
        else
            for (uint8_t i = 0; i < 8; i++)
            {
                byte Num9Dot[8];
                Num9Dot[i] = (Num9[i] >> 2) | (Dot[i]);
                lc.setRow(1, i, Num9Dot[i]);
            }
        break;
        default:
        Dig = 0;
    }
    }
}

void Degree(void)
{
    for (uint8_t i = 0; i < 8; i++)
    {
        lc.setRow(0, i, DegreeC[i]);
    }
}
 
Александр Симонов

Александр Симонов

★★★★✩✩✩
2 Авг 2018
727
208
S_Sergey_G написал(а):
Хочется подключить два датчика ds18b20 и переключаться между ними пультом. Пробовал сам ни чего не получается.
Нажмите для раскрытия...
Многовато лишнего в этом скетче. Начни с нуля и делай по шагам.

Сначала ардуинка с двумя датчиками ds18b20 и новый скетч. Считывай с них температуру и выводи в монитор порта.

Потом отдельный пробный скетч и схема для работы с пультом: считать код кнопки и вывести его в монитор порта.

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

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

Ну или обращаешься в соседний раздел "Ищу разработчика" и за денежку тебе всё это сделают за день.
 
S

S_Sergey_G

✩✩✩✩✩✩✩
23 Фев 2021
165
3
Температуру выводил с обоих датчиков. С пульта считывал код. Попробую соединить. Спасибо.
 
Александр Симонов

Александр Симонов

★★★★✩✩✩
2 Авг 2018
727
208
S_Sergey_G написал(а):
Температуру выводил с обоих датчиков. С пульта считывал код. Попробую соединить. Спасибо.
Нажмите для раскрытия...
Перед этим советую "прибраться" в исходном счетче. Сейчас там намешана в кучу работа с 1-Wire протоколом, высчитывание температуры, какие-то дополнительные переменные для вывода и потом сам вывод. А должно быть, условно, так:
C++: 
float tempC = readTemp(sensorIndex);
displayTemp(tempC);
Тогда и добавить новую функциональность будет просто.
 
S

S_Sergey_G

✩✩✩✩✩✩✩
23 Фев 2021
165
3
Мне помог, уважаемый "Дим" с одного форума, сделать код с переключением между датчиками пультом. В этом плане все работает. Но с отображением на матрицах не все в порядке. При изменении температуры строка выравнивается по левому краю. Подскажите как сделать выравнивание по правому краю?
C++: 
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Max72xxPanel.h>
#include <DallasTemperature.h>
#include "IRremote.h"
IRrecv irrecv(A0);                           // указываем вывод, к которому подключен ИК приемник
decode_results results;
uint32_t Key1 = 0xFFA25D;                    // Определяем код кнопки ПДУ 1 датчик
uint32_t Key2 = 0xFFE21D;                    // Определяем код кнопки ПДУ 2 датчик

uint8_t updCnt = 0;
uint8_t dots = 0;
long dotTime = 0;
long clkTime = 0;

const uint8_t DS18B20_1 = 8;                    // Указываем, к какому выводу подключен 1 датчик
const uint8_t DS18B20_2 = 7;                    // Указываем, к какому выводу подключен 2 датчик
long previousMillis = 0;
uint8_t val=0;

uint8_t knopka = 0;                            // если не нажата на ПДУ 0 ((показ первый датчик)), иначе 1 (показ второй датчик)
uint8_t spacer = 2;
uint8_t width = 5 + spacer;                   // Регулируем расстояние между символами
uint8_t refresh=0;
const uint8_t  pinCS = 10;                    // Подключение пина CS
uint8_t numberOfHorizontalDisplays = 4;       // Количество светодиодных матриц по Горизонтали
uint8_t numberOfVerticalDisplays = 1;         // Количество светодиодных матриц по Вертикали
String temp;                                // температура

Max72xxPanel matrix = Max72xxPanel(pinCS, numberOfHorizontalDisplays, numberOfVerticalDisplays);
OneWire oneWire_1(DS18B20_1);
OneWire oneWire_2(DS18B20_2);              
DallasTemperature sensors_1(&oneWire_1);
DallasTemperature sensors_2(&oneWire_2);
byte brightness = 3;                         // Яркость матрицы от 0 до 15
// ===================================================================================================================================
void setup(void) {
  Serial.begin( 9600 );                       // Инициируем передачу данных в монитор последовательного порта
  irrecv.enableIRIn();                        // запускаем прием ИК приемника

  sensors_1.begin();
  sensors_2.begin();
  matrix.setIntensity(brightness);            // Яркость матрицы от 0 до 15
  matrix.setRotation(matrix.getRotation()+2); // 1 - 90  2 - 180   3 - 270 угол поворота
                                   // начальные координаты матриц 8*8
  matrix.setRotation(0, 1);        // 1 матрица
  matrix.setRotation(1, 1);        // 2 матрица
  matrix.setRotation(2, 1);        // 3 матрица
  matrix.setRotation(3, 1);        // 4 матрица
}
// =======================================================================
void loop(void)
{
  DisplayTime();
*  if(updCnt<=0)
  {                                                               // каждые 10 циклов получаем данные времени и погоды
    updCnt = 1;
    DisplayTime();
    clkTime = millis();
  }
  if(millis()-dotTime > 500)
  {
    dotTime = millis();
    dots = !dots;
  }*/ 
  if ( irrecv.decode( &results )){         // если данные с ПДУ пришли

//==================== для двух кнопок начало кода =============      
    if (results.value == Key1)                                     // если нажата кнопка 1
      {knopka = 1;}                                                // 1 датчик
    if (results.value == Key2)                                     // если нажата кнопка 2
      {knopka = 0;}                                                // 2 датчик
//==================== для двух кнопок конец кода =============    

    irrecv.resume();   // принимаем следующую команду
  }
}

void DisplayTime()
{
float tempOffset = 1.0;               //поправка уличного датчика
  sensors_1.requestTemperatures();             // Считываем показания температуры 1 датчика
  sensors_2.requestTemperatures();             // Считываем показания температуры 2 датчика
  if(knopka == 0)
  {
  temp = String(sensors_1.getTempCByIndex(0) - tempOffset, 1)+"";  // темп в стринг 1 датчика
  }
  else{
  temp = String(sensors_2.getTempCByIndex(0) - tempOffset, 1)+"";  // темп в стринг 2 датчика
  }

  matrix.fillScreen(LOW);
  int y = (matrix.height() - 8) / 2;         // Центрируем текст по Вертикали

  int xh = 0;
  int xm = 17;
  matrix.drawChar(xh, y, temp[0], HIGH, LOW, 1);
  matrix.drawChar(xh+6, y, temp[1], HIGH, LOW, 1);
  matrix.drawChar(xm-6, y, temp[2], HIGH, LOW, 1);
  matrix.drawChar(xm, y, temp[3], HIGH, LOW, 1);
  matrix.drawChar(xm+5, y, temp[4], HIGH, LOW, 1);

  matrix.write();                                     // Вывод на дисплей
}
 
P

poty

★★★★★★✩
19 Фев 2020
3,230
940
Так Вы же сами устанавливаете место, куда выводить, с помощью переменных y, xh, xm.
 
S

S_Sergey_G

✩✩✩✩✩✩✩
23 Фев 2021
165
3
poty написал(а):
Так Вы же сами устанавливаете место, куда выводить, с помощью переменных y, xh, xm.
Нажмите для раскрытия...
Да выставляю именно так, но при изменении выравнивается по левому краю. Вот так I- 13.5 I I-5.3 I I 23.6 I а надо I 23.6I
Что бы десятые оставались на месте а минус перемещался к десяткам ну или к единицам между -9.9 и 9.9
 
Изменено:
P

poty

★★★★★★✩
19 Фев 2020
3,230
940
Во-первых, пробел, который Вы добавляете (+" ") к строке - Вы его добавляете к концу строки.
Во вторых, не понял танцев с бубном по поводу xh, xm. Почему бы не выводить с последнего символа, расположив его справа?
 
P

poty

★★★★★★✩
19 Фев 2020
3,230
940
S_Sergey_G написал(а):
@poty, А можно пример?
Нажмите для раскрытия...
C++: 
// предполагаю, что xh и xm - это адреса точек в строке, куда выводится целая часть (xh) и дробная часть (xm)
// с библиотекой не знаком, поэтому могу ошибаться
    matrix.fillScreen(LOW);
    int y = (matrix.height() - 8) / 2;         // Центрируем текст по Вертикали

    matrix.drawChar(22, y, temp[3], HIGH, LOW, 1);
    matrix.drawChar(16, y, temp[2], HIGH, LOW, 1);
    matrix.drawChar(10, y, temp[1], HIGH, LOW, 1);
    matrix.drawChar( 4, y, temp[0], HIGH, LOW, 1);
 
S

S_Sergey_G

✩✩✩✩✩✩✩
23 Фев 2021
165
3
@poty, Всё равно по левой стороне выравнивает. Минус стоит на месте а десятки и единицы передвигаются в лево.
 
P

poty

★★★★★★✩
19 Фев 2020
3,230
940
@S_Sergey_G, Вы фото можете прислать? На каком месте стоит минус? Или я чего-то не понимаю. Покажите, как это выглядит и что в этом не так?
 
P

poty

★★★★★★✩
19 Фев 2020
3,230
940
Интересно, это отображение того кода, что я написал выше? Или Вы что-то изменили?
В любом случае я понял ошибку. Строка всегда начинается со значащего символа. Сейчас в дороге, приеду - напишу, что нужно изменить.
 
S

S_Sergey_G

✩✩✩✩✩✩✩
23 Фев 2021
165
3
@poty, Я добавил еще одну строку
C++: 
matrix.drawChar(22, y, temp[4], HIGH, LOW, 1);
не выводились десятые.
 
P

poty

★★★★★★✩
19 Фев 2020
3,230
940
Имеем длину дисплея в 32 точки. Исходя из первоначального скетча ширина цифр - 5 точек + одна точка - интервал между символами. Была произведена попытка исключить интервал до и после знака десятичной точки.
Форматирование с помощью функции String ограничивает количество знаков после запятой одним. Длина получающегося числа может быть от трёх символов (0.1, 3.2 и т.п.) до 5 символов (-11.9, приведённые на фото).
Первое, что нужно сделать - убрать ненужный пробел в строке:
C++: 
if(knopka) temp = String(sensors_2.getTempCByIndex(0) - tempOffset, 1);  // темп в стринг 2 датчика
else temp = String(sensors_1.getTempCByIndex(0) - tempOffset, 1);  // темп в стринг 1 датчика
Второе - нужно определить длину строки и вывести всё с последнего знакоместа:
C++: 
byte tempLength = temp.length();
byte curSymbol = 0;
if (tempLength == 5) {
    matrix.drawChar( 32-5-5-5-6-6, y, temp[0], HIGH, LOW, 1);
    curSymbol++;
    tempLength--;
}
if (tempLength == 4) {
    matrix.drawChar( 32-5-5-5-6, y, temp[curSymbol++], HIGH, LOW, 1);
    tempLength--;
}
matrix.drawChar( 32-5-5-5, y, temp[curSymbol++], HIGH, LOW, 1);
matrix.drawChar( 32-5-5,    y, temp[curSymbol++], HIGH, LOW, 1);
matrix.drawChar( 32-5,       y, temp[curSymbol], HIGH, LOW, 1);
 
Изменено:
Войдите или зарегистрируйтесь для ответа.
Сверху Снизу