0221-TS-_antwort_empfangen_512-Test.c


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

2
//           *Testschaltung 1611*

3
//           ********************

4
//   graph. Flüssigkristallanzeige  FKA LC7981

5
//             Uhr DS32C35 

6
7
//                 MSP430F1611

8
//              -----------------

9
//              |              XIN|- 32,768kHz

10
//              |                 |

11
//  Taster rot--|RST (58)     XOUT|- 32,768kHz

12
//                            P5.7|LED rot

13
//              |             P5.6|LED Grün

14
// 8  Mhz X2IN- |             P2.1|Taster 

15
//              |             P2.0|Taster 

16
// 8 MHz X2OUT- |       P1.0..P1.7|Daten FKA 

17
//              |                 |

18
//              |             P3.0|   SPI BL1                        (28)

19
//       UTXD0  |P3.4         P3.1|-> Daten Ausgang           SPI/I²C     (29)

20
//       URXD0  |P3.5         P3.2|<- Data In  (SOMI0)        SPI/I²C          (30)

21
// grau  UTXD1  |P3.6         P3.3|-> Serial Clock Out (SCL)  SPI/I²C   (31)        

22
// rosa  URXD1  |P3.7                                                                                                        

23
//              |             P4.0| M0   E32_868T  grün

24
//                            P4.1| M1   E32_868T

25
//                            P4.2| AUX  E32_868T

26
//                            P4.3|

27
//          |             P4.6|   

28
//              |        P4.7|                   

29
//(44)SD-CS     |P5.0         P2.7| SD Karte Einsteckkontrolle                  

30
//    SD-DI     |P5.1         P2.6| 

31
//    SD-DO     |P5.2         P2.5| RST RV1805

32
//    SD-CLK    |P5.3         P2.4| 

33
// nCSB  ADS1293  |P5.4         P2.3| 

34
//              |P5.5         P2.2| 

35
//   LED grün   |P5.6         P6.7|  

36
//   LED rot    |P5.7         P6.6| Steuerung FKA RS    

37
//                            P6.5| Steuerung FKA R/W

38
//                            P6.3| Steuerung FKA E

39
//******************************************************************************

40
41
#include <msp430x16x.h>

42
#include "0200_lc7981.c"

43
#include <string.h>            // für Zeichen (Infotext) notwendig

44
#include <stdio.h>             // für sprint

45
#include <signal.h>

46
#include "TS_0218_SD_MAINTI.c"

47
#define F_CPU                     800000    // Hz, DCO nach Reset

48
#define TIMEOUT                   7000      // Bits für Datenempfang 7000

49
#define CYCLES_PER_UART_BIT_TIME    (F_CPU/9600)    // CPU Takte pro UART-Bit

50
51
// ein paar #defines für leichter lesbaren Code

52
53
#define LED_GRUEN_EIN   P5OUT &= ~BIT6      

54
#define LED_GRUEN_AUS   P5OUT |=  BIT6

55
#define LED_GRUEN_UM    P5OUT ^=  BIT6

56
#define LED_ROT_EIN     P5OUT &= ~BIT7

57
#define LED_ROT_AUS     P5OUT |=  BIT7

58
59
void programmversion(void);

60
void UART1_einstellen(void);

61
void tasten_entprellen(void);

62
void daten_senden(const unsigned char *data, int cnt);

63
void daten_1_ausgeben(unsigned int data);

64
void daten_2_ausgeben(unsigned int data);

65
void daten_3_ausgeben(unsigned int data);

66
void daten_4_ausgeben(unsigned int data);

67
void  daten_5_ausgeben(unsigned int data);

68
void  daten_6_ausgeben(unsigned int data);

69
void  daten_7_ausgeben(unsigned int data);

70
//void Dx_ausgeben(unsigned int hexwe);

71
72
void antwort_empfangen(void);

73
void delay_ms(unsigned int ms);

74
void Datenanfang(void);

75
void grunddaten(void);

76
77
//unsigned char rx_daten[5]; 

78
//unsigned char rx_daten[8];

79
unsigned char rx_daten[512];

80
char tmp_string[10];

