После того, как Я реализовал битовый контроллер I2C Master — уж очень чесались руки опробовать его в реальной задаче. Теперь можно начинать строить уровни абстракции от манипуляции отдельными битами и уже формировать полноценные транзакции, которые приводят к какому-либо действию с подчиненным устройством. Я подумал, что было бы классно сделать такую проверку своего автомата во взаимодействии с простейшей I2C 2K-bit EEPROM.

Идея простая — читаем и записываем данные по нажатию клавиш на одной из отладок с Cyclone IV, которые я рассматривал в одном из своих обзоров.

Если материал вам кажется интересным — добро пожаловать, с удовольствием и в свойственной мне манере расскажу, чего мне удалось добиться, а чего не удалось. ????

Дисклеймер. Перед началом повествования, хотелось бы заранее оговориться, что основная цель, которую я преследую при написании этой статьи — рассказать о своем опыте. Я не являюсь профессиональным разработчиком под ПЛИС на языке Verilog и могу допускать какие-либо ошибки в использовании терминологии, использовать не самые оптимальные пути решения задач, etc. Но отмечу, что любая конструктивная и аргументированная критика только приветствуется. Что ж, поехали…

❯ Давайте для начала определимся с общей идеей

Первым шагом нужно определиться, к чему стремимся и чего хотим в итоге получить.

В первую очередь нужно будет подключить к отладке плату с несколькими кнопками и сделать обработку входящих сигналов с антидребезгом. Каждая из кнопок должна будет выполнять свою функцию.

Вывод всех данных будет осуществляться на 7-сегментный индикатор с 8 разрядами который установлен на отладку. Поэтому нужно будет написать соответствующий драйвер для вывода информации на этот индикатор.

Необходимо также выводить ACK-сигнал на плату, чтобы увидеть что транзакция выполнена успешно.

Раз мы хотим организовать общение с EEPROM — то:

1. Первой клавишей будет активировано действие на чтение данных из ячейки с заданным адресом и вывод прочитанных данных на семисегментный дисплей;
2. Вторая клавиша будет производить запись выбранного значения в заданную ячейку памяти;
3. Третья клавиша будет предназначена для инкремента значения текущего адреса памяти EEPROM в который будет произведена запись значения в диапазоне от 0x00 до 0xFF, ну или чтение;
4. Четвертая клавиша будет декрементировать значение адреса памяти;
5. Пятая клавиша будет предназначена для инкремента значения полезных данных, которые будут записаны в выбранный адрес ячейки памяти;
6. Шестая, соответственно, будет декрементировать это значение;
7. На плате клавиша RESET будет отвечать за асинхронный сброс.

Выглядит как набор небольших задач, при выполнении которых получится то что нужно. Поехали.

❯ Что необходимо для выполнения задачи?

Итак, для реализации задачи понадобится:

1. Отладочная плата Saylinx с Cyclone IV, которую я обозревал в этой статье. Она подходит для моей цели как раз потому что на плате есть EEPROM и семисегментный индикатор;
2. Программатор Altera USB Blaster для прошивки платы и отладки;
3. На плате понадобится семисегментный индикатор. У индикатора есть 8 разрядов, первые два из которых мы задействуем под указание того, какой адрес памяти сейчас выбран, третий и четвертый — под выбор полезных данных для записи в ячейку, пятый и шестой — под вывод считанных данных из EEPROM;
4. На плате должен быть EEPROM. И он там есть ????;
5. Платка с кнопками и соединительными проводками для PLS-гребенки, потому что на отладке их не так много как хочется;
6. Логический анализатор, типа какого-нибудь DSLogic Basic и программа DSView (можно найти на Али). Он понадобится также для наблюдения за транзакциями в реальном железе.

Плюсом к этому потребуется, конечно же рабочий HDL-код для описания цифровой схемы, которая позволит реализовать желаемое. Ну что ж, давайте попробуем сделать задумку!)

❯ Шаг нулевой. Создаем проект и размечаем пины

Этот шаг я описывать отдельно не буду, думаю вы уже научились из прошлых статей создавать новый проект и добавлять в него новые файлы. После этого необходимо добавить Top-Level Design File и указать его в настройках проекта.

Следующий подготовительный этап — создать главный модуль и определить входные и выходные сигналы:

module top_module 
	(
		input		clk_i,		// Входной сигнал для тактирования
		input		rstn_i,		// Входной сигнал для сброса, 0 - сброс
		
		input	[2:0] btn_main_i,	// Входной сигнал от кнопок на плате
		input	[5:0] btn_brd_i,	// Входные сигналы от платы с кнопками
		output	[3:0] led_brd_o,	// Выходные сигналы для светодиодов
			
		output	[5:0] seg_sel_o,	// Выбор активного разряда семисегментного дисплея
		output	[7:0] seg_data_o,	// Данные для отображения на семисегментном дисплее
		
		inout		sda_io,		// Линия I2C SDA
		output		scl_io		// Линия I2C SCL		
	);

endmodule

После этого можно сразу обозначить пины, которые будут передавать эти сигналы, чтобы не возвращаться к этому вопросу. Для этого необходимо открыть схематик платы и определить пины, к которым подключено то, что нам нужно. Сразу же стоит обратить внимание каким образом осуществлено подключение, чтобы выбрать правильный способ управления сигналами.

Начнем с сигнала системного тактирования. Видим, что на плате установлен кварцевый генератор с частотой 50MHz:


И подключен CLK к ножке E1:


Найдем в схеме светодиоды. На плате у нас их всего 4 штуки:


Переходим к разделу схемы где цепи LEDx подключаются к ПЛИС:


Отлично. LED0 — E10, LED1 — F9, LED2 — C9, LED3 — D9. Я обычно записываю эти данные на на отдельный листочек, чтобы потом в Pin Planner сразу указать нужные пины, не перерывая схематик снова.

Идём дальше. Кнопки. Качество китайских схематиков как обычно “на высоте” и ссылок по цепям нет, поэтому включаем поиск и ищем по ключевым словам.


