comparison: main/task_dcf.c
main/task_dcf.c
- changeset 3
- 849ca14d4a2f
- parent 2
- 053649608c09
- child 4
- 426defedd402
equal
deleted
inserted
replaced
| 2:053649608c09 | 3:849ca14d4a2f |
|---|---|
| 64 | 64 |
| 65 | 65 |
| 66 static void DCFout(void* arg); | 66 static void DCFout(void* arg); |
| 67 void DCFout(void* arg) | 67 void DCFout(void* arg) |
| 68 { | 68 { |
| 69 int i, tmp, parity; | 69 int i; |
| 70 static int tmp, tmpin, parity = 0; | |
| 70 | 71 |
| 71 switch (impulseCount++) { | 72 switch (impulseCount++) { |
| 72 case 0: if (actualSecond == 0) { | 73 case 0: if (actualSecond == 0) { |
| 73 time(&dcf_now); | 74 time(&dcf_now); |
| 74 dcf_now += 60; | 75 dcf_now += 60; |
| 75 } | 76 } |
| 76 if (impulseArray[actualSecond] != 0) { | 77 if (impulseArray[actualSecond] == 1) { |
| 77 gpio_set_level(CONFIG_LED1_PIN, 1); | 78 gpio_set_level(CONFIG_LED1_PIN, 1); |
| 79 } else if (impulseArray[actualSecond] == 2) { | |
| 80 gpio_set_level(CONFIG_LED2_PIN, 1); | |
| 78 } | 81 } |
| 79 break; | 82 break; |
| 80 case 1: if (impulseArray[actualSecond] == 1) { | 83 case 1: if (impulseArray[actualSecond] == 1) { |
| 81 gpio_set_level(CONFIG_LED1_PIN, 0); | 84 gpio_set_level(CONFIG_LED1_PIN, 0); |
| 82 } | 85 } |
| 83 break; | 86 break; |
| 84 case 2: gpio_set_level(CONFIG_LED1_PIN, 0); | 87 case 2: gpio_set_level(CONFIG_LED1_PIN, 0); |
| 88 gpio_set_level(CONFIG_LED2_PIN, 0); | |
| 85 break; | 89 break; |
| 86 case 9: impulseCount = 0; | 90 case 9: impulseCount = 0; |
| 87 /* | 91 /* |
| 88 * To spread the CPU load, we set all bits during the first seconds | 92 * To spread the CPU load, we set all bits during the first seconds |
| 89 * because we don't use these bits. | 93 * because we don't use these bits. |
| 90 */ | 94 */ |
| 91 switch (actualSecond) { | 95 switch (actualSecond) { |
| 92 case 0: /* the first 20 bits of each minute at a logical zero value */ | 96 case 0: /* the first 20 bits of each minute at a logical zero value */ |
| 93 for (i = 0; i < 20; i++) | 97 for (i = 0; i < 20; i++) |
| 94 impulseArray[i] = 1; | 98 impulseArray[i] = 1; |
| 99 for (i = 1; i < 9; i++) | |
| 100 impulseArray[i] = 2; /* Civil warning bits 1..14 */ | |
| 101 /* Bit 15, Antenna bit. 0 = normal operation, 1 = fault */ | |
| 95 break; | 102 break; |
| 96 case 1: localtime_r(&dcf_now, &dcf_tm); | 103 case 1: localtime_r(&dcf_now, &dcf_tm); |
| 97 char strftime_buf[64]; | 104 char strftime_buf[64]; |
| 98 strftime(strftime_buf, sizeof(strftime_buf), "%c", &dcf_tm); | 105 strftime(strftime_buf, sizeof(strftime_buf), "%c", &dcf_tm); |
| 99 ESP_LOGI(TAG, "The current date/time to send is: %s", strftime_buf); | 106 ESP_LOGI(TAG, "The current date/time to send is: %s", strftime_buf); |
| 100 break; | 107 break; |
| 101 case 2: /* DST bits */ | 108 case 2: /* DST bits */ |
| 102 if (dcf_tm.tm_isdst == 0) { | 109 if (dcf_tm.tm_isdst == 0) { |
| 103 impulseArray[17] = 1; | 110 impulseArray[17] = 1; /* Set when DST is in effect. */ |
| 104 impulseArray[18] = 2; | 111 impulseArray[18] = 2; /* Set when DST is not in effect. */ |
| 105 } else { | 112 } else { |
| 106 impulseArray[17] = 2; | 113 impulseArray[17] = 2; |
| 107 impulseArray[18] = 1; | 114 impulseArray[18] = 1; |
| 108 } | 115 } |
| 109 /* bit 20 must be 1 to indicate active time */ | 116 /* Start of encoded time. Always set */ |
| 110 impulseArray[20] = 2; | 117 impulseArray[20] = 2; |
| 111 break; | 118 break; |
| 112 case 3: int minute = bin2bcd(dcf_tm.tm_min); | 119 case 3: /* announce DST on-off bit 16 */ |
| 120 int month = dcf_tm.tm_mon + 1; | |
| 121 bool announce = false; | |
| 122 if (dcf_tm.tm_mday >= 25 || dcf_tm.tm_wday == 0) { | |
| 123 /* Last sunday in the month */ | |
| 124 if (month == 3) { | |
| 125 if (dcf_tm.tm_isdst == 0 && dcf_tm.tm_hour == 1 && dcf_tm.tm_min != 0) { | |
| 126 announce = true; /* Wintertime to summertime */ | |
| 127 } | |
| 128 } else if (month == 10) { | |
| 129 if (dcf_tm.tm_isdst > 0 && dcf_tm.tm_hour == 1 && dcf_tm.tm_min != 0) { | |
| 130 announce = true; /* Summertime to wintertime */ | |
| 131 } | |
| 132 } | |
| 133 } | |
| 134 ESP_LOGI(TAG, "%d announce TZ change %s", dcf_tm.tm_isdst, announce ? "true":"false"); | |
| 135 impulseArray[16] = (announce) ? 2:1; | |
| 136 break; | |
| 137 case 4: /* | |
| 138 * We don't announce the leap second. It is not always sure when this will | |
| 139 * happen, possible at end of 2023, but it is not sure. And the next? | |
| 140 * SNTP timesync will deal with this and we will see a timejump. | |
| 141 */ | |
| 142 break; | |
| 143 case 5: tmpin = bin2bcd(dcf_tm.tm_min); | |
| 113 parity = 0; | 144 parity = 0; |
| 114 for (i = 21; i < 28; i++) { | 145 for (i = 21; i < 28; i++) { |
| 115 tmp = minute & 1; | 146 tmp = tmpin & 1; |
| 116 impulseArray[i] = tmp + 1; | 147 impulseArray[i] = tmp + 1; |
| 117 parity += tmp; | 148 parity += tmp; |
| 118 minute >>= 1; | 149 tmpin >>= 1; |
| 119 } | 150 } |
| 120 impulseArray[28] = (parity & 1) ? 2:1; | 151 impulseArray[28] = (parity & 1) ? 2:1; |
| 121 ESP_LOGI(TAG, "minute %d%d%d%d%d%d%d %d", impulseArray[21], impulseArray[22], impulseArray[23], | 152 ESP_LOGI(TAG, "minute %d%d%d%d%d%d%d P1 %d", impulseArray[21], impulseArray[22], impulseArray[23], |
| 122 impulseArray[24], impulseArray[25], impulseArray[26], impulseArray[27], impulseArray[28]); | 153 impulseArray[24], impulseArray[25], impulseArray[26], impulseArray[27], impulseArray[28]); |
| 123 break; | 154 break; |
| 124 | 155 case 6: tmpin = bin2bcd(dcf_tm.tm_hour); |
| 125 | 156 parity = 0; |
| 157 for (i = 29; i < 35; i++) { | |
| 158 tmp = tmpin & 1; | |
| 159 impulseArray[i] = tmp + 1; | |
| 160 parity += tmp; | |
| 161 tmpin >>= 1; | |
| 162 } | |
| 163 impulseArray[35] = (parity & 1) ? 2:1; | |
| 164 ESP_LOGI(TAG, "hour %d%d%d%d%d%d P2 %d", impulseArray[29], impulseArray[30], impulseArray[31], | |
| 165 impulseArray[32], impulseArray[33], impulseArray[34], impulseArray[35]); | |
| 166 break; | |
| 167 case 7: tmpin = bin2bcd(dcf_tm.tm_mday); | |
| 168 parity = 0; | |
| 169 for (i = 36; i < 42; i++) { | |
| 170 tmp = tmpin & 1; | |
| 171 impulseArray[i] = tmp + 1; | |
| 172 parity += tmp; | |
| 173 tmpin >>= 1; | |
| 174 } | |
| 175 ESP_LOGI(TAG, "mday %d%d%d%d%d%d", impulseArray[36], impulseArray[37], impulseArray[38], | |
| 176 impulseArray[39], impulseArray[40], impulseArray[41]); | |
| 177 break; | |
| 178 case 8: tmpin = bin2bcd(dcf_tm.tm_wday); | |
| 179 if (tmpin == 0) | |
| 180 tmpin = 7; | |
| 181 for (i = 42; i < 45; i++) { | |
| 182 tmp = tmpin & 1; | |
| 183 impulseArray[i] = tmp + 1; | |
| 184 parity += tmp; | |
| 185 tmpin >>= 1; | |
| 186 } | |
| 187 ESP_LOGI(TAG, "wday %d%d%d", impulseArray[42], impulseArray[43], impulseArray[44]); | |
| 188 break; | |
| 189 case 9: tmpin = bin2bcd(dcf_tm.tm_mon + 1); | |
| 190 for (i = 45; i < 50; i++) { | |
| 191 tmp = tmpin & 1; | |
| 192 impulseArray[i] = tmp + 1; | |
| 193 parity += tmp; | |
| 194 tmpin >>= 1; | |
| 195 } | |
| 196 ESP_LOGI(TAG, "month %d%d%d%d%d", impulseArray[45], impulseArray[46], impulseArray[47], | |
| 197 impulseArray[48], impulseArray[49]); | |
| 198 break; | |
| 199 case 10: tmpin = bin2bcd(dcf_tm.tm_year - 100); | |
| 200 for (int i = 50; i < 58; i++) { | |
| 201 tmp = tmpin & 1; | |
| 202 impulseArray[i] = tmp + 1; | |
| 203 parity += tmp; | |
| 204 tmpin >>= 1; | |
| 205 } | |
| 206 impulseArray[58] = (parity & 1) ? 2:1; | |
| 207 ESP_LOGI(TAG, "year %d%d%d%d%d%d%d%d P3 %d", impulseArray[50], impulseArray[51], impulseArray[52], | |
| 208 impulseArray[53], impulseArray[54], impulseArray[55], impulseArray[56], impulseArray[57], impulseArray[58]); | |
| 209 break; | |
| 126 } | 210 } |
| 127 if (actualSecond < 59) /* Can include leap second */ | 211 if (actualSecond < 59) /* Can include leap second */ |
| 128 actualSecond++; | 212 actualSecond++; |
| 129 break; | 213 break; |
| 130 } | 214 } |
