Блокирующие и неблокирующие присваивания в Verilog

Вкратце: модуль принимает сигнал, отсчитывает задержку, и выдаёт последовательным кодом заранее заготовленные значения из массива с добавлением стартового и стопового битов. Опишем входы/выходы:

module UartTX(

iClk80, iReq,

oTX, oDirTX, oDirRX);

input iClk80, iReq;

output reg oDirTX, oDirRX, oTX;

Опишем вспомогательные переменные:

reg tmpReq, tx;
reg [5:0] delay = 0;
reg [3:0] cntBit = 0;
reg [3:0] cntArr = 0;
reg [4:0] cntClk = 0;
reg [7:0] reqArr [13:0]; //На самом деле массив наполняется из входящих шин, не важно
reg [7:0] elem = 0;

Ну и дадим знать ПЛИС, что должно происходить.

always@(posedge iClk80)

begin
Для начала поделим тактовую частоту, чтобы из входящей получить частоту передачи:
cntClk = cntClk + 1'b1;
if (cntClk == 16) begin 
cntClk = 0;
Найдём фронт сигнала о передаче
if (tmpReq == 1 && iReq == 0)tx = 1;
tmpReq = iReq;
и, собственно, начнём: где-то там, внизу, создадим счётчик, который будет у нас управлять задержкой и временем передачи, а основную работу будем выполнять в виде конечного автомата:
if (tx == 1) begin
case (delay)
5: oDirRX <= 1; //отключили приём
10: oDirTX <= 1; //включили передачу
25: begin
delay = 24; //отменили увеличение задержки
case (cntBit)
0: oTX <= 0;
1,2,3,4,5,6,7,8: begin
elem = reqArr[cntArr];
oTX <= elem[cntBit-1];
end
9: oTX <= 1;
endcase
cntBit = cntBit + 1'b1;
if (cntBit==10) begin //перебрали 10 бит передаваемых данных
cntBit = 0;
cntArr = cntArr + 1'b1;
if (cntArr == 14) begin //перебрали 14 элементов массива
cntArr = 0;
delay = delay + 1'b1; //продолжаем считать задержку
end
end
end
40: oDirTX <= 0; //отключили передачу
45: oDirRX <= 0; //включили приём
endcase;
delay = delay + 1'b1;
if (delay == 50) begin
delay = 0; //закончили считать
tx <= 0; //до следующего сигнала забыли об этом блоке
end;
end
end
end
endmodule
А теперь, самое интересное. Выдача последовательным кодом и добавление стартового-стопового битов происходит непосредственно в этом маленьком кейсе:
case (cntBit)
0: oTX <= 0;
1,2,3,4,5,6,7,8: begin
elem = reqArr[cntArr];
oTX <= elem[cntBit-1];
end
9: oTX <= 1;
endcase
При присвоении регистру elem значения при помощи блокирующего присваивания, на выходе получаем ровную картинку значений 1,2,3,4,5,6,7,8,9,10,11,12,13,14. Все танцуют. Но если ту-же строку записать

elem <= reqArr[cntArr];

Картинка на выходе получается весьма прискорбной: 1,3,2,5,4,7,6,9,8,11,10,13,12,14. Как видно, после первой итерации, переменной присваивается следующее нечётное значение, затем предшествующее ему, затем следующее нечётное, затем ситуация повторяется. 

Поймать-то я это поймал, а объяснить пока-что не могу...