Находим кнопки KEY1, KEY2, KEY3 на ножках M15, M16, E16 соответственно:


И кнопку RESET — тут, на N13:


Далее необходимо определиться к каким пинам подключить плату с кнопками и я выбрал левую гребенку на плате и следующие пины:


К сожалению, кривой китайский схематик показывает данный элемент кверху ногами, но шелкография на обратной стороне платы позволяет достаточно быстро сориентироваться в распиновке. Получается следующее:

• кнопка записи — подключаем к пину N2;
• кнопка чтения — подключаем к пину P1;
• кнопка прибавления единицы к значению адреса ячейки памяти — пин P2;
• кнопка вычитания единицы из значения адреса выбранной ячейки памяти — пин R1;
• кнопка прибавления единицы к записываемому числу в ячейку памяти — пин P8;
• кнопка вычитания единицы из записываемого числа в ячейку памяти — пин K9.

Далее переходим к семисегментному индикатору:



Тут пины все подписаны. Не буду их дополнительно перечислять. Хоть где-то сделали нормальное указание цепей, чтобы не блуждать по схематику ???? в поисках пина, к которому подключена периферия. О принципе работы семисегментника я расскажу чуть позже.

И остается последний штрих — пины SDA и SCL микросхемы EEPROM:


И самые внимательные читатели заметят — что на пинах D1, E6 находятся сигналы выбора SEL6 и SEL7 и сигналы SCL, SDA. Поэтому последние два разряда мы не сможем задействовать в нашем проекте. И они будут постоянно показывать всякую хрень, будем держать это во внимании.

Теперь можно скомпилировать проект и перейти в Pin Planner (Assignments — Pin Planner) чтобы занести значения пинов. У меня получился вот такой внушительный список:


Обратите внимание, что I/O Standard указан 3.3-V LVTTL. Указываем и закрываем данное окно. Теперь можно к этому этапу больше не возвращаться, если не собираетесь менять имена цепей, иначе их придется размечать заново на новые имена.

❯ Шаг первый. Драйвер LED-ов

В первую очередь стоит начать с самых простых задач, чтобы раскачать энтузиазм — сделаем простой драйвер для LED-индикаторов.

Добавляем в проект файл led_driver.v и в нём мы пишем простую логику управления сигналами. Думаю в дополнительном комментировании она не нуждается:

module led_driver
	(
		input		clk_i,		// Сигнал тактирования
		input		rstn_i,	// Сигнал асинхронного сброса
		input		state_i,	// Входное значение, 1 - горит, 0 - не горит
		output		led_o		// Выходной сигнал для LED
);    
                
  reg led_r; 

  always @ (posedge clk_i or negedge rstn_i)
  begin
	 
      if (~rstn_i) begin
        led_r <= 0;
      end 
      else if(state_i) begin
        led_r <= 1'b1;
      end
      else begin
        led_r <= 1'b0;
      end      
  end

  assign led_o = led_r;            
           
endmodule

После этого можно добавить эти модули в Top Level Design и идти дальше:

//#################################################
//  LED Drivers
//#################################################
	
reg ack_bit_r;				// Регистр для хранения значения ACK 
wire ack_bit_w;				// Провод который будет идти из I2C Bit Controller

reg led_write_pulse_r;		// Для отладки: индикатор нажатия кнопки Write
reg led_read_pulse_r;		// Для отладки: индикатор нажатия кнопки Read
	
// ACK bit LED
led_driver led_driver_m0 (
	.clk_i		(clk_i),
	.rstn_i	(rstn_i),
	.state_i	(ack_bit_w),
	.led_o		(led_brd_o[0])
);   
	
// Pulse Write LED
led_driver led_driver_m1 (
	.clk_i		(clk_i),
	.rstn_i	(rstn_i),
	.state_i	(led_read_pulse_r),
	.led_o		(led_brd_o[1])
); 
	
// Pulse Read LED
led_driver led_driver_m2 (
	.clk_i		(clk_i),
	.rstn_i	(rstn_i),
	.state_i	(led_write_pulse_r),
	.led_o		(led_brd_o[2])
);

Последний, 4-й светодиод оставим незадействованным. Идем дальше.

❯ Шаг второй. Драйвер кнопок

Следующим шагом необходимо накидать модуль обработки входных сигналов с ножек GPIO для того, чтобы использовать их потом в качестве “рычагов” для определенных экшенов.

Все знают, что дребезг механических кнопок и переключателей — это стандартная проблема, которая требует дополнительного модуля обработки и фильтрации. Об этом я писал в этой статье, в главе “Модуль Debouncer”.

Выглядит эта ситуация вот таким образом:


Итак. Добавим в проект файл с именем gpio_debouncer.v. В этот раз я решил накидать несколько видоизмененный модуль. Общий принцип остается таким же как и в прошлых статьях — когда нажата кнопка и удерживается необходимое количество времени (очень короткий по человеческим ощущениям период) — запускается счетчик который достигая определенного значения — передает значение на выходной порт. Если кнопка отжимается — то сигнал устанавливается в ноль. В дополнение к этому генерируется импульс на нажатие кнопки, и импульс на момент отжатия кнопки. Они, точнее один из импульсов — нам очень пригодится в будущем.

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

module gpio_debouncer

	// Порты
	(
		input		clk_i,			// Сигнал тактирования
		input		rstn_i,			// Сигнал асинхронного сброса
		input		button_i,		// Сигнал с физической кнопки
		output reg	button_posedge_r,	// Импульс на нажатие кнопки
		output reg	button_negedge_r,	// Импульс на отжатие кнопки
		output reg	button_out_r		// Фильтрованный сигнал с кнопки
	);

endmodule

Следующим шагом необходимо определить какой величины будет счётчик, какова минимальная длительность нажатия, чтобы ее считать стабильным нажатием а не набором импульсов, которым из себя представляет момент нажатия механической кнопки.

