Часы на трех матрицах 8x8 MAX7219

[Дим]

Если с "моим" кодом не получиться

Получится. Готово - пользуйся. Убран знак температуры "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, 3);

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 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 = 2;

    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);
}

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(1, i, BufferedDigit[i] << 4);
          }

          if (Sign == "Plus")
          {
            lc.setRow(2, i, Plus[i] >> 5);
          }
          else if (Sign == "Minus")
          {
            lc.setRow(2, i, Minus[i] >> 5);
          }
          else if (Sign == "None")
          {
            lc.setRow(2, 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(1, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(2, i, Num1[i] >> 6 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(2, i, Num1[i] >> 6 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(2, 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(1, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(2, i, Num2[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(2, i, Num2[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(2, 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(1, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(2, i, Num3[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(2, i, Num3[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(2, 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(1, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(2, i, Num4[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(2, i, Num4[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(2, 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(1, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(2, i, Num5[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(2, i, Num5[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(2, 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(1, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(2, i, Num6[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(2, i, Num6[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(2, 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(1, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(2, i, Num7[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(2, i, Num7[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(2, 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(1, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(2, i, Num8[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(2, i, Num8[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(2, 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(1, i, BufferedDigit[i] << 4);
            }

            if (Sign == "Plus")
            {
                lc.setRow(2, i, Num9[i] >> 4 | Plus[i]);
            }
            else if (Sign == "Minus")
            {
                lc.setRow(2, i, Num9[i] >> 4 | Minus[i]);
            }
            else if (Sign == "None")
            {
                lc.setRow(2, 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(1, 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(1, 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(1, 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(1, 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(1, 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(1, 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(1, 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(1, 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(1, 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(1, 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(0, 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(0, i, Num0Dot[i]);
            }
        break;
    }
    case 1:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(0, 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(0, i, Num1Dot[i]);
            }
        break;
    }
    case 2:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(0, 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(0, i, Num2Dot[i]);
            }
        break;
    }
    case 3:
    {
        if (!DotBool)
        {

            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(0, 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(0, i, Num3Dot[i]);
            }
        break;
    }
    case 4:
    {
        if (!DotBool)
        {

            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(0, 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(0, i, Num4Dot[i]);
            }
        break;
    }
    case 5:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(0, 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(0, i, Num5Dot[i]);
            }
        break;
    }
    case 6:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(0, 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(0, i, Num6Dot[i]);
            }
        break;
    }
    case 7:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(0, 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(0, i, Num7Dot[i]);
            }
        break;
    }
    case 8:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(0, 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(0, i, Num8Dot[i]);
            }
        break;
    }
    case 9:
    {
        if (!DotBool)
        {
            for (uint8_t i = 0; i < 8; i++)
            {
                lc.setRow(0, 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(0, i, Num9Dot[i]);
            }
        break;
        default:
        Dig = 0;
    }
    }
} 

phpBB [media]

[S_Sergey_G]

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

[Дим]

этот код, что он не адаптивный

Где такое говорят?

[S_Sergey_G]

Edward Leary. Этот код я у него взял. Он помог убрать незначащий ноль после плюса. Было сначала +05,3, стало +5,3.

[S_Sergey_G]

А как сделать задержку в измерении или отображении температуры? А то десятки так и скачут туда сюда.

[Дим]

А как сделать задержку в измерении

Код: Выделить всё

if (nowMillis - currentMillis >= 100) 

попробуй сотню увеличить, можно 1000 поставить

Edward Leary

я прям так и знаю кто это

[S_Sergey_G]

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

Код: Выделить всё

//    Подключение
 
//  CD       MOSI D11, MISO D12, CLK D13, CS D4, VCC +5V
//  18B20    OUT A1, +5V VCC
//  DS3231   SDA A4, SCL A5, VCC +5V
 
#include <SPI.h>
#include <SD.h>
#include <OneWire.h>
#include <Wire.h>
#include <DallasTemperature.h>
#include <DS3231.h>
OneWire oneWire(A1);
DallasTemperature t(&oneWire);
DS3231 clock;
RTCDateTime DateTime;
 
File myFile; 
float temp;
long nomer;
int data_old;
 
void setup() {
  Serial.begin(9600);
  Serial.print("Initializing SD card...");
  if (!SD.begin(4)) {Serial.println(" Error!!!"); return;}
  else{Serial.println(" OK");}// проверка подключения
 
  t.begin(); 
  t.setResolution(12);// 12 bit 18b20
  clock.begin();
  // clock.setDateTime(__DATE__, __TIME__);// установка времени DS3231, раскомментировать и залить скетч, далее закомментировать и залить скетч повторно   
}
 
void loop() {
  DateTime = clock.getDateTime();
  Serial.print(clock.dateFormat("d-m-Y H:i:s", DateTime));
  Serial.print(" ");
  t.requestTemperatures();
  Serial.println(temp = t.getTempCByIndex(0));//считываем температуру
  delay(5000);// записывать данные на CD каждые 5 сек
  nomer++;
 
   myFile = SD.open("temp.txt", FILE_WRITE);// открываем файл для записи, если файла нет, то создает его
   myFile.print(nomer);// запись
   myFile.print(" ");// запись
if(data_old!=DateTime.day){
   myFile.print(DateTime.day/10);myFile.print(DateTime.day%10);myFile.print("-");
   myFile.print(DateTime.month/10);myFile.print(DateTime.month%10);myFile.print("-");
   myFile.print(DateTime.year);myFile.print(" ");}
data_old = DateTime.day;
   myFile.print(DateTime.hour/10);myFile.print(DateTime.hour%10);myFile.print("-");
   myFile.print(DateTime.minute/10);myFile.print(DateTime.minute%10);myFile.print("-");
   myFile.print(DateTime.second/10);myFile.print(DateTime.second%10);
   
   myFile.print(" ");// запись
   myFile.println(temp);// запись
   myFile.close();// закрываем файл
} 

[Дим]

Просто добавляй.

[S_Sergey_G]

Спасибо большое за помощь!

[Дим]

Всё получилось, работает?