AVT 5560 - potrzebna modyfikacja oprogramowania.

[dekom]

Witam. Z mnogości funkcji kitu niezbędne mi są funkcja uczenia sekwencji, w kodzie źródłowym pliku "mikro_timek.c"oznaczony MODE6_LEARN (w dokumentacji pdf tryb 7) oraz zmodyfikowany tryb MODE3_ADD (w dokumentacji tryb 4). Modyfikacja miała by polegać na tym by czas do wyłączenia przekaźnika był mierzony od nowa przy każdym puszczeniu przycisku/włącznika chwilowego bez przerywania działania przekaźnika. Taki "reset timera" przy każdym puszczeniu przycisku

Wszelki moje próby resetowania timer'a w różnych miejscach kodu zawiodły. Pierwszy raz modyfikuję kod C/C++ ... metodą analizy i porównań istniejącego kodu, ale jak widać z marnym skutkiem. Proszę o pomoc we wpisaniu właściwej sekwencji kodu we właściwym miejscu kodu źródłowego autora P D. Sosnowskiego.
Zawartość oryginalna kodu źródłowego mikro_timek.c:

/*
* mikro_timek.c
*
* Created: 2016-03-16 13:36:51
* Author: dsosnowski
*/


#define F_CPU 1000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/sleep.h>

#include "defs.h"
#include "ee_mem.h"
#include "wdog.h"



// 1:2:3: - szpilki
// no - result = 0 - standard mode - pulse after press
// 1: - result = 1 - standard + reload - restrat pulse
// 2: - result = 2 - standard + clear - quick off
// 3: - result = 3 - add mode - pulse after press
// 1-2 - result = 4 - loop mode + clear - pulses when hold and quick off after release
// 2-3 - result = 5 - bistable


void SekwenceGet(char index);
void SekwenceStore(char index, char state, uint16_t time);
void HardIinit(void);
void TimerStart(void);
char InputGet(char restart);
char ConfigGet(void);



struct {
volatile char tick;
char mode;
char input;
char led;
} system;

struct {
char step;
char state;
uint16_t range;
uint16_t counter;
char next;
char stop;
} sekwence;




