unit CRCUnit;

interface

type
    TByteArray = array of Byte;

    // Вычислитель CRC8
    TCRC8Calc = class
    private
        FValue : Byte;
    public
        constructor Create;
        function Evaluate(B : Byte) : Byte; overload;
        function Evaluate(B : TByteArray) : Byte; overload;
        property CurrentValue : Byte read FValue write FValue;
    end;

    // Вычислитель CRC16
    TCRC16Calc = class
    private
        FValue : Word;
    public
        constructor Create;
        function Evaluate(B : Byte) : Word; overload;
        function Evaluate(B : TByteArray) : Word; overload;
        function Evaluate(B : TByteArray; Position, Count : Integer) : Word; overload;
        property CurrentValue : Word read FValue write FValue;
    end;

implementation

const
    crc8InitValue = $DE;
    crc8tab : array[0..255] of byte = (
        $00, $5E, $BC, $E2, $61, $3F, $DD, $83, $C2, $9C, $7E, $20, $A3, $FD, $1F, $41,
        $9D, $C3, $21, $7F, $FC, $A2, $40, $1E, $5F, $01, $E3, $BD, $3E, $60, $82, $DC,
        $23, $7D, $9F, $C1, $42, $1C, $FE, $A0, $E1, $BF, $5D, $03, $80, $DE, $3C, $62,
        $BE, $E0, $02, $5C, $DF, $81, $63, $3D, $7C, $22, $C0, $9E, $1D, $43, $A1, $FF,
        $46, $18, $FA, $A4, $27, $79, $9B, $C5, $84, $DA, $38, $66, $E5, $BB, $59, $07,
        $DB, $85, $67, $39, $BA, $E4, $06, $58, $19, $47, $A5, $FB, $78, $26, $C4, $9A,
        $65, $3B, $D9, $87, $04, $5A, $B8, $E6, $A7, $F9, $1B, $45, $C6, $98, $7A, $24,
        $F8, $A6, $44, $1A, $99, $C7, $25, $7B, $3A, $64, $86, $D8, $5B, $05, $E7, $B9,
        $8C, $D2, $30, $6E, $ED, $B3, $51, $0F, $4E, $10, $F2, $AC, $2F, $71, $93, $CD,
        $11, $4F, $AD, $F3, $70, $2E, $CC, $92, $D3, $8D, $6F, $31, $B2, $EC, $0E, $50,
        $AF, $F1, $13, $4D, $CE, $90, $72, $2C, $6D, $33, $D1, $8F, $0C, $52, $B0, $EE,
        $32, $6C, $8E, $D0, $53, $0D, $EF, $B1, $F0, $AE, $4C, $12, $91, $CF, $2D, $73,
        $CA, $94, $76, $28, $AB, $F5, $17, $49, $08, $56, $B4, $EA, $69, $37, $D5, $8B,
        $57, $09, $EB, $B5, $36, $68, $8A, $D4, $95, $CB, $29, $77, $F4, $AA, $48, $16,
        $E9, $B7, $55, $0B, $88, $D6, $34, $6A, $2B, $75, $97, $C9, $4A, $14, $F6, $A8,
        $74, $2A, $C8, $96, $15, $4B, $A9, $F7, $B6, $E8, $0A, $54, $D7, $89, $6B, $35
        );
    crc16InitValue = $00DE;
    crc16tab : array[0..255] of Word = (
        $0000, $1189, $2312, $329B, $4624, $57AD, $6536, $74BF,
        $8C48, $9DC1, $AF5A, $BED3, $CA6C, $DBE5, $E97E, $F8F7,
        $1081, $0108, $3393, $221A, $56A5, $472C, $75B7, $643E,
        $9CC9, $8D40, $BFDB, $AE52, $DAED, $CB64, $F9FF, $E876,
        $2102, $308B, $0210, $1399, $6726, $76AF, $4434, $55BD,
        $AD4A, $BCC3, $8E58, $9FD1, $EB6E, $FAE7, $C87C, $D9F5,
        $3183, $200A, $1291, $0318, $77A7, $662E, $54B5, $453C,
        $BDCB, $AC42, $9ED9, $8F50, $FBEF, $EA66, $D8FD, $C974,
        $4204, $538D, $6116, $709F, $0420, $15A9, $2732, $36BB,
        $CE4C, $DFC5, $ED5E, $FCD7, $8868, $99E1, $AB7A, $BAF3,
        $5285, $430C, $7197, $601E, $14A1, $0528, $37B3, $263A,
        $DECD, $CF44, $FDDF, $EC56, $98E9, $8960, $BBFB, $AA72,
        $6306, $728F, $4014, $519D, $2522, $34AB, $0630, $17B9,
        $EF4E, $FEC7, $CC5C, $DDD5, $A96A, $B8E3, $8A78, $9BF1,
        $7387, $620E, $5095, $411C, $35A3, $242A, $16B1, $0738,
        $FFCF, $EE46, $DCDD, $CD54, $B9EB, $A862, $9AF9, $8B70,
        $8408, $9581, $A71A, $B693, $C22C, $D3A5, $E13E, $F0B7,
        $0840, $19C9, $2B52, $3ADB, $4E64, $5FED, $6D76, $7CFF,
        $9489, $8500, $B79B, $A612, $D2AD, $C324, $F1BF, $E036,
        $18C1, $0948, $3BD3, $2A5A, $5EE5, $4F6C, $7DF7, $6C7E,
        $A50A, $B483, $8618, $9791, $E32E, $F2A7, $C03C, $D1B5,
        $2942, $38CB, $0A50, $1BD9, $6F66, $7EEF, $4C74, $5DFD,
        $B58B, $A402, $9699, $8710, $F3AF, $E226, $D0BD, $C134,
        $39C3, $284A, $1AD1, $0B58, $7FE7, $6E6E, $5CF5, $4D7C,
        $C60C, $D785, $E51E, $F497, $8028, $91A1, $A33A, $B2B3,
        $4A44, $5BCD, $6956, $78DF, $0C60, $1DE9, $2F72, $3EFB,
        $D68D, $C704, $F59F, $E416, $90A9, $8120, $B3BB, $A232,
        $5AC5, $4B4C, $79D7, $685E, $1CE1, $0D68, $3FF3, $2E7A,
        $E70E, $F687, $C41C, $D595, $A12A, $B0A3, $8238, $93B1,
        $6B46, $7ACF, $4854, $59DD, $2D62, $3CEB, $0E70, $1FF9,
        $F78F, $E606, $D49D, $C514, $B1AB, $A022, $92B9, $8330,
        $7BC7, $6A4E, $58D5, $495C, $3DE3, $2C6A, $1EF1, $0F78
        );


