PROGRAM CRC32


VAR_EXTERNAL
             (* LICZBA PODANA PRZEZ UZYTKOWNIKA *)
    wynik_CRC : DWORD;      (* WYNIK KONCOWY CRC32 *)
    start : BOOL;

    wejscie : UINT;
    wejscie2 : UINT;
    wejscie3 : UINT;
    wejscie4 : UINT;
    wejscie5 : UINT;
    dlugosc : INT;

    UINTwejscie : UINT;
    temp : UDINT;
    temp2 : UDINT;
    tempDL : INT;
    temp4 : UDINT;
    temp3 : UDINT;
    temp5 : UDINT;



END_VAR

VAR
    i : int := 0;           (* DO OBSLUGI GLOWNEJ PETLI *)
    j : int;                (* DO OBSLUGI PETLI FOR *)
    k : int := 0;
    crc : DWORD;             (* DO CIAGLEGO OBLICZANIA CRC *)
    bajt : DWORD;            (* DO OPEROWANIA NA ZNAKU W PETLI *)
    obliczana :  DWORD;      (* DO ZAMIANY BITOW NA ZNAK ASCII *)

    obliczana2 : DWORD;
    obliczana3 : DWORD;
    obliczana4 : DWORD;
    obliczana5 : DWORD;

    UINT_na_STR32 : str32;   (* DO KONWERSJI NA DWORD *)
    UINT_na_STR32_2 : str32; (* DO KONWERSJI NA DWORD *)
    DWORD_na_UDINT : UDINT;

    xor_crc_bajt : DWORD;    (* PRZECHOWUJE WYNIK XOR(crc,bajt) *)
    warunek_if : DINT;       (* DO ZAPISANIA WYNIKU XOR(crc,bajt) I KONWERSJI NA DINT *)

    F1: ARRAY [1..5] OF UDINT := [3];
    dziesiec : UDINT := 10;
    UDINTwejscie : UDINT;
    konwersja : UDINT;


END_VAR

konwersja := TO_UD(wejscie);
F1[1] := konwersja;
konwersja := TO_UD(wejscie2);
F1[2] := konwersja;
konwersja := TO_UD(wejscie3);
F1[3] := konwersja;
konwersja := TO_UD(wejscie4);
F1[4] := konwersja;
konwersja := TO_UD(wejscie5);
F1[5] := konwersja;


IF start THEN

       temp4 := F1[4];
       temp5 := F1[5];
       temp3 := F1[3];
       temp2 := F1[2];
       temp :=  F1[1];
       tempDL := dlugosc;


    (* INICJALIZUJE ZMIENNE PETLI FOR ORAZ CRC *)
    j := 0;
    crc := 4294967295;

FOR j := 1 TO dlugosc BY 1 DO
     (* KONWERTUJE UINT NA STR32 A POTEM NA DWORD *)
     UINT_na_STR32 := TO_STR32(F1[j]);
     obliczana := TO_DW(UINT_na_STR32);



     (* ZAMIANA LICZBY NA ASCII *)
CASE obliczana OF
    1: obliczana := 49;
    2: obliczana := 50;
    3: obliczana := 51;
    4: obliczana := 52;
    5: obliczana := 53;
    6: obliczana := 54;
    7: obliczana := 55;
    8: obliczana := 56;
    9: obliczana := 57;
    0: obliczana := 48;
END_CASE;
    DWORD_na_UDINT := TO_UD(obliczana);
    F1[j] := DWORD_na_UDINT;
    (* KONIEC ZAMIANY ZNAKOW *)
END_FOR;

FOR k := 1 TO dlugosc BY 1 DO
    (* ODWRACANIE BITOW, NIE ZNASZ NIE OCENIAJ, LAWIEJ SIE NIE DA :) *)
        bajt := TO_DW(F1[k]);

        bajt := (SHL(bajt AND 16#55555555)) OR (SHR(bajt) AND 16#55555555);
        bajt := SHL(SHL(bajt AND 16#33333333)) OR ( SHR(SHR(bajt)) AND 16#33333333 );
        bajt := SHL(SHL(SHL(SHL(bajt AND 16#0F0F0F0F)))) OR ( SHR(SHR(SHR(SHR(bajt)))) AND 16#0F0F0F0F);
        bajt := ( SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(bajt)))))))))))))))))))))))) ) OR
           ( SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(bajt AND 16#FF00)))))))) ) OR
           ( SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(bajt)))))))) AND 16#FF00 ) OR
           ( SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(bajt)))))))))))))))))))))))) );
    (* KONIEC ODWRACANIE BITOW *)

    (* WYKONUJE OPERACJE W PETLI NA ZNAKU *)
    FOR j := 0 TO 7 BY 1 DO

        xor_crc_bajt := XOR(crc,bajt);            (* OBLICZAM XOR CRC I ZNAKU *)
        warunek_if := TO_DI(xor_crc_bajt);        (* KONWERSJA UINT DO DINT *)

        IF warunek_if < 0  THEN               (* SPRAWDZAM CZY (int)(xor(crc,bajt) JEST < 0) *)
            crc := XOR(SHL(crc),16#04C11DB7); (* PRZESUNIECIE XOR W LEWO i xor(crc,16#...) *)
        ELSE
            crc := SHL(crc);                  (* PRZESUWAM CRC W LEWO *)
        END_IF;

        bajt := SHL(bajt);                    (* PRZESUWAM ZNAK W LEWO *)
    END_FOR;
    (*KONIEC PETLI FOR *)
END_FOR;

    (* NEGACJA CRC *)
     crc :=  NOT crc;

    (* ODWRACNIE BITOW CRC *)
     crc := (SHL(crc AND 16#55555555)) OR (SHR(crc) AND 16#55555555);
     crc := SHL(SHL(crc AND 16#33333333)) OR ( SHR(SHR(crc)) AND 16#33333333 );
     crc := SHL(SHL(SHL(SHL(crc AND 16#0F0F0F0F)))) OR ( SHR(SHR(SHR(SHR(crc)))) AND 16#0F0F0F0F);
     crc := ( SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(crc)))))))))))))))))))))))) ) OR
            ( SHL(SHL(SHL(SHL(SHL(SHL(SHL(SHL(crc AND 16#FF00)))))))) ) OR
            ( SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(crc)))))))) AND 16#FF00 ) OR
            ( SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(SHR(crc)))))))))))))))))))))))) );
    (* KONIEC ODWRACANIA BITOW CRC *)

    (* ZAPISUJE CRC DO ZMIENNEJ WYNIKOWEJ EXTERNAL *)
     wynik_CRC := crc;
ELSE;
END_IF;
END_PROGRAM