//--------------------------------------------------
int main(void) {
char i;

HardIinit();

sekwence.next = 0;
sekwence.step = 0;
sekwence.stop = 1;
sekwence.state = 0;

system.mode = ConfigGet();

InputGet(1);
for (i = 0; i <= TON_THR; i++) {
if (InputGet(0) == INPUT_PRESS)
sekwence.state = 1;
}

//---------------------------------------------------------------------
if (system.mode == MODE6_LEARN) {
sekwence.range = (TIME_MAX + 1);
sekwence.stop = 0;
system.led = 1;
SekwenceStore(sekwence.step, 1, TIME_MASK);
/*i = 0;
while (i <= TON_THR) {
if (InputGet() == INPUT_PRESS){
sekwence.state = 1;
OUT_SET;
}
i++;
}*/
if (sekwence.state == 1) OUT_SET;
}

if (system.mode < MODE6_LEARN) {
if (sekwence.state == 1)
SekwenceGet(0);
else
SekwenceGet(STEPS_MAX);
//if (sekwence.state) OUT_SET;
//else OUT_OFF;
InputGet(1);
}

TimerStart();
sei();

//---------------------------------------------------------------------
while(1)
{

system.input = InputGet(0);

//---------------------------------------------------------------------
if (system.tick) {
system.tick = 0;
system.led++;
if (sekwence.counter < TIME_MAX) sekwence.counter++;
if (sekwence.counter >= sekwence.range) sekwence.next = NEXT_NEXT;
if (sekwence.stop) sekwence.next = 0;
}

//---------------------------------------------------------------------
if (system.mode == MODE6_LEARN) {

if ((system.input == INPUT_PRESS) || (system.input == INPUT_RELEASE)) {
TIMER_RESTART;

sekwence.state = 0;
if (system.input == INPUT_RELEASE) sekwence.state = 1;

SekwenceStore(sekwence.step, sekwence.state, sekwence.counter);
if (sekwence.step < STEPS_MAX) sekwence.step++;
SekwenceStore(sekwence.step, 1, TIME_MASK);

sekwence.counter = 0;

if (sekwence.state == 0) {
OUT_SET;
sekwence.state = 1;
} else {
OUT_OFF;
sekwence.state = 0;
}
}

if ((PINB & (1<<CF1_PIN)) > 0) {
TIMER_RESTART;
sekwence.state = 0;
if (system.input >= INPUT_HOLD) sekwence.state = 1;
SekwenceStore(STEPS_MAX, sekwence.state, sekwence.counter);

PORTB &= ~(1<<CF1_PIN);
LED_SET;

while(1);
}
}

//---------------------------------------------------------------------
if (system.mode < MODE6_LEARN) {

if (system.input == INPUT_PRESS) {
if (system.mode == MODE0_STANDARD) {
if (sekwence.stop == 1) {
sekwence.stop = 0;
sekwence.next = NEXT_RESTART;
}
}

if (system.mode == MODE1_STANDARD_RELOAD) {
sekwence.stop = 0;
sekwence.next = NEXT_RESTART;
}

if (system.mode == MODE2_STANDARD_CLEAR) {
if (sekwence.stop == 1) {
sekwence.stop = 0;
sekwence.next = NEXT_RESTART;
} else {
sekwence.next = NEXT_END;
}
}

if (system.mode == MODE3_ADD) {
if (sekwence.stop == 1) {
sekwence.next = NEXT_RESTART;
}
}

if (system.mode == MODE4_LOOP_CLEAR) {
if (sekwence.stop == 1) {
sekwence.stop = 0;
sekwence.next = NEXT_RESTART;
}
}

if (system.mode == MODE5_BISTABLE) {
TIMER_RESTART;
sekwence.stop = 1;
sekwence.next = 0;
system.led = 0;
if (sekwence.state) {
sekwence.state = 0;
//OUT_OFF;
} else {
sekwence.state = 1;
//OUT_SET;
}
}
}

//-----------------------------------
if (system.input == INPUT_RELEASE) {
if (system.mode == MODE3_ADD) {
if (sekwence.stop == 1) {
sekwence.stop = 0;
sekwence.next = NEXT_RESTART;
}
}

if (system.mode == MODE4_LOOP_CLEAR) {
if (sekwence.stop == 0) {
sekwence.stop = 1;
sekwence.next = NEXT_END;
}
}
}

//-----------------------------------
if (sekwence.next) {
if (sekwence.next == NEXT_RESTART) {
sekwence.step = 0;
system.led = 0;
TIMER_RESTART;
}
if (sekwence.next == NEXT_END) sekwence.step = STEPS_MAX;

if (sekwence.next == NEXT_NEXT) {
sekwence.step++;
system.led = 0;
}

SekwenceGet(sekwence.step);

sekwence.counter = 0;
//if (sekwence.state) OUT_SET;
//else OUT_OFF;
sekwence.next = NEXT_IDLE;
}

if (sekwence.state) OUT_SET;
else OUT_OFF;


//-----------------------------------
if (system.led >= LED_INTERVAL) system.led = 0;
if (system.led < 3) LED_SET;
if (system.led == 3) LED_OFF;
}

//---------------------------------------------------------------------
WdtReset();
_delay_ms(MAIN_DELAY);
}
}

//--------------------------------------------------
void SekwenceGet(char index) {
uint16_t data;
char result = 0;

//end of memory
if (index >= STEPS_MAX) {
index = STEPS_MAX;
result = 1;
}

//end of sekwence - data = 0xFFFF;
data = EEread16(index * 2);
if ((data & TIME_MASK) > TIME_MAX) {
index = STEPS_MAX;
result = 1;
}

//read step
data = EEread16(index * 2);

sekwence.state = 0;
if (data & STATE_MASK) sekwence.state = 1;

sekwence.range = (data & TIME_MASK);

//loop modes
if (result == 1) {
if ((system.mode == MODE4_LOOP_CLEAR) && (system.input >= INPUT_HOLD)) {
sekwence.stop = 0;
sekwence.step = 0xFF;
} else {
sekwence.stop = 1;
sekwence.range = 0;
}
}
}