//==============================================================================
{ TCRC8Calc }

constructor TCRC8Calc.Create;
begin
    FValue := crc8InitValue;
end;
//------------------------------------------------------------------------------

function TCRC8Calc.Evaluate(B : Byte) : Byte;
begin
    FValue := crc8tab[FValue xor B];
    Result := FValue;
end;
//------------------------------------------------------------------------------

function TCRC8Calc.Evaluate(B : TByteArray) : Byte;
var
    i : Integer;
begin
    for i := Low(B) to High(B) do
        Evaluate(B[i]);
    Result := FValue;
end;
//==============================================================================
{ TCRC16Calc }

constructor TCRC16Calc.Create;
begin
    FValue := crc16InitValue;
end;
//------------------------------------------------------------------------------

function TCRC16Calc.Evaluate(B : Byte) : Word;
begin
    FValue := crc16tab[Byte(FValue) xor B] xor Byte(FValue shr 8);
    Result := FValue;
end;
//------------------------------------------------------------------------------

function TCRC16Calc.Evaluate(B : TByteArray) : Word;
var
    i : Integer;
begin
    for i := Low(B) to High(B) do
        Evaluate(B[i]);
    Result := FValue;
end;
//------------------------------------------------------------------------------

function TCRC16Calc.Evaluate(B : TByteArray; Position, Count : Integer) : Word;
var
    i : Integer;
begin
    for i := 0 to Count - 1 do
        Evaluate(B[i + Position]);
    Result := FValue;
end;
//==============================================================================
end.

typedef TFilterIn ...;   // входной объект для фильтра
typedef TFilterOut ...;  // выходной объект фильтра

class TFilter
{
public:
   TFilter();    // конструктор по умолчанию, создает объект фильтра с параметрами по умолчанию
   TFilter(...); // 1-й конструктор с параметрами - создает объект фильтра с какими-то спец. свойствами
    ...
   TFilter(...); N- й конструктор с параметрами - создает объект фильтра с какими-то спец. свойствами

    void in(TFilterIn x); // принимает объект для фильтрации
    TFilterOut out();     // отдает результат фильтрации  
    void execute();       // выполняет собственно фильтрацию


private:
   ...
}

