INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Temperatur mit MAX7219
23.02.2020, 22:52 (Dieser Beitrag wurde zuletzt bearbeitet: 23.02.2020 23:51 von Angelina80.)
Beitrag #1
Temperatur mit MAX7219
Hallo Freunde

Ich habe ein recht einfaches Thermometer aus dem Netz nachgebaut. Eigentlich funktioniert tadellos, aber hat ja trotzdem ein kleiner Schönheitsfehler: Bei einstelliger Anzeige zeigt er vor der Temperatur eine Null. Das würde ich gerne unterdrücken, weiss aber leider nicht was ich in dem Code ändern soll! Wäre sehr schön, wenn jemand mir helfen könnte!

Die Schaltung besteht aus : MAX7219 DOT, Arduino Uno, DS18, DS18b20
   

Mit freundlichen Grüßen Smile

Code:
#include "Arduino.h"
#include "LedControl.h"
#include "OneWire.h"

#define CS 10       // MAX7219  CS
#define CLK 11      // MAX7219  CLK
#define DIN 12      // MAX7219  DIN

#define Sensor 8    // DS18B20 Sensor

#define Button1 2   // Helligkeits Taste
#define Button2 3   // Helligkeits Taste

OneWire ds(Sensor);

LedControl lc = LedControl(DIN, CLK, CS, 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] =
{ B00000000,
  B11100000,
  B10100110,
  B11101001,
  B00001000,
  B00001000,
  B00001001,
  B00000110
};

byte ArrowUp[8] =
{ B00000000,
  B00100000,
  B01110000,
  B11111000,
  B01110000,
  B01110000,
  B01110000,
  B01110000
};

byte ArrowDown[8] =
{ B00000000,
  B01110000,
  B01110000,
  B01110000,
  B01110000,
  B11111000,
  B01110000,
  B00100000
};

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

uint8_t CurrentDigit2, intensity, ReadyFract;

int HighByte, LowByte, TReading, SignBit, Tc_100, Whole, Fract;
int Button1state = 0;
int Button2state = 0;

unsigned long SensorCurrentMillis, ButtonRequesttMillis, SetModeCurrentMillis,
         ButtonPressedMillis, nowMillis;

void setup()
{
  pinMode(Button1, INPUT);
  pinMode(Button2, INPUT);

  intensity = 0;

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

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

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

  lc.shutdown(3, false);
  lc.clearDisplay(3);
}

void loop()
{
  String Sign, Mode;
  byte i;
  byte present = 0;
  byte data[12];
  byte addr[8];
  bool SetBrightnessMode = false;

  nowMillis = millis();

  Button1state = digitalRead(Button1);
  Button2state = digitalRead(Button2);

  if (nowMillis - ButtonPressedMillis <= 1000)
  {
    SetBrightnessMode = true;
  }

  if (Button1state == HIGH && intensity < 0)
  {
    if (nowMillis - ButtonRequesttMillis >= 200)
    {
      Mode = "toUp";
      intensity += 0;
      SetBrightnessMode = true;
      ButtonPressedMillis = millis();
      ButtonRequesttMillis = millis();
    }
  }

  if (Button2state == HIGH && intensity > 0)
  {
    if (nowMillis - ButtonRequesttMillis >= 200)
    {
      Mode = "toDown";
      intensity -= 0;
      SetBrightnessMode = true;
      ButtonPressedMillis = millis();
      ButtonRequesttMillis = millis();
    }
  }

  lc.setIntensity(0, intensity);
  lc.setIntensity(1, intensity);
  lc.setIntensity(2, intensity);
  lc.setIntensity(3, intensity);

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

    SensorCurrentMillis = 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;
  }

  if (!SetBrightnessMode)
  {
    Mode = "Degree";
    Digit1(Whole / 10, Sign);
    Digit2(Whole % 10);
    Digit3(ReadyFract, true);
    Digit4(Mode);
  }
  else
  {
    Digit1(0, "None");
    Digit2(intensity / 10);
    Digit3(intensity % 10, false);
    Digit4(Mode);
  }
}

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

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

          if (Sign == "Plus")
          {
            lc.setRow(3, i, Num0[i] >> 4 | Plus[i]);
          }
          else if (Sign == "Minus")
          {
            lc.setRow(3, i, Num0[i] >> 4 | Minus[i]);
          }
          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]);
          }
        }
        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] >> 1);
          }
        }
        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]);
          }
        }
        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]);
          }
        }
        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]);
          }
        }
        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]);
          }
        }
        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]);
          }
        }
        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]);
          }
        }
        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]);
          }
        }
        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]);
          }
        }
        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 Digit4(String Dig4)
{
  if (Dig4 == "Degree")
    for (uint8_t i = 0; i < 8; i++)
    {
      lc.setRow(0, i, DegreeC[i]);
    }
  else if (Dig4 == "toUp")
    for (uint8_t i = 0; i < 8; i++)
    {
      lc.setRow(0, i, ArrowUp[i]);
    }
  else if (Dig4 == "toDown")
    for (uint8_t i = 0; i < 8; i++)
    {
      lc.setRow(0, i, ArrowDown[i]);
    }
}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
23.02.2020, 23:01
Beitrag #2
RE: Temperatur mit MAX7219
Stelle Deinen Sketch bitte in Codetags.
Wie das geht, steht hier.


Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
23.02.2020, 23:53
Beitrag #3
RE: Temperatur mit MAX7219
(23.02.2020 23:01)Tommy56 schrieb:  Stelle Deinen Sketch bitte in Codetags.
Wie das geht, steht hier.