81
unsigned char daten1, daten2, daten3, daten4,daten5,daten6,daten7,d3[512],d2[512],d1[512],ZeitOB=0xFF,ZeitUB=0xFF;

82
unsigned int sector=619,k;

83
const unsigned char config_E32[] = {

84
    0xC0, // sichert die Parameter nach Stromausfall

85
    0x02, // Adresse oberes Byte  

86
    0x02, // Adresse unteres Byte 

87
    0x1A, // 8N1, UART baut rate:9600 (bps), Übertragungsrate:2,4k (bps)

88
    0x09, // Kanal 09 gesendet von von Gerät 3

89
    0xC4  // "fixed" Übetragungsmodus; TXD und AUX als Ausgang RXD als Eingang;  

90
};

91
92
const unsigned char tx_daten[] = {

93
    0x44,  // Adresse 

94
    0x44,  // Adresse

95
    0x09,  // kanal

96
    0x56,  // Marke 0x56 löst antwort bei DS10 aus

97
    0x56  

98
};

99
100
101
102
int main(void) {

103
    WDTCTL = WDTPW | WDTHOLD;     // Stop watchdog timer

104
    P5DIR |= BIT0 + BIT6 + BIT7;  // für LED   P5.6 + P5.7, 5.0 =ST1-SD

105
    LED_GRUEN_AUS;

106
    LED_ROT_AUS;

107
    P4DIR |= BIT0 | BIT1;         // M0; M1

108
    P4OUT |= BIT0 | BIT1;         // M0 und M1 auf 1 --> E32 konfigurieren

109
    P1DIR  = 0xFF;                // FKA

110
    text_init();                  // in FKA TS_7981.h

111
    programmversion();

112
    UART1_einstellen();

113
    daten_senden(config_E32, 6);

114
    P4OUT &= ~BIT0;               // M0 und M1 auf 0 --> E32 senden/empfangen

115
    P4OUT &= ~BIT1;               // M0 und M1 auf 0 --> E32 senden/empfangen

116
    delay_ms(2000);

117
  // SD_Beginn();

118
  // Datenanfang();

119
    while(1) {

120
        tasten_entprellen();

121
        delay_ms(10);

122
    }

123
}

124
125
void tasten_entprellen(void) {

126
    static unsigned char pin_alt;

127
    unsigned char pin;

128
129
    pin = ~P2IN;    // Tasten low active

130
      // eine einfache Flankenerkennung

131
    if ( (pin & BIT0) && !(pin_alt & BIT0) ) {   // Taster 2.0 

132
       i=0;

133
       // LED_ROT_EIN;

134
        daten_senden(tx_daten, 5);               //sendet adresse, Kanal und Marke = 0x56

135
       // LED_ROT_AUS;

136
        antwort_empfangen();

137
    }

138
    if ( (pin & BIT1) && !(pin_alt & BIT1) ) {         // Taster 2.1   keine besondere Funktion

139
        LED_GRUEN_UM;                                  

140
    }                                                

141
    pin_alt = pin;

142
}

143
void antwort_empfangen(void){

144
    unsigned int  j,k;

145
     

146
    for (k=0, j=0; k<TIMEOUT && j<512; k++ )

147
    {

148
        LED_GRUEN_EIN;

149
        if (IFG2 & URXIFG1) {

150
        rx_daten[j++] = RXBUF1;

151
        }

152
         // ca. 5 Bitzeiten warten

153
        __delay_cycles(CYCLES_PER_UART_BIT_TIME*5);

154
        LED_GRUEN_AUS;

155
    }    

156
    

157
    if (i==TIMEOUT) {    // timeout, nicht alle Daten empfangen

158
        // was nun?

159
       LED_ROT_EIN;     //bei Zeitüberschreitung

160
    } else {             

161
       LED_ROT_EIN;

162
       daten1 =  rx_daten[1];  // wird richtig übertragen

163
       daten2 =  rx_daten[2];  // wird richtig übertragen

164
       daten3 =  rx_daten[15]; // wird richtig übertragen

165
       daten4 =  rx_daten[58]; // 58 = max Bytes ?, Byte [58] wird richtig übertragen

166
       daten5 =  rx_daten[59]; // wird zu 0x00; Byte nicht übertragen?

167
       daten6 =  rx_daten[60]; // wird zu 0x00; Byte nicht übertragen?

168
       daten7 =  rx_daten[61]; // wird zu 0x00; Byte nicht übertragen?

169
      

170
       daten_1_ausgeben(daten1);

171
       daten_2_ausgeben(daten2);

172
       daten_3_ausgeben(daten3);

173
       daten_4_ausgeben(daten4);

174
       daten_5_ausgeben(daten5);

175
       daten_6_ausgeben(daten6);

176
       daten_7_ausgeben(daten7);

177
       LED_ROT_AUS;

178
      

179
       }

180
}