TFilterOut execute(TFilterIn);

TFilter Filter;
TFilterIn fi = ...;
...
TFilterOut fo = Filter << fi;

// регистровые переменные для работы прерывания системного таймера

register BYTE ADCL_            asm("r2");
register BYTE ADCH_            asm("r3");
register BYTE ADMUX_           asm("r4");
register BYTE ADCSRA_          asm("r5");
register BYTE SYSTICKSTART_    asm("r6");
register BYTE PINB_            asm("r7");
register BYTE PINC_            asm("r8");
register BYTE PIND_            asm("r9");

//-------------------------------------------------------------------
// Прерывание системного таймера
//   используются только регистровые переменные
//   никакие регистры не сохраняются
//   SREG не сохраняется
//-------------------------------------------------------------------

void TIMER2_COMP_vect(void) __attribute__((signal)) __attribute__((naked));
void TIMER2_COMP_vect()
{
  ADCL_  = ADCL;       // читаем результат последнего преобразования
  ADCH_  = ADCH;
  ADMUX  = ADMUX_;     // новый канал
  ADCSRA = ADCSRA_;    // запускаем новое преобразование
                       // информируем о начале нового цикла
  SYSTICKSTART_= ADCSRA_;     // записью значения ADCSRA в SYSTICKSTART_
                              // сбрасывается в 0 в основном цикле
  PINB_  = PINB;       // читаем порты
  PINC_  = PINC;
  PIND_  = PIND;
  __asm__ __volatile__ ("reti" ::);  // выходим
}

//------------------------------------------------------------------------------
class TUartCmd
{
public:
    TUartCmd(byte Baud_rate)
    {
        UBRR = Baud_rate;
        SetBits(UCR, ( (1 << RxEnable) | (1 << TxEnable)) );
        enableRxInt();
        Cmd = &fptrUartCmd;
        MaxCmdCode = 3;
    }

    enum TBlockCode
    {
        bcMsg,
        bcRead,
        bcWrite,
        bcLogOp,
        bcUser,
        bcDataFlash
    };

    static bool send(const byte* ptr, const byte count, TBlockCode block_code = bcUser);
    static void mgr();

private:
    #pragma vector = UART_UDRE_vect
    static __interrupt void UART_UDRE_interrupt();

    #pragma vector = UART_RX_vect
    static __interrupt void UART_Rx_interrupt();


    static __monitor byte lockUDREInt(); //  { byte ucr = TUartCmd::Control_Reg; disableUDREInt(); return ucr; }
    static __monitor void unlockUDREInt(byte ucr); // { TUartCmd::Control_Reg = ucr; }

protected:
    static byte IsFrameError()   { return USR & FrameError; }
    static byte IsOverRun()      { return USR & Rx_OverRun; }
    static byte IsUartRxErrors() { return USR & (Rx_OverRun | FrameError); }
    static void resetRx();

    static void msg(byte* ptr, byte count);
    static void read(byte* ptr, byte count);
    static void write(byte* ptr, byte count);
    static void log_op(byte* ptr, byte count);

protected:
    static void (*__flash(*Cmd)[])(byte* ptr, byte count);
    static byte MaxCmdCode;

private:
    static struct Flags
    {
        bool RxTimeout  : 1;
    } status;
    static __flash void (*fptrUartCmd[])(byte* ptr, byte count);

    static byte   RxTimer;
    static byte   RxBuf[C_BufferSize];
    static byte   RxIndex;
    static byte   TxBuf[C_BufferSize];
    static TCbuf  Tx;


private:
    enum
    {
        Rx_OverRun    = (1 << 0),
        Rx_FrameError = (1 << 1),
        Rx_BufOverRun = (1 << 2)
    };

    enum UART_Status_Register_Bits
    {
        RxComplete = 7,
        TxComplete = 6,
        UDREmpty   = 5,
        FrameError = 4,
        Overrun    = 3
    };

    enum UART_Control_Register_Bits
    {
        RxCompleteIE = 7,
        TxCompleteIE = 6,
        UDREmptyIE   = 5,
        RxEnable     = 4,
        TxEnable     = 3,
        Char9        = 2,
        RxBit8       = 1,
        TxBit8       = 0
    };

