-------------------------------------------------------------------------------------------------------
--
-- University of Heidelberg
-- Kirchhoff Institute for Physics
--
-- Filename:    hamming_enc_dmem.vhd
-- Author:      Falk Lesser
-- Description:
--
--
-- Comment:  Hamming: (2**m-1, 2**m-1-m); allgemein: (n,k)-Codes mit n Bits, k Informationsstellen
--           n-k Pruefstellen. Betrachte: 32 Informationsstellen => m = 6 => (63, 57) Code.
--           Kuerze also Code um 25 Stellen in H-Matrix zu (38, 32) Code.
--
--
--            111111111111111111111111111111110000000000000000000000000000000
--            111111111111111100000000000000001111111111111111000000000000000
--       H =  111111110000000011111111000000001111111100000000111111110000000  streiche die Stellen mit vielen Einsen
--            111100001111000011110000111100001111000011110000111100001111000
--            110011001100110011001100110011001100110011001100110011001100110
--            101010101010101010101010101010101010101010101010101010101010101
--
--
--            new
--            11111100000000000000000000000000|100000
--            00000011111111111111100000000000|010000
--            00000011111111000000011111110000|001000
--            11100011110000111100011110001110|000100
--            10011011001100110011011001101101|000010
--            01010110101010101010110101011011|000001
--
--
--
--   Hamming Bits sind die Spalten der 6x6 Einheitsmatrix (1,2,4,8,16,32). Verknuepfe dabei
--   zeilenweise.
--   d=3 => 2 Bit Fehler erkennen ODER 1 Bit Fehler korregieren.
--   Deshalb verwende falls notwendig Abstand 4 Code oder Parity
--   Konstruktion Abstand 4: kuerze (63,57) Code zu (38,32) und erweitere zu (39,24).
--
--   H''= H|0
--        ---
--        111
--
--
--         11111100000000000000000000000000|1000000
--         00000011111111111111100000000000|0100000
--         00000011111111000000011111110000|0010000
--    H''= 11100011110000111100011110001110|0001000
--         10011011001100110011011001101101|0000100
--         01010110101010101010110101011011|0000010
--         1111111111111111111111111111111111111111
--
--
--
-- History:
-------------------------------------------------------------------------------------------------------
-- Version  |  Author |  Date   |  Changes    |
-------------------------------------------------------------------------------------------------------
--          | lesser  |28.01.02 | made        |
-------------------------------------------------------------------------------------------------------


LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
USE IEEE.std_logic_signed.ALL;

--------------------------------------------------------------------------------------------------------
-- ENTITY
--------------------------------------------------------------------------------------------------------
entity hamming_enc_32d is
    port (
          din            : in  std_logic_vector (31 downto 0);  -- data from the device
          dout           : out std_logic_vector (38 downto 0)   -- data to instr. memory
          );
end hamming_enc_32d;

--------------------------------------------------------------------------------------------------------
-- ARCHITECTURE
--------------------------------------------------------------------------------------------------------
architecture RTL of hamming_enc_32d is

signal h : std_logic_vector (5 downto 0);

begin
  h(0) <=     din( 0) xor din( 1) xor din( 3) xor din( 4)
                xor din( 6) xor din( 8) xor din(10) xor din(11)
                xor din(13) xor din(15) xor din(17) xor din(19)
                xor din(21) xor din(23) xor din(25) xor din(26)
                xor din(28) xor din(30) ;
  h(1) <=     din( 0) xor din( 2) xor din( 3) xor din( 5)
                xor din( 6) xor din( 9) xor din(10) xor din(12)
                xor din(13) xor din(16) xor din(17) xor din(20)
                xor din(21) xor din(24) xor din(25) xor din(27)
                xor din(28) xor din(31) ;
  h(2) <=     din( 1) xor din( 2) xor din( 3) xor din( 7)
                xor din( 8) xor din( 9) xor din(10) xor din(14)
                xor din(15) xor din(16) xor din(17) xor din(22)
                xor din(23) xor din(24) xor din(25) xor din(29)
                xor din(30) xor din(31) ;
  h(3) <=     din( 4) xor din( 5) xor din( 6) xor din( 7)
                xor din( 8) xor din( 9) xor din(10) xor din(18)
                xor din(19) xor din(20) xor din(21) xor din(22)
                xor din(23) xor din(24) xor din(25) ;
  h(4) <=     din(11) xor din(12) xor din(13) xor din(14)
                xor din(15) xor din(16) xor din(17) xor din(18)
                xor din(19) xor din(20) xor din(21) xor din(22)
                xor din(23) xor din(24) xor din(25) ;
  h(5) <=     din(26) xor din(27) xor din(28) xor din(29)
                xor din(30) xor din(31) ;

-- connect the hamming bits
dout(0)  <= h(0);
dout(1)  <= h(1);
dout(3)  <= h(2);
dout(7)  <= h(3);
dout(15) <= h(4);
dout(31) <= h(5);


dout(2) <= din(0); dout(4) <= din(1); dout(5) <= din(2); dout(6) <= din(3); dout(8) <= din(4); dout(9) <= din(5);
dout(10) <= din(6); dout(11) <= din(7); dout(12) <= din(8); dout(13) <= din(9); dout(14) <= din(10); dout(16) <= din(11);
dout(17) <= din(12); dout(18) <= din(13); dout(19) <= din(14); dout(20) <= din(15); dout(21) <= din(16); dout(22) <= din(17);
dout(23) <= din(18); dout(24) <= din(19); dout(25) <= din(20); dout(26) <= din(21); dout(27) <= din(22); dout(28) <= din(23);
dout(29) <= din(24); dout(30) <= din(25); dout(32) <= din(26); dout(33) <= din(27); dout(34) <= din(28); dout(35) <= din(29);
dout(36) <= din(30); dout(37) <= din(31);

-- blow up to hamming distance d=4 and add an other check bit to detect 2-Bit errors
dout(38) <= din(31) xor din(30) xor din(29) xor din(28) xor din(27) xor din(26) xor din(25) xor din(24) xor din(23) xor
            din(22) xor din(21) xor din(20) xor din(19) xor din(18) xor din(17) xor din(16) xor din(15) xor
            din(14) xor din(13) xor din(12) xor din(11) xor din(10) xor din( 9) xor din( 8) xor din( 7) xor
            din( 6) xor din( 5) xor din( 4) xor din( 3) xor din( 2) xor din( 1) xor din( 0) xor h(5) xor h(4) xor h(3) xor
            h(2) xor h(1) xor h(0);

end RTL;