Для этого я сделал ряд служебных параметров у данного модуля:

// Глобальные параметры
#(
	parameter CNT_WIDTH = 32,	// Разрядность счетчика таймера
	parameter FREQ = 50,	// Глобальная частота тактирования
	parameter MAX_TIME = 20	// Длительность стабильного удержание кнопки
)

// Локальные параметры
localparam TIMER_MAX_VAL = MAX_TIME * 1000 * FREQ; 	// Максимальное значение таймера

Далее необходимо объявить несколько вспомогательных регистров (D-триггеров) и флаг сброса счётчика если детектирован дребезг. Они будут выполнять функцию сброса счетчика, если их значения будут отличаться, т.е. когда будет дребезг контактов в виде хаотичного изменения входного сигнала — сбрасываем счётчик:

// Input flip-flops
reg DFF1; 
reg DFF2; 

wire q_reset;

assign q_reset = (DFF1 ^ DFF2);			// XOR для наблюдения за дребезгом

Еще нужно объявить два регистра для счётчика и один вспомогательный флаг:

// Timing regs
reg [CNT_WIDTH-1:0] q_reg;				// Регистр счетчика
reg [CNT_WIDTH-1:0] q_next;			// Вспомогательный регистр

wire q_add;

assign q_add = ~(q_reg == TIMER_MAX_VAL);	// Флаг на разрешение инкремента счётчика 

Теперь нужно сделать поведенческий блок, который будет осуществлять прибавление счётчика. Сигналов на изменение поведения будет несколько:

• q_reset — это сигнал о том, что нужно сбросить счетчик;
• q_add — это сигнал о том, что можно производить инкремент счётчика;
• q_reg — это сам счётчик.

Общая идея заключается в том, что если сигнала q_reset нет, а есть сигнал на q_add, т.е. не достигнут максимум счётчика — то прибавляем значение.