    enum TOpCodes
    {
        opcodeAND,
        opcodeOR,
        opcodeXOR
    };
};
//------------------------------------------------------------------------------
__interrupt void  TUartCmd::UART_UDRE_interrupt()
{
    if(TUartCmd::Tx.get_count())
    {
        UDR = TUartCmd::Tx.get();
    }
    else
        disableUDREInt();
}
//------------------------------------------------------------------------------
__interrupt void  TUartCmd::UART_Rx_interrupt()
{
    byte Symbol = UDR;
    //__enable_interrupt();

    if(IsUartRxErrors())
    {
        resetRx();
        return;
    }

    byte t = get_system_tick();
    byte dt = t - RxTimer;

    if(RxIndex)
    {
        if(dt > C_MaxRxSymbolTransferTime)
        {
            resetRx();
            return;
        }
    }

    RxTimer = t;
    RxBuf[RxIndex++] = Symbol;

    byte header = RxBuf[0];
    byte size   = (header & 0x0f) + 2;

    if(size == RxIndex)
    {
        byte code = header >> 4;

        RxIndex = 0;
        if(get_checksum(RxBuf, size))
        {
            resetRx();
            return;
        }

        if(code == 7) code = TUartCmd::bcUser; // patch
        if(code > TUartCmd::MaxCmdCode) return;

        (*(*TUartCmd::Cmd)[code])(RxBuf+1, size-2);
    }
}
//------------------------------------------------------------------------------

class TUartCmdUsr : public TUartCmd
{
public:
    TUartCmdUsr(byte Baud_rate) : TUartCmd(Baud_rate)
    {
        Cmd = &fptrUartCmd;
        MaxCmdCode = 4;
    }
    static void user(byte* ptr, byte count);

private:
    static __flash void (*fptrUartCmd[])(byte* ptr, byte count);
};

#include "setjmp.h"

#define    CONTEXT_SWT_vect SPM_RDY_vect

#pragma vector=CONTEXT_SWT_vect
__interrupt void CNTX_SWT(void);

#define IN_CSWT ACSR_ACIS1

jmp_buf main_task;
jmp_buf rs_task;
char rs_rstack[8];
char rs_cstack[64];

char rxbuf[16];

#pragma vector=USART0_RXC_vect
__interrupt __raw void rs_rx(void)
{
  UCSR0B_RXCIE0=0;
  if (!IN_CSWT)
  {
    IN_CSWT=1;
    __enable_interrupt();
    ((void(*)(void))CNTX_SWT)();
    __disable_interrupt();
    IN_CSWT=0;
  }
}

#pragma vector=USART0_UDRE_vect
__interrupt __raw void rs_tx(void)
{
  UCSR0B_UDRIE0=0;  //Запретили прерывания
  if (!IN_CSWT)
  {
    IN_CSWT=1;
    __enable_interrupt();
    ((void(*)(void))CNTX_SWT)();
    __disable_interrupt();
    IN_CSWT=0;
  }
}

#pragma vector=USART0_TXC_vect
__interrupt __raw void rs_txc(void)
{
  //UCSR0A=1<<TXC0; //Сбросили флаг
  if (!IN_CSWT)
  {
    IN_CSWT=1;
    __enable_interrupt();
    ((void(*)(void))CNTX_SWT)();
    __disable_interrupt();
    IN_CSWT=0;
  }
}

#pragma vector=TIMER1_OVF_vect
__interrupt __raw void rs_timeout(void)
{
  UCSR0B_RXCIE0=0; //Запретили прерывания от приемника
  if (!IN_CSWT)
  {
    IN_CSWT=1;
    __enable_interrupt();
    ((void(*)(void))CNTX_SWT)();
    __disable_interrupt();
    IN_CSWT=0;
  }
}

#pragma vector=CONTEXT_SWT_vect
__interrupt void CNTX_SWT(void)
{
  if (!setjmp(main_task)) //Запомнили контекст осн. задачи
  {
    longjmp(rs_task,1); //Перешли в контекст RS_TRX
  }
}

void wait_int()
{
  if (!setjmp(rs_task)) //Запомнили контекст RS_TASK
  {
    longjmp(main_task,1); //Перешли в контекст осн. задачи
  }
}

char rxbuf[16];

