Hey Guys 

I have been working on a key creator module for an encryption algorithm. Which uses a simple state machine to count to ten rounds of encryption. The IF statement in the state machine for the load signal, when this is always a one i get ten outputs of encrypted data but, when its just 1 for a clock cycle i get 40 outputs any guidance here guys would be great. i have included the code for the state machine and a key creator module that is been used.  I have also included a WVF file that shows the output values when load is one, Thanks guys.

 ControllingStateMachine: process(CLOCK)

begin

if rising_edge(CLOCK) then

--sets the round value to 11 so it will reset the counter.

if RESET = '1' then

RoundNum <= x"a" & "01";

else

--if it is round eleven then reset the round counter.

if RoundNum = (x"a" & "01") then

if LOAD = '1' then

RoundNum <= "000000";

end if;

--if the round number is not equal 11 then increment the counter

elsif RoundNum /= (x"a" & "01") then

RoundNum <= RoundNum + '1';

end if;

end if;

end if;

KEYCreator: process(CLOCK)

begin

if rising_edge(CLOCK) then

if load = '1' then

--if its the first round then populate the variable word with the user defined key.

Word32(0) <= KEY_IN(127 downto 96);

Word32(1) <= KEY_IN(95 downto 64);

Word32(2) <= KEY_IN(63 downto 32);

Word32(3) <= KEY_IN(31 downto 0);

--else if its any other round less than 10 populate word with the new value caculated

elsif RoundNum < (x"a" & "00") 

then

Word32 <= Word32(1 to 3) & (Word32(0) xor NewWord);

end if;

end if;

end process;

--Routine word is a one byte left circular shift 

RoutineWord <= Word32(3)(23 downto 0) & Word32(3)(31 downto 24);

NewBytesFORKey: for k in 0 to 3 generate

--instead of using  seperate module called sbox creating an array/look up table(LUT) populating it accordingly

--makes for easier coding. The sbox array is filled with the specified values from the AES look up table.

type sboxKey is array(0 to 255) of std_logic_vector(7 downto 0);

constant KeySub : sboxKey :=(

x"63", x"7c", x"77", x"7b", x"f2", x"6b", x"6f", x"c5", x"30", x"01", x"67", x"2b", x"fe", x"d7", x"ab", x"76",

x"ca", x"82", x"c9", x"7d", x"fa", x"59", x"47", x"f0", x"ad", x"d4", x"a2", x"af", x"9c", x"a4", x"72", x"c0",

x"b7", x"fd", x"93", x"26", x"36", x"3f", x"f7", x"cc", x"34", x"a5", x"e5", x"f1", x"71", x"d8", x"31", x"15",

x"04", x"c7", x"23", x"c3", x"18", x"96", x"05", x"9a", x"07", x"12", x"80", x"e2", x"eb", x"27", x"b2", x"75",

x"09", x"83", x"2c", x"1a", x"1b", x"6e", x"5a", x"a0", x"52", x"3b", x"d6", x"b3", x"29", x"e3", x"2f", x"84",

x"53", x"d1", x"00", x"ed", x"20", x"fc", x"b1", x"5b", x"6a", x"cb", x"be", x"39", x"4a", x"4c", x"58", x"cf",

x"d0", x"ef", x"aa", x"fb", x"43", x"4d", x"33", x"85", x"45", x"f9", x"02", x"7f", x"50", x"3c", x"9f", x"a8",

x"51", x"a3", x"40", x"8f", x"92", x"9d", x"38", x"f5", x"bc", x"b6", x"da", x"21", x"10", x"ff", x"f3", x"d2",

x"cd", x"0c", x"13", x"ec", x"5f", x"97", x"44", x"17", x"c4", x"a7", x"7e", x"3d", x"64", x"5d", x"19", x"73",

x"60", x"81", x"4f", x"dc", x"22", x"2a", x"90", x"88", x"46", x"ee", x"b8", x"14", x"de", x"5e", x"0b", x"db",

x"e0", x"32", x"3a", x"0a", x"49", x"06", x"24", x"5c", x"c2", x"d3", x"ac", x"62", x"91", x"95", x"e4", x"79",

x"e7", x"c8", x"37", x"6d", x"8d", x"d5", x"4e", x"a9", x"6c", x"56", x"f4", x"ea", x"65", x"7a", x"ae", x"08",

x"ba", x"78", x"25", x"2e", x"1c", x"a6", x"b4", x"c6", x"e8", x"dd", x"74", x"1f", x"4b", x"bd", x"8b", x"8a",

x"70", x"3e", x"b5", x"66", x"48", x"03", x"f6", x"0e", x"61", x"35", x"57", x"b9", x"86", x"c1", x"1d", x"9e",

x"e1", x"f8", x"98", x"11", x"69", x"d9", x"8e", x"94", x"9b", x"1e", x"87", x"e9", x"ce", x"55", x"28", x"df",

x"8c", x"a1", x"89", x"0d", x"bf", x"e6", x"42", x"68", x"41", x"99", x"2d", x"0f", x"b0", x"54", x"bb", x"16");

begin

--The subroutineword variable is filled with the new values derived from the sbox array

SubRoutineWord(8*(k+1)-1 downto 8*k) <= KeySub(conv_integer(RoutineWord(8*(k+1)-1 downto 8*k)));

end generate;

--The subroutine word is the XORed with the round constant value corresponding to the ongoing round. These round constants are uses

-- to get rid of any simularities created by the exspansion process. There must be zeros for 3 of the least significant bits.

NewWord <= SubRoutineWord xor (RoundConstantV(conv_integer(RoundNum(5 downto 2))) & x"000000") when RoundNum(1 downto 0) = "00" 

else

--else it is XORed with the populated word32(3) as can be seen above the lut.

Word32(3);

--The new key value is created which is the 4 words concantanated together to create the 128-bit output for the next module

NewKey <= Word32(0) & Word32(1) & Word32(2) & Word32(3);

An immediate suggestion, make Roundnum an integer.  You seem to be almost exclusively performing integer operations on it (assignment, addition) and the code is (to my thinking) much easier to read.

For example, you don't need a comment saying what's happening here:

--sets the round value to 11 so it will reset the counter.
if RESET = '1' then
  RoundNum <= x"a" & "01";

if you write this, it's self explanatory.

RoundNum <= 11;

Also, I'm not sure what you are trying to achieve with

  RoundNum <= x"a" & "01";

It looks like you might be trying to AND 0xA (bits "1010") and the bits "01"?  The & operator doesn't do this, it concatenates two values, so Roundnum ends up being 101001.

As to any further problems, that's a lot of code to ask people to volunteer to review.  I would suggest simplifying it to the bare problem (we don't need to see all the sbox stuff for example).  I often find that reducing the problem to it's basis is quite a good way of guiding myself to a solution :)  Also, explain in detail what you expect to see and what you actually see.  We are not familiar with your system, so just looking at a screenshot it's often not easy to see what is unexpected.

You have essentially answered my question! That was the issue I have simply now entered the binary equivalent values and the issue has been sorted. Something so simple!! Thank you!!