always @(q_reset, q_add, q_reg)
begin
	case({q_reset , q_add})
		2'b00 :				// Достигнут максимум счётчика
			q_next <= q_reg;			// Оставляем значение тем же
		2'b01 :				// Не достигнут максимум
			q_next <= q_reg + 1;		// Добавляем к значению +1
		default :				// Все остальные случаи
			q_next <= {CNT_WIDTH {1'b0}};	// Обнуляем значение
		endcase     
end

И добавим блок, который будет обновлять значение q_reg и реагировать на входной сигнал:

always @(posedge clk_i or negedge rstn_i)	
begin
	if(rstn_i == 1'b0) begin			// Если произошел сброс то обнуляем значения
		DFF1 <= 1'b0;
		DFF2 <= 1'b0;
		q_reg <= {CNT_WIDTH {1'b0}};
	end
	else begin					
		DFF1 <= button_i;			// Фиксируем входное значение
		DFF2 <= DFF1;				// Передаем его второму D-триггеру
		q_reg <= q_next;			// Обновляем значение счётчика
	end
end

Добавим блок для формирования выходного сигнала в случае если достигнут предел счёта:

always @(posedge clk_i or negedge rstn_i)
begin
	if(rstn_i == 1'b0)
		button_out_r <= 1'b1;		
	else if(q_reg == TIMER_MAX_VAL)
		button_out_r <= DFF2;
	else
		button_out_r <= button_out_r;
end

И добавим блок для формирования импульсов:

reg button_out_d0_r;

always @(posedge clk_i or negedge rstn_i)
begin
	
  if(rstn_i == 1'b0) begin
      button_out_d0_r <= 1'b1;
      button_posedge_r <= 1'b0;
      button_negedge_r <= 1'b0;
  end
  else begin
      button_out_d0_r 	<= button_out_r;
      button_posedge_r 	<= ~button_out_d0_r &  button_out_r;
      button_negedge_r 	<= button_out_d0_r 	& ~button_out_r;
  end	
end

В итоге получился следующий модуль:

module gpio_debouncer

	// Global parameters
	#(
		parameter CNT_WIDTH = 32, 			// Debounce timer bitwidth
		parameter FREQ = 50,         		// Global clock (MHz)
		parameter MAX_TIME = 20     		// Total delay time in ms
	)
	
	// Ports
	(
		input		clk_i,               // Clock input
		input		rstn_i,              // Reset input
		input		button_i,
		output reg	button_posedge_r,
		output reg	button_negedge_r,
		output reg	button_out_r
	);
	
	localparam TIMER_MAX_VAL = MAX_TIME * 1000 * FREQ; // Maximum timer value
	
	// Timing regs
	reg [CNT_WIDTH-1:0] q_reg;      						
	reg [CNT_WIDTH-1:0] q_next;
	
	// Input flip-flops
	reg DFF1;
	reg DFF2;             										
	
	// Control flags
	wire q_add;                 								
	wire q_reset;
	
	reg button_out_d0_r;
	
	// Continous assignment for counter control
	assign q_reset = (DFF1 ^ DFF2); 	
	assign q_add = ~(q_reg == TIMER_MAX_VAL);
    
	// Combo counter to manage q_next 
	always @(q_reset, q_add, q_reg)
	begin
		case({q_reset , q_add})
			2'b00 :
				q_next <= q_reg;
			2'b01 :
				q_next <= q_reg + 1;
			default :
				q_next <= {CNT_WIDTH {1'b0}};
		 endcase     
	end

	// Flip flop inputs and q_reg update
	always @(posedge clk_i or negedge rstn_i)
	begin
		if(rstn_i == 1'b0) begin
			DFF1 <= 1'b0;
			DFF2 <= 1'b0;
			q_reg <= {CNT_WIDTH {1'b0}};
		end
		else begin
			DFF1 <= button_i;
			DFF2 <= DFF1;
			q_reg <= q_next;
		end
	end

	// Counter control
	always @(posedge clk_i or negedge rstn_i)
	begin
		if(rstn_i == 1'b0)
			button_out_r <= 1'b1;
		else if(q_reg == TIMER_MAX_VAL)
			button_out_r <= DFF2;
		else
			button_out_r <= button_out_r;
	end
	
	always @(posedge clk_i or negedge rstn_i)
	begin
		if(rstn_i == 1'b0) begin
			button_out_d0_r <= 1'b1;
			button_posedge_r <= 1'b0;
			button_negedge_r <= 1'b0;
		end
		else begin
			button_out_d0_r <= button_out_r;
			button_posedge_r <= ~button_out_d0_r & button_out_r;
			button_negedge_r <= button_out_d0_r & ~button_out_r;
		end	
	end
	
endmodule

В итоге можете сделать testbench-файл в котором можно поэкспериментировать с входными сигналами и отследить как работает данный модуль. Но если останавливаться на этом в этой статье, она получится крайне объемной, поэтому идем дальше.

Сразу же добавим в Top Level Design все экземпляры модуля для обработки сигналов с кнопок:

//#################################################
	//  GPIO Buttons Debouncers
	//#################################################

	wire btn_read_negedge_w;	
	wire btn_write_negedge_w;
	wire btn_reg_p_negedge_w;
	wire btn_reg_n_negedge_w;
	wire btn_data_p_negedge_w;
	wire btn_data_n_negedge_w;
	
	gpio_debouncer gpio_debouncer_m0 (
		.clk_i			(clk_i),               			
		.rstn_i		(rstn_i),              			
		.button_i		(btn_brd_i[0]),				

		.button_out_r		(),     			
		.button_negedge_r	(),      			
		.button_posedge_r	(btn_read_negedge_w)   	
	);
	
	gpio_debouncer gpio_debouncer_m1 (
		.clk_i			(clk_i),               			
		.rstn_i		(rstn_i),              			
		.button_i		(btn_brd_i[1]),				

		.button_out_r		(),     			
		.button_negedge_r	(),      			
		.button_posedge_r	(btn_write_negedge_w)  	
	);
	
	gpio_debouncer gpio_debouncer_m2 (
		.clk_i			(clk_i),               			
		.rstn_i		(rstn_i),              			
		.button_i		(btn_brd_i[2]),				

		.button_out_r		(),     			
		.button_negedge_r	(),      			
		.button_posedge_r	(btn_reg_p_negedge_w)  	
	);
	
	gpio_debouncer gpio_debouncer_m3 (
		.clk_i			(clk_i),               			
		.rstn_i		(rstn_i),              			
		.button_i		(btn_brd_i[3]),				

		.button_out_r		(),     		
		.button_negedge_r	(),
        .button_posedge_r	(btn_reg_n_negedge_w)
	);
	
	gpio_debouncer gpio_debouncer_m4 (
		.clk_i			(clk_i),               			
		.rstn_i		(rstn_i),
		.button_i		(btn_brd_i[4]),

		.button_out_r		(),
		.button_negedge_r	(),
		.button_posedge_r	(btn_data_p_negedge_w)
	);
	
	gpio_debouncer gpio_debouncer_m5 (
		.clk_i			(clk_i),
		.rstn_i		(rstn_i),
		.button_i		(btn_brd_i[5]),

		.button_out_r		(),
		.button_negedge_r	(),
		.button_posedge_r	(btn_data_n_negedge_w)
	);

Перейдем дальше к следующему элементу нашей конструкции.

❯ Шаг третий. Управление семисегментным индикатором

Данная задача делится на два этапа. Первый — это декодер 8-битных значений регистров на символы для каждого из сегментов. Второй — это главный драйвер, который будет осуществлять вывод данных на сегменты.

Разберемся сначала со схемотехникой индикатора, откроем схему:


У семисегментников, в каждом разряде используются одни и те же пины для включения конкретно взятых сегментов. И 4 пина которые отвечают за зажигание отдельно взятого разряда.

Общая логика управления состоит в том, что нужно сначала выставить нужные данные на пинах данных (отмечены буквами) и потом выбрать на каком сегменте их отобразить. Чтобы вывести сложный набор цифр, надо постоянно чередовать разряды выставляя соответствующие ему значения сегментов. Как этим управлять — чуть позже.

Сделаем декодер бинарных данных в формат для вывода на дисплей. Создаем файл seg_decoder.v и пишем код модуля. Тут все просто и очевидно:

module seg_decoder
	(
		input[3:0]      bin_data_i,     // Binary data input
		output reg[6:0] seg_data_o      // Seven segments LED output
	);

	always@(*)
	begin
	
		case(bin_data_i)
		
			4'd0:	seg_data_o <= 7'b1000000;
			4'd1:	seg_data_o <= 7'b1111001;
			4'd2:	seg_data_o <= 7'b0100100;
			4'd3:	seg_data_o <= 7'b0110000;
			4'd4:	seg_data_o <= 7'b0011001;
			4'd5:	seg_data_o <= 7'b0010010;
			4'd6:	seg_data_o <= 7'b0000010;
			4'd7:	seg_data_o <= 7'b1111000;
			4'd8:	seg_data_o <= 7'b0000000;
			4'd9:	seg_data_o <= 7'b0010000;
			4'hA:	seg_data_o <= 7'b0001000;
			4'hB:	seg_data_o <= 7'b0000011;
			4'hC:	seg_data_o <= 7'b1000110;
			4'hD:	seg_data_o <= 7'b0100001;
			4'hE:	seg_data_o <= 7'b0000110;
			4'hF:	seg_data_o <= 7'b0001110;
			
			default:seg_data_o <= 7'b1111111;
			
		endcase
		
	end
	
endmodule

Создадим модуль для вывода данных. Создаем файл seg_scan.v и сделаем заготовку модуля. В целом он также достаточно простой:

module seg_scan
	(
		input           clk_i,
		input           rstn_i,
		output reg[7:0] seg_sel_o,      	// Выбор разряда
		output reg[7:0] seg_data_o,     	// Выбор сегмента
		input[7:0]      seg_data_0_i,
		input[7:0]      seg_data_1_i,
		input[7:0]      seg_data_2_i,
		input[7:0]      seg_data_3_i,
		input[7:0]      seg_data_4_i,
		input[7:0]      seg_data_5_i,
		input[7:0]      seg_data_6_i,
		input[7:0]      seg_data_7_i
	);

endmodule

Добавляем параметры для тонкой настройки:

// Global parameters
	#(
	parameter SCAN_FREQ = 200;     // Частота обновления данных
		parameter CLK_FREQ = 50000000; // Системная частота тактирования
		parameter SCAN_COUNT = CLK_FREQ / (SCAN_FREQ * 8) - 1;
	)

Введем несколько вспомогательных регистров:

reg [31:0] scan_timer_r;	// Scan time counter
reg  [3:0] scan_sel_r;	// Scan select counter

Добавляем поведенческий блок, который будет с определенным таймаутом включать сегменты:

always@(posedge clk_i or negedge rstn_i)
begin
	
	if(~rstn_i)
	begin
		
		scan_timer_r 	<= 32'd0;
		scan_sel_r 	<= 4'd0;
			
	end
	else if(scan_timer_r >= SCAN_COUNT)
	begin
		
		scan_timer_r 	<= 32'd0;
			
		if(scan_sel_r == 4'd5)
			scan_sel_r	<= 4'd0;
		else
			scan_sel_r	<= scan_sel_r + 4'd1;
	end
	else begin
		scan_timer_r <= scan_timer_r + 32'd1;
	end			
end	

И добавляем управление пином выбора сегмента с параллельным выставлением данных на сегменты:

always@(posedge clk_i or negedge rstn_i)
	begin
	
		if(~rstn_i)
		begin
			seg_sel_o 	<= 8'b1111_1111;
			seg_data_o 	<= 8'hFF;
		end
		else
		begin
			
			// Digital LEDs choose
			case(scan_sel_r)			
				
				4'd0:	begin
					seg_sel_o <= 8'b1111_1110;
					seg_data_o <= seg_data_0_i;
				end
				
				4'd1:	begin
					seg_sel_o <= 8'b1111_1101;
					seg_data_o <= seg_data_1_i;
				end
				
				4'd2:	begin
					seg_sel_o <= 8'b1111_1011;
					seg_data_o <= seg_data_2_i;
				end
				
				4'd3:	begin
					seg_sel_o <= 8'b1111_0111;
					seg_data_o <= seg_data_3_i;
				end
				
				4'd4:	begin
					seg_sel_o <= 8'b1110_1111;
					seg_data_o <= seg_data_4_i;
				end
				
				4'd5:	begin
					seg_sel_o <= 8'b1101_1111;
					seg_data_o <= seg_data_5_i;
				end
				
				4'd6:	begin
					seg_sel_o <= 8'b1011_1111;
					seg_data_o <= seg_data_6_i;
				end
				
				4'd7:	begin
					seg_sel_o <= 8'b0111_1111;
					seg_data_o <= seg_data_7_i;
				end
				
				default:	begin
					seg_sel_o <= 8'b1111_1111;
					seg_data_o <= 8'hFF;
				end
				
			endcase
		end
	end

Тут тоже все очень просто, кажется что комментировать тут нечего. Значение 0 в конкретном разряде выбирает конкретный сегмент, потому что установлены PNP-транзисторы для управления сопротивлением канала. При этом выставляется соответствующее значение для набора сегментов, в соответствии с данными.

Добавим в Top Level модуль экземпляры вышеописанных модулей для работы с семисегментным дисплеем:

//#################################################
// 7 Segments Display Drivers
//#################################################
	
	wire[6:0] seg_data_0_w;
	wire[6:0] seg_data_1_w;
	wire[6:0] seg_data_2_w;
	wire[6:0] seg_data_3_w;
	wire[6:0] seg_data_4_w;
	wire[6:0] seg_data_5_w;
	
	seg_decoder seg_decoder_m0 (
		 .bin_data_i  (reg_addr_r[7:4]),
		 .seg_data_o  (seg_data_0_w)
	);
	
	seg_decoder seg_decoder_m1 (
		 .bin_data_i  (reg_addr_r[3:0]),
		 .seg_data_o  (seg_data_1_w)
	);
	
	seg_decoder seg_decoder_m2 (
		 .bin_data_i  (data_write_r[7:4]),
		 .seg_data_o  (seg_data_2_w)
	);
	
	seg_decoder seg_decoder_m3 (
		 .bin_data_i  (data_write_r[3:0]),
		 .seg_data_o  (seg_data_3_w)
	);
	
	seg_decoder seg_decoder_m4 (
		 .bin_data_i  (read_data_r[7:4]),
		 .seg_data_o  (seg_data_4_w)
	);
	
	seg_decoder seg_decoder_m5 (
		 .bin_data_i  (read_data_r[3:0]),
		 .seg_data_o  (seg_data_5_w)
	);
	
	// Main driver for 7-seg display
	seg_scan seg_scan_m0 (
		 .clk_i        (clk_i),
		 .rstn_i      	(rstn_i),
		 .seg_sel_o    (seg_sel_o),
		 .seg_data_o   (seg_data_o),
		 .seg_data_0_i ({1'b1, seg_data_0_w}),
		 .seg_data_1_i ({1'b1, seg_data_1_w}),
		 .seg_data_2_i ({1'b1, seg_data_2_w}),
		 .seg_data_3_i ({1'b1, seg_data_3_w}),
		 .seg_data_4_i ({1'b1, seg_data_4_w}),
		 .seg_data_5_i ({1'b1, seg_data_5_w}),
		 .seg_data_6_i ({1'b1, 7'b1111_111}),	// Don't use this segments, busy by I2C
		 .seg_data_7_i ({1'b1, 7'b1111_111})	// Don't use this segments, busy by I2C
	);

Данный HDL-код легко читаем и в дополнительном комментировании, уверен, не нуждается. Идём дальше.

r

❯ Шаг четвертый. Делитель частоты для I2C Bit Controlle

Теперь необходимо подготовить делитель частоты для основного контроллера I2C, который мы создавали в прошлой статье. Создадим файл clock_divider.v и создадим модуль делителя:

module clock_divider
(
	input clk_i,
	output reg clk_o
);

endmodule

Добавляем параметры для тонкой настройки:

// Global parameters
#(
    parameter DIVISOR = 32;     // Частота обновления данных, 
)

Логика делителя очень простая. На вход модуля подается основной тактовый сигнал в 50 MHz и с помощью счетчика, при достижении определенного значения параметра DIVISOR, производится инверсия выходного сигнала.

Добавляем регистр счётчика и поведенческий блок:

reg[27:0] counter = 28'd0;

always @(posedge clk_i)
	begin
	
		counter <= counter + 28'd1;
		
		if(counter >= (DIVISOR - 1))
			counter <= 28'd0;
			
		clk_o <= (counter < DIVISOR / 2) ? 1'b1 : 1'b0;
		
	end

Вставляем данный модуль в Top Level Design модуль:

//#################################################
// Clock Divider for I2C Bit Controller
//#################################################
	
	wire clk_div_w;
	
	clock_divider clock_divider_m0 (
		.clk_i (clk_i),
		.clk_o (clk_div_w),
	);

Так. Со всеми простыми элементами дизайна мы разобрались — осталось самое сложное (для меня), с чем я дольше всего ломал голову.

❯ Шаг пятый. Главный модуль управления I2C сигналами

Следующим этапом передо мной стояла задача организовать управление получившимся в прошлом уроке битовым контроллером, который абстрагирован от отдельных транзакций и чисто крутит отдельными битиками когда ему скажут по определенным командам.

Решение я “рожал” достаточно долго, потому что приходилось учитывать целую совокупность факторов, которые должны были сойтись и синхронно отрабатывать то что мне нужно. И главный вопрос, который нужно было решить — каким образом детектировать момент когда можно переходить к выставлению следующей команды и очередной порции данных. Самый простой и очевидный способ — это ввести счетчик завершения выполнения отдельных транзакций, который будет инкрементироваться от изменения сигнала ready.

Пришлось потратить большое количество времени, чтобы получить работу автомата такой, как я ее ожидал. В остальном кажется многое просто требовало немного логического размышления, прокручивания алгоритма действия в голове и наблюдательности.

Итак, опишу, что в итоге получилось. Добавим модуль и вспомогательные элементы сразу же в Top Level Design модуль. Первый элемент это адрес Slave-устройства, т.е. нашей EEPROM. Посмотрев в Datasheet данной EEPROM и на подключение ее ножек адреса, стало ясно, что адрес на чтение будет 0xA1, а на запись 0xA0. Поэтому Contol Byte мы будем клеить из двух частей 7'b1010000 и бита операции. Далее увидите как это выглядит.

Добавим это в модуль:

//#################################################
// Main Operation FSM
//#################################################
		
// Адрес EEPROM
localparam SLAVE_ADDR 		= 7'b1010000;

Я постоянно забывал, какой бит выставляется в Control Byte с адресом Slave-устройства для чтения, а какой бит для записи. В итоге просто записал константы для удобства использования:

// Биты для подставления в Control Byte I2C 
localparam READ_BIT			= 1'b1;
localparam WRITE_BIT		= 1'b0;

Для управления транзакциями — мне потребовался отдельный автомат с конечными состояниями и его возможные варианты состояний и регистр для их хранения сразу же и объявим:

// Состояния FSM и регистр для них
localparam IDLE_STATE 		= 4'd1;
localparam WRITE_STATE		= 4'd2;
localparam READ_STATE		= 4'd3;
localparam WAIT_STATE		= 4'd4;

reg [3:0] state_r = IDLE_STATE;

Набор команд, которые мы будем подавать на вход I2C Bit Controller — тоже заранее объявим тут:

// Те самые команды из прошлого урока
localparam START_CMD   		= 4'd1; 
localparam WR_CMD     		= 4'd2; 
localparam RD_CMD      		= 3'd3; 
localparam STOP_CMD    		= 4'd4;
localparam RESTART_CMD 		= 4'd5;

reg [2:0] cmd_r = START_CMD;

В определенных местах мне понадобилась искусственная задержка и пришлось подставить костыль, когда не срабатывала последняя команда STOP. Позже покажу где я его поставил, может вы придумаете более изящное решение получившейся у меня проблемы. Объявим регистр для хранения значения таймера:

// Счетчик таймера
reg [31:0] timer_r;

Для старта операций в I2C Bit Controller необходим специальный сигнал — wr_i2c. Объявим для него свой регистр:

// Команда для старта операций в I2C Bit Ctrl
reg wr_i2c_r;

Для передачи адреса Slave устройства, адреса ячейки памяти и значения — объявим три регистра:

reg [6:0] slave_addr_r = SLAVE_ADDR;
reg [7:0] reg_addr_r = 0;
reg [7:0] data_write_r = 0;

Для читаемых и записываемых данных объявим регистры-буферы:

// Data buffers
reg [7:0] read_data_r;
wire [7:0] read_data_w;
	
reg [7:0] write_data_r;

Для бита ACK-так же необходимо своё хранилище и провод который будет идти от модуля I2C Bit Controller:

reg ack_bit_r;
wire ack_bit_w;

Для сигнала готовности модуля — тоже необходим отдельный сигнал:

wire ready_w;

Добавим в Top Level Design модуль из прошлого урока (отладочный сигнал state_o, который я использовал в прошлом уроке — я убрал):

//#################################################
// I2C Bit Controller
//#################################################
	
i2c_bit_controller i2c_bit_controller_m0 (
	
		.rstn_i(rstn_i), 		// Сигнал асинхронного сброса
		.clk_i(clk_div_w), 		// Поделенная частота
		
		.wr_i2c_i(wr_i2c_r),	// Сигнал на старт транзакций
		.cmd_i(cmd_r), 		// Команда для исполнения
		
		.din_i(write_data_r),	// Данные для записи
		.dout_o(read_data_w),	// Прочитанные данные
		.ack_o(ack_bit_w),		// ACK-бит
		
		.ready_o(ready_w),		// Сигнал готовности модуля
			
		.sda_io(sda_io),		// Линия данных SDA
		.scl_io(scl_io)		// Линия тактового сигнала SCL
);

Поскольку напрямую регистры для данных и ACK-бита подключить к модулю не получится (на самом деле не понял до конца почему), необходимо сделать поведенческий блок, который будет сохранять значение прочитанных данных и ACK-бита в регистр:

always @(*) begin	
	read_data_r <= read_data_w;
	ack_bit_r <= ack_bit_w;		
end

Следующим шагом сделаем обработчик действий на кнопки для выбора регистра записи и данных для записи:

always @(posedge clk_i or negedge rstn_i)
begin
		
		if(rstn_i == 1'b0) begin		
			reg_addr_r		<= 0;
			data_write_r		<= 0;			
		end 
		else begin
			
			if(btn_reg_p_negedge_w) begin
				reg_addr_r = reg_addr_r + 1;			
			end
			
			if(btn_reg_n_negedge_w) begin			
				reg_addr_r = reg_addr_r - 1;			
			end
			
			if(btn_data_p_negedge_w) begin				
				data_write_r = data_write_r + 1;				
			end
			
			if(btn_data_n_negedge_w) begin			
				data_write_r = data_write_r - 1;			
			end
			
		end
end

Выглядит очень просто, и кажется что никаких дополнительных пояснений тут не требуется.

Добавим поведенческий блок, который будет подсчитывать количество выполненных транзакций в случае записи или чтения данных. Каждое возведение сигнала ready_w в значение логической единицы — будет основным сигналом для поведенческого блока и счётчик будет увеличиваться. У каждой из операций — есть конечное количество отдельных транзакций, которые нужно сделать, послеих выполнения — нужно сбросить счётчик.

Далее вы увидите как это было использовано, а пока добавим HDL-код в Top-модуль:

// Counter for transactions
reg [4:0] counter_r = 0;
always @(posedge ready_w or negedge rstn_i) begin
	
		if(rstn_i == 1'b0) begin		
			counter_r = 0;		
		end 
		else begin 
	
			counter_r = counter_r + 1;
			
			case(state_r)
			
				READ_STATE: begin			
					if (counter_r == 7) begin
						counter_r = 0;
					end				
				end 
				
				WRITE_STATE: begin				
					if (counter_r == 5) begin
						counter_r = 0;
					end				
				end 
				
				default: begin
					counter_r = 0;
				end
				
			endcase
			
    	end	
end

Перейдем к созданию основного блока, который будет реализовывать транзакции и делаем сброс значений при асинхронном сбросе:

always @(posedge clk_i or negedge rstn_i)
begin

    if(rstn_i == 1'b0) begin	

		led_write_pulse_r	<= 0;
		led_read_pulse_r	<= 0;
		
		cmd_r 			<= START_CMD;
		state_r 		<= IDLE_STATE;
		write_data_r		<= 0;
		wr_i2c_r		<= 0;

    end 
	else begin

    end
end

В основном блоке создаем простую State-машину:


Описываем ее следующим образом и расставим управление сигналом старта транзакций wr_i2c_r:

case(state_r)

    IDLE_STATE: begin
		wr_i2c_r = 0;
    end
      
    READ_STATE: begin
    	wr_i2c_r = 1;
    end
				
	WRITE_STATE: begin
		wr_i2c_r = 1;
	end
				
	WAIT_STATE: begin 
		wr_i2c_r = 1;
	end

    default: begin
		wr_i2c_r = 0;
	end 
				
endcase

В первую очередь сделаем обработку импульсов на исполнение команды записи или чтения с кнопок, если автомат готов. Если приходит импульс — то приходим в следующее состояние, в зависимости от того с какой кнопки пришла команда:

IDLE_STATE: begin
					
	wr_i2c_r = 0;	
						
	// Button for Read operation	
	if(btn_read_negedge_w) begin
		if(ready_w) begin							
			state_r = READ_STATE;
		end						
	end
					
	// Button for Write operation
	if(btn_write_negedge_w) begin						
		if(ready_w) begin							
			state_r = WRITE_STATE;
		end						
	end					
end

Опишем операции на READ_STATE. Тут все просто — реагируем на каждое увеличение счетчика counter_r, это означает, что автомат готов выполнять следующую операцию. Получилось следующее:

READ_STATE: begin
					
		led_read_pulse_r <= ~led_read_pulse_r;		// Для отладки
		wr_i2c_r = 1;						// Стартуем транзакции
					
		case(counter_r)

		0: begin end
						
		1: begin						
			write_data_r = {slave_addr_r, WRITE_BIT}; // Выставляем данные
        end
						
		2: begin							
			write_data_r = reg_addr_r;						
		end
						
		3: begin						
			cmd_r = RESTART_CMD;
			write_data_r = {slave_addr_r, READ_BIT};						
		end
						
		4: begin						
			cmd_r = WR_CMD;
			write_data_r = {slave_addr_r, READ_BIT};						
		end
						
		5: begin							
			cmd_r = RD_CMD;							
		end
						
		6: begin						
			cmd_r = STOP_CMD;	
			
            state_r = WAIT_STATE;
			timer_r = 0; 
		end
		default: begin						
			cmd_r = START_CMD;
			
            state_r = IDLE_STATE;
			write_data_r = 0;	
		end
					
		endcase
end

Тут в целом все легко читается, понятно что происходит каждую посылку. Открыв даташит на EEPROM видно, каким образом осуществляется чтение:


Вы можете самостоятельно сопоставить то, что происходит в коде с тем, как должна быть организована транзакция на Random Read, т.е. на чтение рандомной ячейки памяти.

Перейдем к операции Random Write в Datasheet:

Тоже достаточно очевидно что дожно происходить при записи. Опишем секцию WRITE_STATE. Тут даже несколько проще чем в READ_STATE:

WRITE_STATE: begin
				
		led_write_pulse_r <= ~led_write_pulse_r;
		wr_i2c_r = 1;
					
		case(counter_r)
			0: begin end
						
			1: begin						
				write_data_r = {slave_addr_r, WRITE_BIT};
          	end
						
			2: begin
				write_data_r = reg_addr_r;	
			end
						
			3: begin							
				write_data_r <= data_write_r;
			end
						
			4: begin
				cmd_r = STOP_CMD;	
	
				state_r = WAIT_STATE;
				timer_r = 0; 
			end
						
			default: begin						
				cmd_r = START_CMD;
				state_r = IDLE_STATE;
				write_data_r = 0;	
			end
					
		endcase				
end

Следующий state, который необходимо добавить, в основном для покостыливания невыполнения STOP-команды — это WAIT_STATE:

WAIT_STATE: begin 
				
		wr_i2c_r = 1;
				
		if(timer_r >= 32'd1000) begin
            state_r <= IDLE_STATE;
			write_data_r = 0;
			cmd_r = START_CMD;
		end
		else
            timer_r <= timer_r + 32'd1;
	end

Ждём условно 1000 тактов и переходим в IDLE_STATE.

Добавим также обработчик для всех остальных случаев:

default: begin
					
	wr_i2c_r = 0;
      state_r <= IDLE_STATE;
					
end 

Полный текст исходного когда главного модуля — вы можете найти в моем Github-репозитории.

❯ Шаг шестой. Проверяем как работает, ищем баги

Итак. Мы собрали все необходимое и теперь можно провести проверку и простейший дебаг. Способов вижу два — припаяться к ножкам SDA и SCL у EEPROM и подключить DSLogic или сделать через встроенный в Quartus SignalTap логический анализатор и по JTAG посмотреть, что происходит.

Коротко расскажу про второй способ. Запустить Signal Tap можно через главное меню:


Основные кнопки в окне я выделил красным:



В первую очередь необходимо выбрать источник тактирования в секции Clock. Тут я выбрал поделенную частоту, чтобы охватить необходимое количество семплов т.к. память захвата ограничена и надо чтобы всё влезло. Этот параметр устанавливается через параметр Sample depth.

После необходимо накидать во вкладке Setup наблюдаемые сигналы и выбрать логическую функцию Basic OR для триггеров от этих сигналов. После добавления изменений — необходимо, чтобы модуль наблюдения попал в прошивку. Для этого необходимо перекомпилировать ее и прошить в плату.

После компиляции нужно выбрать триггер, я выбрал от сигнала READ_STATE и WRITE_STATE. Можно запустить Run Analysis для единичного захвата и перейти в секцию Data нажать кнопку, которой присвоено действие на чтение:



Подробно рассмотрев, видим, что все сигналы на команду Read отрабатывают как нужно т.е. читаем из регистра 0x02 заранее записанное значение 0xCE. Теперь можно посмотреть что происходит на команду Write. Запишем в ячейку 0x02 новое значение 0xF1:



Кажется все работает как нужно. Подключим для проверки DSLogic к ножкам EEPROM и с помощью программы DSView и декодера I2C протокола проверить правильность транзакций.

На чтение:



На запись:



Кажется при корректных данных все выполняется правильно, в соответствии с Datasheet. Плюсом если повторно нажимать кнопки транзакций, выбирать данные и регистры для записи и чтения — то все на первый взгляд работает корректно. Но стоит немного углубиться в изучение — и сходу можно найти несколько багов. Перечислю их.

❯ Баг №1. Некорректная частота SCL

Рассмотрению частоту тактирования, получилось значение 390.62kHz:


Получилось конечно не 400kHz ровно, но кажется что этого для данного уровня “развития” автомата будет достаточно. Можно считать за первый баг.

❯ Баг №2. Некорректная установка ACK-бита

В ходе просмотра транзакций — Я обнаружил хаотическую установку ACK-бита. Пока не понятно откуда берется во взаимодействии с железом этот косяк. Надо будет разбираться после.


В качестве неприятного дополнения к этому — при подаче адреса для Slave-устройства которого нет на шине — один фиг приходит сигнал ACK.

Других проблем я пока не обнаружил. Думаю в коммитах в репозитории можно будет отслеживать прогресс по доработке.

❯ Заключение

В целом результат можно считать удовлетворительным т.к. основная задача выполнена:


Этот материал мне дался достаточно большой ценой — куча вариантов реализации, куча времени на отладку. Но результат стоил того. Куча опыта в отладке, в разборе вариантов реализации, часы просмотра результатов RTL-синтеза. Кажется базовый Verilog-кодинг стал одной из моих компетенций, но безусловно есть куда расти.

Сейчас стоит обозначить дальнейшие планы:

• пофиксить баги;
• перенести код в Xilinx Vivado, чтобы запустить его на плате Zynq Mini (которую я обозревал в этой статье);
• подключить данный модуль к AXI шине чтобы можно было взаимодействовать с ним из Linux.

Поэтому с этими планами можно идти дальше. До встречи в следующих статьях!

P. S. Забыл сказать. Самое дурацкое, что выяснилось сравнительно недавно — OLED-дисплей SSD1306, с которым планировалось взаимодействие полученного автомата оказывается подключен по SPI и необходимо будет придумать SPI-автомат ????. Так что буду по всей видимости писать еще и его ????

---

Возможно, захочется почитать и это:

• ➤ IR remote control, а без микроконтроллеров можно? Да не вопрос
• ➤ Как запустить сотовую сеть стандарта AMPS при помощи SDR
• ➤ Hello World на Tang Primer 20K под Linux
• ➤ Выполняем сторонние программы на микроконтроллерах с Гарвардской архитектурой: как загружать программы без знания ABI?
• ➤ Atomic Heart или как забилось сердце русского геймдева