Gruß Tommy

Gemacht!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
24.02.2020, 13:45 (Dieser Beitrag wurde zuletzt bearbeitet: 24.02.2020 14:53 von Franz54.)
Beitrag #4
RE: Temperatur mit MAX7219
(23.02.2020 22:52)Angelina80 schrieb:  Die Schaltung besteht aus : MAX7219 DOT, Arduino Uno, DS18, DS18b20

Hy Angelina.

Was ist das "DS18" Huh
DS18b20 ist klar. Das ist der Temp. Sensor.

Franz

PS: Zu deiner Änderung. Ich kann mit deiner Hardware nicht Testen. Aber ich würde mal testen, wenn du oben bei den Deklarationen noch dieses Feld dazukopierst:
Code:
byte NumX[8] =
{ B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000
};

Und unten bei Digit1 Case0
Die 4 Zeilen in denen "Num0" steht, auf "NumX" änderst, sollte es funktionieren. Ohne Gewähr, aber ich denke das sollte gehen.

Also so:
Code:
case 0:
      {
        for (uint8_t i = 0; i < 8; i++)
        {
          BufferedDigit[i] = NumX[i];

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

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

Ob´s funktioniert, Blush ....ich weiß es nicht.
Franz

https://www.youtube.com/watch?v=Fnzn85oWM_Q
Hier was zum Thema Deutsche Politik Angry
Und hier zum Thema richtige Politik Big Grin
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.02.2020, 11:40
Beitrag #5
RE: Temperatur mit MAX7219
Hallo Franz54

Du hast mir sehr geholfen! Ja es funktioniert genauso wie Du es auch schon vermutet hast. "DS18" war ein Schreibfehler, keine Ahnung wie es reingekommen ist! Ich danke Dir vielmals für Deine Mühe!

Gruß Angelina80 SmileWink
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.02.2020, 12:24
Beitrag #6
RE: Temperatur mit MAX7219
OK, wunderbar. Danke für die Rückmeldung.

Franz

https://www.youtube.com/watch?v=Fnzn85oWM_Q
Hier was zum Thema Deutsche Politik Angry
Und hier zum Thema richtige Politik Big Grin
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Temperatur- und Füllstandsüberwachung - Fehlersuche h22_de 14 1.063 29.03.2020 17:15
Letzter Beitrag: Fips
  Temperatur mit nrf24 übertragen jgrothe 19 10.136 01.01.2020 16:55
Letzter Beitrag: hotsystems
  MAX7219 Digits tauschen daja64 12 1.392 02.11.2019 18:05
Letzter Beitrag: daja64
  MAX7219 6-Kanal Temperatur Bargraph Cruiser1 3 1.418 18.08.2018 11:25
Letzter Beitrag: ardu_arne
  DS18s20 Temperatur Sensor georg01 9 3.859 25.02.2018 16:03
Letzter Beitrag: georg01
  Temperatur mit Taster um +1 erhöhen T100 7 3.446 09.02.2018 04:58
Letzter Beitrag: T100
  MAX7219 LED Dot Matrix für Mega2560 comfan 4 4.791 29.07.2017 22:40
Letzter Beitrag: Bitklopfer
  Bitte um Hilfe Arduino Nano-MAX7219-PIR_Sensor Opa_Klaus 35 7.932 20.05.2017 21:11
Letzter Beitrag: Opa_Klaus
  Temperatur via SMS senden Obermuda 6 4.525 07.02.2017 12:27
Letzter Beitrag: Tommy56
  DHT22 min max Temperatur 7-Segmentanzeige bastelbert 50 12.677 14.01.2017 11:46
Letzter Beitrag: Tommy56

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste