2
2
#include "app_ios_and_regs.h"
3
3
#include "hwbp_core.h"
4
4
5
+ extern uint16_t pulse_counter_ms ;
5
6
6
7
/************************************************************************/
7
8
/* Create pointers to functions */
@@ -13,7 +14,7 @@ void (*app_func_rd_pointer[])(void) = {
13
14
& app_read_REG_ANALOG_INPUTS ,
14
15
& app_read_REG_DI0 ,
15
16
& app_read_REG_RESERVED0 ,
16
- & app_read_REG_THRESHOLDS ,
17
+ & app_read_REG_RESERVED00 ,
17
18
& app_read_REG_RANGE_AND_INPUT_FILTER ,
18
19
& app_read_REG_SAMPLE_FREQUENCY ,
19
20
& app_read_REG_DI0_CONF ,
@@ -75,7 +76,7 @@ bool (*app_func_wr_pointer[])(void*) = {
75
76
& app_write_REG_ANALOG_INPUTS ,
76
77
& app_write_REG_DI0 ,
77
78
& app_write_REG_RESERVED0 ,
78
- & app_write_REG_THRESHOLDS ,
79
+ & app_write_REG_RESERVED00 ,
79
80
& app_write_REG_RANGE_AND_INPUT_FILTER ,
80
81
& app_write_REG_SAMPLE_FREQUENCY ,
81
82
& app_write_REG_DI0_CONF ,
@@ -207,35 +208,42 @@ bool app_write_REG_RESERVED0(void *a)
207
208
208
209
209
210
/************************************************************************/
210
- /* REG_THRESHOLDS */
211
+ /* REG_RESERVED00 */
211
212
/************************************************************************/
212
- void app_read_REG_THRESHOLDS (void )
213
+ void app_read_REG_RESERVED00 (void )
213
214
{
214
- //app_regs.REG_THRESHOLDS = 0;
215
+ //app_regs.REG_RESERVED00 = 0;
215
216
216
217
}
217
218
218
- bool app_write_REG_THRESHOLDS (void * a )
219
+ bool app_write_REG_RESERVED00 (void * a )
219
220
{
220
221
uint8_t reg = * ((uint8_t * )a );
221
222
222
- app_regs .REG_THRESHOLDS = reg ;
223
+ app_regs .REG_RESERVED00 = reg ;
223
224
return true;
224
225
}
225
226
226
227
227
228
/************************************************************************/
228
229
/* REG_RANGE_AND_INPUT_FILTER */
229
230
/************************************************************************/
230
- void app_read_REG_RANGE_AND_INPUT_FILTER (void )
231
- {
232
- //app_regs.REG_RANGE_AND_INPUT_FILTER = 0;
233
-
234
- }
235
-
231
+ void app_read_REG_RANGE_AND_INPUT_FILTER (void ) {}
236
232
bool app_write_REG_RANGE_AND_INPUT_FILTER (void * a )
237
233
{
238
234
uint8_t reg = * ((uint8_t * )a );
235
+
236
+ if (reg & ~MSK_RANGE_AND_INPUT_FILTER )
237
+ return false;
238
+
239
+ PORTD .OUTCLR = 0x1C ;
240
+ PORTD .OUTSET = (reg << 2 ) & 0x1C ;
241
+
242
+
243
+ if (reg & 0x10 )
244
+ set_RANGE ;
245
+ else
246
+ clr_RANGE ;
239
247
240
248
app_regs .REG_RANGE_AND_INPUT_FILTER = reg ;
241
249
return true;
@@ -245,15 +253,13 @@ bool app_write_REG_RANGE_AND_INPUT_FILTER(void *a)
245
253
/************************************************************************/
246
254
/* REG_SAMPLE_FREQUENCY */
247
255
/************************************************************************/
248
- void app_read_REG_SAMPLE_FREQUENCY (void )
249
- {
250
- //app_regs.REG_SAMPLE_FREQUENCY = 0;
251
-
252
- }
253
-
256
+ void app_read_REG_SAMPLE_FREQUENCY (void ) {}
254
257
bool app_write_REG_SAMPLE_FREQUENCY (void * a )
255
258
{
256
259
uint8_t reg = * ((uint8_t * )a );
260
+
261
+ if (reg & ~MSK_SAMPLE_FREQUENCY )
262
+ return false;
257
263
258
264
app_regs .REG_SAMPLE_FREQUENCY = reg ;
259
265
return true;
@@ -263,15 +269,13 @@ bool app_write_REG_SAMPLE_FREQUENCY(void *a)
263
269
/************************************************************************/
264
270
/* REG_DI0_CONF */
265
271
/************************************************************************/
266
- void app_read_REG_DI0_CONF (void )
267
- {
268
- //app_regs.REG_DI0_CONF = 0;
269
-
270
- }
271
-
272
+ void app_read_REG_DI0_CONF (void ) {}
272
273
bool app_write_REG_DI0_CONF (void * a )
273
274
{
274
275
uint8_t reg = * ((uint8_t * )a );
276
+
277
+ if (reg & (~MSK_DI0_SEL ))
278
+ return false;
275
279
276
280
app_regs .REG_DI0_CONF = reg ;
277
281
return true;
@@ -317,16 +321,16 @@ bool app_write_REG_DO0_PULSE(void *a)
317
321
/************************************************************************/
318
322
/* REG_DO_SET */
319
323
/************************************************************************/
320
- void app_read_REG_DO_SET (void )
321
- {
322
- //app_regs.REG_DO_SET = 0;
323
-
324
- }
325
-
324
+ void app_read_REG_DO_SET (void ) {}
326
325
bool app_write_REG_DO_SET (void * a )
327
326
{
328
- uint16_t reg = * ((uint16_t * )a );
327
+ uint8_t reg = * ((uint8_t * )a );
328
+
329
+ //PORTA_OUTSET = reg & 0x0F;
330
+ //if (reg & B_DO0)
331
+ // pulse_counter_ms = app_regs.REG_DO0_PULSE + 1;
329
332
333
+ app_regs .REG_DO_WRITE = PORTA_OUT & 0x0F ;
330
334
app_regs .REG_DO_SET = reg ;
331
335
return true;
332
336
}
@@ -335,16 +339,14 @@ bool app_write_REG_DO_SET(void *a)
335
339
/************************************************************************/
336
340
/* REG_DO_CLEAR */
337
341
/************************************************************************/
338
- void app_read_REG_DO_CLEAR (void )
339
- {
340
- //app_regs.REG_DO_CLEAR = 0;
341
-
342
- }
343
-
342
+ void app_read_REG_DO_CLEAR (void ) {}
344
343
bool app_write_REG_DO_CLEAR (void * a )
345
344
{
346
- uint16_t reg = * ((uint16_t * )a );
345
+ uint8_t reg = * ((uint8_t * )a );
346
+
347
+ //PORTA_OUTCLR = reg & 0x0F;
347
348
349
+ app_regs .REG_DO_WRITE = PORTA_OUT & 0x0F ;
348
350
app_regs .REG_DO_CLEAR = reg ;
349
351
return true;
350
352
}
@@ -353,16 +355,18 @@ bool app_write_REG_DO_CLEAR(void *a)
353
355
/************************************************************************/
354
356
/* REG_DO_TOGGLE */
355
357
/************************************************************************/
356
- void app_read_REG_DO_TOGGLE (void )
357
- {
358
- //app_regs.REG_DO_TOGGLE = 0;
359
-
360
- }
361
-
358
+ void app_read_REG_DO_TOGGLE (void ) {}
362
359
bool app_write_REG_DO_TOGGLE (void * a )
363
360
{
364
- uint16_t reg = * ((uint16_t * )a );
365
-
361
+ uint8_t reg = * ((uint8_t * )a );
362
+
363
+ //if (!read_DO0)
364
+ // if (reg & B_DO0)
365
+ // pulse_counter_ms = app_regs.REG_DO0_PULSE + 1;
366
+
367
+ //PORTA_OUTTGL = reg & 0x0F;
368
+
369
+ app_regs .REG_DO_WRITE = PORTA_OUT & 0x0F ;
366
370
app_regs .REG_DO_TOGGLE = reg ;
367
371
return true;
368
372
}
@@ -371,17 +375,17 @@ bool app_write_REG_DO_TOGGLE(void *a)
371
375
/************************************************************************/
372
376
/* REG_DO_WRITE */
373
377
/************************************************************************/
374
- void app_read_REG_DO_WRITE (void )
375
- {
376
- //app_regs.REG_DO_WRITE = 0;
377
-
378
- }
379
-
378
+ void app_read_REG_DO_WRITE (void ) {}
380
379
bool app_write_REG_DO_WRITE (void * a )
381
380
{
382
- uint16_t reg = * ((uint16_t * )a );
381
+ uint8_t reg = * ((uint8_t * )a );
382
+
383
+ //PORTA_OUT = (PORTA_OUT & (~0x0F)) | (reg & 0x0F);
384
+
385
+ //if (reg & B_DO0)
386
+ // pulse_counter_ms = app_regs.REG_DO0_PULSE + 1;
383
387
384
- app_regs .REG_DO_WRITE = reg ;
388
+ app_regs .REG_DO_WRITE = PORTA_OUT & 0x0F ;
385
389
return true;
386
390
}
387
391
@@ -425,15 +429,13 @@ bool app_write_REG_RESERVED2(void *a)
425
429
/************************************************************************/
426
430
/* REG_TRIGGER_DESTINY */
427
431
/************************************************************************/
428
- void app_read_REG_TRIGGER_DESTINY (void )
429
- {
430
- //app_regs.REG_TRIGGER_DESTINY = 0;
431
-
432
- }
433
-
432
+ void app_read_REG_TRIGGER_DESTINY (void ) {}
434
433
bool app_write_REG_TRIGGER_DESTINY (void * a )
435
434
{
436
- int16_t reg = * ((int16_t * )a );
435
+ uint8_t reg = * ((uint8_t * )a );
436
+
437
+ if (reg & (~MSK_TRIG_TO_DO0 ))
438
+ return false;
437
439
438
440
app_regs .REG_TRIGGER_DESTINY = reg ;
439
441
return true;
0 commit comments