main.h
events.h
events.c
kbd_drv.h
kbd_drv.c
Программные таймеры тут.
proc_device.h
proc_device.с Собссно сам алгоритм.
Спойлер
Код: Выделить всё
//==================
#include "main_def_func.h" // Заголовочные файлы, глобальные определения, общие функции.
//==================
//==================
__C_task main (void)
{
wdt_enable (WDTO_15_MS);
init_soft_timers ();
Init_Events ();
__enable_interrupt ();
while (1)
{
__watchdog_reset ();
proc_device ();
Process_Events ();
}
}
//==================
Спойлер
Код: Выделить всё
//==================
#ifndef EVENTS_H
#define EVENTS_H
#include "events.h"
#include "main_def_func.h"
//==================
//==================
extern u08 Events [];
typedef enum num_event
{
EV_ID_KEY_PRESSED,
EV_ID_KEY_UNPRESSED,
EV_ID_2,
EV_ID_3,
EV_ID_4,
MAX_ID_EVENTS,
} num_event;
#define NORMAL_EVENT 1
#define USER_EVENT 3
//==================
extern void Init_Events (void);
extern bool Get_Event (u08 event);
extern void Set_Event (u08 event, u08 status);
extern void Clr_Event (u08 event);
extern void Process_Events (void);
#endif
Спойлер
Код: Выделить всё
//==================
#include "events.h"
//==================
//==================
u08 Events [MAX_ID_EVENTS];
//==================
//==================
void Init_Events (void)
{
u08 i = 0;
while (i < MAX_ID_EVENTS)
{
Events [i++] = 0;
}
}
bool Get_Event (u08 event)
{
if (Events [event] == 2 || Events [event] == USER_EVENT)
{
Events [event] = 0;
return true;
}
return false;
}
void Set_Event (u08 event, u08 status)
{
if (Events [event] == 0)
Events [event] = status;
}
void Clr_Event (u08 event)
{
Events [event] = 0;
}
void Process_Events (void)
{
u08 i = 0;
while (i < MAX_ID_EVENTS)
{
switch (Events [i])
{
case 0:
break;
case 1:
Events [i] = 2;
break;
case 2:
Events [i] = 0;
break;
}
i++;
}
}
//==================
Спойлер
Код: Выделить всё
#ifndef KBD_DRV_H
#define KBD_DRV_H
#include "kbd_drv.h"
#include "main_def_func.h"
//==================
#define DEBOUNCE_DELAY 20
//==================
//==================
#define KEYS_PIN PINB
#define KEYS_DDR DDRB
#define KEYS_PORT PORTB
//==================
#define KEY_SELECT_MODE_DDR DDRB
#define KEY_SELECT_MODE_PORT PORTB
#define KEY_SELECT_MODE_PIN PINB
#define KEY_SELECT_MODE PB0
//==================
//==================
typedef enum kbd_drv_states
{
KBD_DRV_INIT = 0,
KBD_DRV_NONE,
KBD_DRV_DOWN,
KBD_DRV_WAIT_UP,
KBD_DRV_UP,
} kbd_drv_states;
//==================
//==================
void kbd_drv (void);
bool check_button (void);
//==================
#endif
Спойлер
Код: Выделить всё
//==================
#include "kbd_drv.h"
//==================
//==================
void kbd_drv (void)
{
static kbd_drv_states _kbd_drv;
static soft_timer ST_KBD;
switch (_kbd_drv)
{
case KBD_DRV_INIT:
_kbd_drv = KBD_DRV_NONE;
break;
case KBD_DRV_NONE:
if (check_button ())
{
set_soft_timer (ST_KBD, DEBOUNCE_DELAY, 0);
_kbd_drv = KBD_DRV_DOWN;
}
break;
case KBD_DRV_DOWN:
if (handle_soft_timer (ST_KBD))
{
if (check_button ())
{
Set_Event (EV_ID_KEY_PRESSED, USER_EVENT);
_kbd_drv = KBD_DRV_WAIT_UP;
}
else
_kbd_drv = KBD_DRV_NONE;
}
break;
case KBD_DRV_WAIT_UP:
if (!check_button ())
{
set_soft_timer (ST_KBD, DEBOUNCE_DELAY, 0);
_kbd_drv = KBD_DRV_UP;
}
break;
case KBD_DRV_UP:
if (handle_soft_timer (ST_KBD))
{
if (!check_button ())
{
_kbd_drv = KBD_DRV_NONE;
Set_Event (EV_ID_KEY_UNPRESSED, USER_EVENT);
}
else
_kbd_drv = KBD_DRV_WAIT_UP;
}
break;
default:
break;
}
}
//==================
//==================
#pragma inline = forced
bool check_button (void)
{
return check_bit (KEY_SELECT_MODE_PIN, KEY_SELECT_MODE);
}
//------------------------------------------------------------------------
proc_device.h
Спойлер
Код: Выделить всё
//==================
#ifndef PROC_DEVICE_H
#define PROC_DEVICE_H
#include "proc_device.h"
#include "main_def_func.h"
//==================
//==================
//--------------------------- INPUTS -------------------------------------
//-------------------------- OUTPUTS -------------------------------------
#define OUT_1_PORT PORTD
#define OUT_1_DDR DDRD
#define OUT_1 PD0
#define OUT_1_METHOD OUT_1_PORT
//==================
/*
typedef enum proc_device_states
{
PROC_DEVICE_INIT = 0,
PROC_DEVICE_MODE_1_INIT,
PROC_DEVICE_MODE_1,
PROC_DEVICE_MODE_2_INIT,
PROC_DEVICE_MODE_2,
} proc_device_states;
*/
//==================
void proc_device (void);
void set_proc_out_1_on (void);
void set_proc_out_1_off (void);
bool proc_out_1 (void);
//==================
//==================
void out_1_on (void);
void out_1_off (void);
void out_1_switch (void);
//==================
#endif
Спойлер
Код: Выделить всё
//==================
#include "proc_device.h"
//==================
#define LED_ON_TIME 3 // 3000
#define MINUTE 5 // 60000
#define MINUTES 2 // 90
//==================
void proc_device (void)
{
static u08 _proc_device_main;
static u08 _proc_device_slave;
static u08 minutes;
static soft_timer ST_PROC_DEVICE;
kbd_drv ();
switch (_proc_device_main)
{
case 0:
set_bit (OUT_1_DDR, OUT_1);
case 1:
_proc_device_main = 2; // Настройка первого режима.
_proc_device_slave = 0;
break;
case 2:
if (Get_Event (EV_ID_KEY_PRESSED))
{
set_proc_out_1_off ();
_proc_device_main = 3; // Настройка второго режима.
_proc_device_slave = 0;
return;
}
switch (_proc_device_slave)
{
case 0:
set_proc_out_1_on ();
_proc_device_slave = 1;
break;
case 1:
if (proc_out_1 ())
{
set_soft_timer (ST_PROC_DEVICE, MINUTE, MINUTE);
_proc_device_slave = 2;
}
break;
case 2:
if (handle_soft_timer (ST_PROC_DEVICE))
{
minutes++;
if (minutes > MINUTES)
{
minutes = 0;
_proc_device_slave = 0;
}
}
break;
}
break;
case 3:
if (Get_Event (EV_ID_KEY_PRESSED))
{
set_proc_out_1_off ();
_proc_device_main = 1;
return;
}
// Тут пишете логику второго режима.
break;
}
}
//==================
//==================
static u08 _proc_out_1;
void set_proc_out_1_on (void)
{
_proc_out_1 = 1;
}
void set_proc_out_1_off (void)
{
out_1_off ();
_proc_out_1 = 0;
}
bool proc_out_1 (void)
{
static soft_timer ST_PROC_OUT_1;
switch (_proc_out_1)
{
case 0:
break;
case 1:
out_1_on ();
set_soft_timer (ST_PROC_OUT_1, LED_ON_TIME, 0);
_proc_out_1 = 2;
break;
case 2:
if (handle_soft_timer (ST_PROC_OUT_1))
{
out_1_off ();
_proc_out_1 = 0;
return true;
}
break;
}
return false;
}
//==================
//==================
#pragma inline = forced
void out_1_on (void)
{
set_bit (OUT_1_METHOD, OUT_1);
}
#pragma inline = forced
void out_1_off (void)
{
clr_bit (OUT_1_METHOD, OUT_1);
}
#pragma inline = forced
void out_1_switch (void)
{
switch_bit (OUT_1_METHOD, OUT_1);
}
//==================