//--------------------------------------------------
void SekwenceStore(char index, char state, uint16_t time) {
//end of memory
if (index > STEPS_MAX) {
index = STEPS_MAX;
}

time &= ~(STATE_MASK);
if (state) time |= STATE_MASK;

EEwrite16((index * 2), time);
}

//--------------------------------------------------
void HardIinit(void) {
DDRB = (1<<OUTPUT_PIN);
PRR = (1<<PRTIM1 | 1<<PRUSI | 1<<PRADC);
ACSR |= (ACD);
WdtSet(7);
}

//--------------------------------------------------
void TimerStart(void) {
TCCR0B = 0;
TCCR0A = (1<<WGM01 | 1<<WGM00);
TCNT0 = 0;
//OCR0A = TIMER_MAX;
GTCCR |= (1<<PSR0);
TIFR |= (1<<TOV0);
TIMSK |= (1<<TOIE0);
TCCR0B = (1<<WGM02 | 1<<CS02 | 1<<CS00);
}

//--------------------------------------------------
ISR (TIMER0_OVF_vect) {
system.tick++;
}

//--------------------------------------------------
char InputGet(char restart) {
static char t_on;
static char t_off;

if (restart > 0) {
t_on = 0;
t_off = TOFF_THR + 1;
} else {
if ((PINB & (1<<INPUT_PIN)) == 0) {
if (t_on < 0xFF) t_on++;
t_off = 0;
} else {
if (t_off < 0xFF) t_off++;
if (t_off >= TOFF_THR) t_on = 0;
}
}

if (t_on == TON_THR) return INPUT_PRESS;
if (t_on > TON_THR) return INPUT_HOLD;
if (t_off == TOFF_THR) return INPUT_RELEASE;
return INPUT_IDLE;
}

//--------------------------------------------------
char ConfigGet(void) {
char result = MODE0_STANDARD;

DDRB &= ~(1<<CF1_PIN | 1<<CF2_PIN | 1<<CF3_PIN);
PORTB |= (1<<CF1_PIN | 1<<CF2_PIN | 1<<CF3_PIN);

_delay_ms(50);

if ((PINB & (1<<CF1_PIN)) == 0) {
result = MODE6_LEARN;
} else {
if (((PINB & (1<<CF2_PIN)) == 0) && ((PINB & (1<<CF3_PIN)) > 0)) {
result = MODE1_STANDARD_RELOAD;
}
if (((PINB & (1<<CF2_PIN)) > 0) && ((PINB & (1<<CF3_PIN)) == 0)) {
result = MODE2_STANDARD_CLEAR;
}
if (((PINB & (1<<CF2_PIN)) == 0) && ((PINB & (1<<CF3_PIN)) == 0)) {
result = MODE3_ADD;
}
}

if (result == 0) {
PORTB &= ~(1<<CF2_PIN);
DDRB |= (1<<CF2_PIN);
_delay_ms(50);

if (((PINB & (1<<CF1_PIN)) == 0) && ((PINB & (1<<CF3_PIN)) > 0)) {
result = MODE4_LOOP_CLEAR;
}
if (((PINB & (1<<CF1_PIN)) > 0) && ((PINB & (1<<CF3_PIN)) == 0)) {
result = MODE5_BISTABLE;
}

DDRB &= ~(1<<CF2_PIN);
}

//DDRB |= (1<<CF1_PIN);
PORTB &= ~(1<<CF1_PIN | 1<<CF2_PIN | 1<<CF3_PIN);
if (result == MODE6_LEARN) PORTB |= (1<<CF1_PIN);

_delay_ms(50);
return result;
}

[dekom]

Nie mogłem czekać na "miłosierdzie" forum i rozwiązałem zagadnienia przez dopisanie:

//-----------------------------------
if (system.input == INPUT_HOLD) {
if (system.mode == MODE3_ADD) {
sekwence.stop = 0;
sekwence.next = NEXT_RESTART;

}
}


Pozdrawiam.