//txsize - количество байт без контрольной суммы
__x char DO_RS(char *out, char txsize, char n_rs, char CRC8RX)
{
  char CRC8;
  char c;
  char rxerr=0;
  UCSR0A=1<<TXC0; //Сбросили флаг от предыдущего прерывания
  CRC8=CRC8tab[c=(*out++)]; //ПУ всегда начинает с нуля
  __disable_interrupt();
  UDR0=c;
  while(PINE_Bit1); //Ждем начала стартового бита
  if (n_rs) EnaTX2; else EnaTX0; //Разрешаем передатчик
  __enable_interrupt();
  while(--txsize)
  {
    CRC8=CRC8tab[CRC8^(UDR0=(*out++))];
    UCSR0B_UDRIE0=1; //Разрешили прерывания от UDRIE
    wait_int(); //Ждем освобождения буфера
  }
  UDR0=CRC8;
  UCSR0B_TXCIE0=1; //Разрешили прерывание от TXC
  wait_int(); //Байт контрольной суммы - последний байт
  UCSR0B_TXCIE0=0; //Запретили прерывания от TXC
  DisTX2; //Выключили каналы передачи
  DisTX0;
  if (n_rs) EnaRX2; else EnaRX0; //Разрешили приемник (пока только на драйвере)
  TCNT1=Time1000;
  TIFR=1<<(TOV1);
  TIMSK_TOIE1=1; //Разрешили прерывание от таймера
  wait_int(); //Ждем 1 мс пока переходные процессы
  UCSR0B_RXEN0=1; //Разрешили приемник
  //txsize здесь равен 0
  CRC8RX=CRC8tab[CRC8RX]; //Нач. значение
  out=rxbuf;
  TCNT1=Time2200; //Время ожидания первого байта
  for(;;)
  {
    UCSR0B_RXCIE0=1; //Разрешили прерывания от приемника
    wait_int();
    if (!UCSR0A_RXC0)
    {
      //Выход по таймауту
      if (CRC8RX) txsize=0; //Не срослась контрольная сумма
      break; //Выходим из цикла
    }
    //Приняли байт
    if (UCSR0A_FE0||UCSR0A_DOR0)
    {
      rxerr=1; //Ошибки
    }
    c=UDR0;
    if (txsize<sizeof(rxbuf))
    {
      CRC8RX=CRC8tab[CRC8RX^(*out=c)]; // Читаем принятый байт в буфер приема и перерасчет CRC
      txsize++;
      out++;
    }
    else
    {
      rxerr=1; //Слишком много байт
      break;
    }
    TCNT1=Time1600;
  }
  UCSR0B_RXEN0=0; //Запретили приемник
  TIMSK_TOIE1=0; //Запретили таймер
  DisRX0;
  DisRX2;
  if (rxerr) txsize=0;
  return(txsize); //Количество принятых байт, если 0 - нет ответа
}


__task __noreturn RS_TRX(void)
{
  struct
  {
    char PPKP;
    char Cmd;
  };
  char abon=0;
  char c;
  char CurRS=0;
  for(;;)
  {
    c=DO_RS(&PPKP,1,CurRS,abon);
    switch(c)
    {
    case 4:
      //Есть событие
      //Записываем событие в стек
      Event2FIFO(abon,rxbuf[1],rxbuf[2],0);
    case 2:
      //Нет события
      //.......
      break;
    default:
      //Ошибка
      //.............
      break;
    }
    if (!(abon=(abon+1)&0x7F))
    {
      CurRS^=1;
    }
  }
}
    
void InitRS(void)
{
  __disable_interrupt();
  DDRE=0xFE;
  PORTE=0xFF;
  UBRR0L=25;
  UCSR0B_TXEN0=1; //Разрешили передатчик
  TCCR1B=2;
  ((unsigned int *)rs_task)[10]=((unsigned int)rs_rstack)+7; //SP
  ((unsigned int *)rs_task)[8]=((unsigned int)rs_cstack)+64; //Y
  ((unsigned int *)rs_task)[9]=(unsigned int)RS_TRX; //Адрес перехода
  if (!setjmp(main_task)) longjmp(rs_task,1); //Переходим в RS_TRX
  __enable_interrupt();
}

typedef struct _TCanalData
{
       ..........
} TCanalData;

byte canal_getByteForSend(TCanalData *pData);
void canal_onByteRecieved(TCanalData *pData, byte dt);

while(--txsize)
{
   CRC8=CRC8tab[CRC8^(UDR0=(*out++))];
   UCSR0B_UDRIE0=1; //Разрешили прерывания от UDRIE
   wait_int(); //Ждем освобождения буфера
}

char r=3;
do
{
c=DO_RS(&PPKP,1,CurRS,abon);
if ((c!=4)||(c!=2)) break; //Ну или другое условие проверим
}
while(--c);