SetDigit.c


1
/********************************************************************************************/

2
//Bitstore, store bit to T-Flag

3
#define bst(byte,i) asm volatile("bst %0, %1\n\t" : "+r"(byte) : "M"(i))

4
5
/********************************************************************************************/

6
//Bitload, load bit from T-Flag

7
#define bld(byte,i) asm volatile("bld %0, %1\n\t" : "+r"(byte) : "M"(i))

8
9
10
// 834 Byte (-144B)

11
void SetDigit(uint8_t digit, uint8_t value)

12
{

13
  uint8_t d1, d2, d3, d4;

14
  uint8_t* lcd_addr = lcd;

15
  asm volatile(  "lsr %[digit]        \n\t" 

16
          "adc %A[addr], __zero_reg__  \n\t" //Wenn bit 0 von digit 1 war, addr um eins erhöhen

17
          "adc %B[addr], __zero_reg__  \n\t"

18
          "ldd %[d1],%a[addr]+0    \n\t"

19
          "ldd %[d2],%a[addr]+2    \n\t"

20
          "ldd %[d3],%a[addr]+4    \n\t"

21
          "ldd %[d4],%a[addr]+6    \n\t"

22
          : [d1] "=r"(d1), [d2] "=r"(d2), [d3] "=r"(d3), [d4] "=r"(d4),

23
            [addr] "+b"(lcd_addr), [digit] "+r"(digit));

24
25
  switch(digit)

26
  {

27
    case 0:

28
      bst(value, 0);

29
      bld(d3, 6);

30
      break;

31
    case 1:

32
      bst(value, 2);

33
      bld(d2, 7);

34
      bst(value, 3);

35
      bld(d3, 0);

36
      bst(value, 4);

37
      bld(d3, 1);

38
      bst(value, 5);

39
      bld(d1, 7);

40
      bst(value, 6);

41
      bld(d1, 6);

42
      bcpf(value, d2, 0x03);

43
      break;

44
    case 2:

45
      bst(value, 0);

46
      bld(d1, 3);

47
      bst(value, 1);

48
      bld(d1, 4);

49
      bst(value, 2);

50
      bld(d4, 7);

51
      bst(value, 3);

52
      bld(d2, 4);

53
      bst(value, 4);

54
      bld(d2, 5);

55
      bst(value, 5);

56
      bld(d1, 2);

57
      bst(value, 6);

58
      bld(d2, 3);

59
      break;

60
    case 3:

61
      bst(value, 0);

62
      bld(d3, 4);

63
      bst(value, 5);

64
      bld(d3, 5);

65
      bst(value, 6);

66
      bld(d1, 5);

67
      value <<= 1;

68
      bcpf(value, d4, 60);

69
      break;

70
      

71
  }

72
73
  asm volatile(  "std %a[addr]+0, %[d1]  \n\t"

74
          "std %a[addr]+2, %[d2]  \n\t"

75
          "std %a[addr]+4, %[d3]  \n\t"

76
          "std %a[addr]+6, %[d4]  \n\t"

77
          : : [d1] "r"(d1), [d2] "r"(d2), [d3] "r"(d3), [d4] "r"(d4),

78
            [addr] "b"(lcd_addr) : "memory");

79
80
}

81
// 978 Bytes (+144B)

82
void SetDigit(uint8_t digit, uint8_t value)

83
{

84
  switch(digit >> 1)

85
  {

86
    case 0:

87
      bst(value, 0);

88
      bld(lcd[4+(digit&1)], 6);

89
      break;

90
    case 1:

91
      bst(value, 2);

92
      bld(lcd[2+(digit&1)], 7);

93
      bst(value, 3);

94
      bld(lcd[4+(digit&1)], 0);

95
      bst(value, 4);

96
      bld(lcd[4+(digit&1)], 1);

97
      bst(value, 5);

98
      bld(lcd[digit&1], 7);

99
      bst(value, 6);

100
      bld(lcd[digit&1], 6);

101
      bcpf(value, lcd[2+(digit&1)], 0x03);

102
      break;

103
    case 2:

104
      bst(value, 0);

105
      bld(lcd[digit&1], 3);

106
      bst(value, 1);

107
      bld(lcd[digit&1], 4);

108
      bst(value, 2);

109
      bld(lcd[6+(digit&1)], 7);

110
      bst(value, 3);

111
      bld(lcd[2+(digit&1)], 4);

112
      bst(value, 4);

113
      bld(lcd[2+(digit&1)], 5);

114
      bst(value, 5);

115
      bld(lcd[digit&1], 2);

116
      bst(value, 6);

117
      bld(lcd[2+(digit&1)], 3);

118
      break;

119
    case 3:

120
      bst(value, 0);

121
      bld(lcd[4+(digit&1)], 4);

122
      bst(value, 5);

123
      bld(lcd[4+(digit&1)], 5);

124
      bst(value, 6);

125
      bld(lcd[digit&1], 5);

126
      value <<= 1;

127
      bcpf(value, lcd[6+(digit&1)], 60);

128
      break;

129
      

130
  }

131
}