181
182
void UART1_einstellen(void) {

183
  

184
    P3SEL  |= 0xC0;                        // P3.6 = USART1 TXD ; P3.7 = RXD1

185
    ME2    |= UTXE1 + URXE1;               // Enable USART1 TXD/RXD  

186
    UCTL1  |= CHAR;                        // 8-bit character

187
    UTCTL1 |= SSEL0;                       // UCLK = ACLK

188
    UBR01   = 0x03;                        // 32k/9600 - 3.41

189
    UBR11   = 0x00;                        //

190
    UMCTL1  = 0x4A;                        // Modulation

191
    UCTL1  &= ~SWRST;                      // Initialize USART state machine

192
//   IE2    |=  URXIE1;      //UTXIE1+        // Enable USART1 RX interrupt 

193
//  _BIS_SR(LPM3_bits + GIE);              // Enter LPM3 w/ interrupt

194
   }

195
196
197
void daten_senden(const unsigned char *data, int cnt) {  

198
        int i;

199
        for (i=0; i<cnt; i++) {   

200
        while (!(IFG2 & UTXIFG1));      // USART1 TX buffer ready? 

201
        TXBUF1 = data[i];

202
        }

203
}

204
205
 // ms Millisekunden warten 

206
void delay_ms(unsigned int ms) {

207
    for (; ms>0; ms--) __delay_cycles(F_CPU/1000);              

208
}

209
210
void programmversion(void) {

211
212
    lcd_set_cursor(0, 1);

213
    lcd_print_string("0218 antwort speichern-SD");  

214
    lcd_set_cursor(0, 2);

215
    lcd_print_string("antwort von DS10");

216
} 

217
218
void  daten_1_ausgeben(unsigned int data) {

219
220
    lcd_set_cursor(1, 4);              // Spalte 1, Zeile 5

221
    sprintf(tmp_string, "%02X", data);

222
    lcd_print_string(tmp_string);

223
}

224
   

225
void  daten_2_ausgeben(unsigned int data) {

226
227
    lcd_set_cursor(4, 4);

228
    sprintf(tmp_string, "%02X", data);

229
    lcd_print_string(tmp_string);

230
}

231
   

232
void  daten_3_ausgeben(unsigned int data) {

233
234
    lcd_set_cursor(7, 4);

235
    sprintf(tmp_string, "%02X", data);

236
    lcd_print_string(tmp_string);

237
}

238
239
void  daten_4_ausgeben(unsigned int data) {

240
241
    lcd_set_cursor(10, 4);

242
    sprintf(tmp_string, "%02X", data);

243
    lcd_print_string(tmp_string);

244
}

245
void  daten_5_ausgeben(unsigned int data) {

246
247
    lcd_set_cursor(13, 4);

248
    sprintf(tmp_string, "%02X", data);

249
    lcd_print_string(tmp_string);

250
}

251
void  daten_6_ausgeben(unsigned int data) {

252
253
    lcd_set_cursor(16, 4);

254
    sprintf(tmp_string, "%02X", data);

255
    lcd_print_string(tmp_string);

256
}

257
void  daten_7_ausgeben(unsigned int data) {

258
259
    lcd_set_cursor(19, 4);

260
    sprintf(tmp_string, "%02X", data);

261
    lcd_print_string(tmp_string);

262
}