[clump.git] / master.v

`include "pll.v"
`include "master_rom.v"
`include "i2c.v"
`include "uart.v"

`ifdef SIM
 `define UART_DIVIDE 1
 `define I2C_DIVIDE 4
`else
 `define UART_DIVIDE 1024
 `define I2C_DIVIDE 256
`endif

module master(input CLKin, output [4:0] led, output uart_tx, input uart_rx, output reg busy_out = 0, input busy_in, output scl, output sda);
   wire clk;

   assign clk = CLKin;

   // ROM

   reg [7:0] program_counter = 0;
   // go here at end of program
   reg [7:0] main = 1;
   wire [31:0] rom_output;

   master_rom master_rom (.clk(clk), .addr(program_counter), .data(rom_output));

   wire [2:0]  rom_op = rom_output[26:24];
   wire [2:0]  rom_led = rom_output[14:12];
   wire [3:0]  rom_chip_select = rom_output[31:28];

   // if the 4th board won't execute this instruction,
   // then we won't receive propagation or news
   wire 	   dont_wait = !rom_chip_select[3];
   reg [25:0]  dont_send = 23'b11111111111111111111111;

   always @(posedge clk) begin
	  if(busy_in)
		dont_send <= 21'b111111111111111111111;
	  else if(dont_send)
		dont_send <= dont_send - 1;
   end

   // state

`define STATE_SEND 0
`define STATE_WAIT_PROPAGATE 1
`define STATE_WAIT_NEWS 2
`define STATE_PROPAGATE_NEWS 3
`define STATE_SET_LEDS 4
`define STATE_WASTE_TIME 5

   reg [5:0] state = `STATE_SEND;
   reg [5:0] uart_ptr = 0;

   reg [30:0]  waste_counter = 0;
   reg [7:0]   saved_news [3:0];
   reg [7:0]   sent_byte [3:0];

   reg [7:0]   bytes_sent = 0;

   // i2c
   reg [15:0]  leds [3:0];

   initial begin
	  leds[0] <= 16'hF00F;
	  leds[1] <= 16'h0000;
	  leds[2] <= 16'h0000;
	  leds[3] <= 16'hFFFF;
   end

   /* even rows are green, odd rows are red:
    * mb_leds[2 * k] is the kth row of green leds
	* mb_leds[2 * k + 1] is the kth row of red leds
	*/
   wire [7:0] mb_leds [15:0];

   // all red leds are off
   assign mb_leds[1] = program_counter;
   assign mb_leds[3] = 0;
   assign mb_leds[5] = state;
   assign mb_leds[7] = uart_ptr;
   assign mb_leds[9] = 0;
   assign mb_leds[11] = 0;
   assign mb_leds[13] = 0;
   assign mb_leds[15] = 0;

   // green leds, first half
   assign mb_leds[0] = {leds[1][3:0],   leds[0][3:0]};
   assign mb_leds[2] = {leds[1][7:4],   leds[0][7:4]};
   assign mb_leds[4] = {leds[1][11:8],  leds[0][11:8]};
   assign mb_leds[6] = {leds[1][15:12], leds[0][15:12]};

   // green leds, second half
   assign mb_leds[8]  = {leds[3][3:0],   leds[2][3:0]};
   assign mb_leds[10] = {leds[3][7:4],   leds[2][7:4]};
   assign mb_leds[12] = {leds[3][11:8],  leds[2][11:8]};
   assign mb_leds[14] = {leds[3][15:12], leds[2][15:12]};

   wire [7:0]  mb_in;
   wire [5:0]  mb_addr;
   assign mb_in = mb_leds[mb_addr];

   reg [7:0]   i2c_tx_byte;
   reg [5:0]   more_bytes = 0;
   reg 		   i2c_transmit = 0;
   wire 	   i2c_is_transmitting;

   i2c_write #(.CLOCK_DIVIDE(`I2C_DIVIDE)) i2c (.clk(clk), .scl(scl), .sda(sda), .tx_byte(i2c_tx_byte), .transmit(i2c_transmit), .is_transmitting(i2c_is_transmitting), .more_bytes(more_bytes), .mb_in(mb_in), .mb_addr(mb_addr));

   reg [3:0]   i2c_init_step = 0;

   always @ (posedge clk) begin
	  if(i2c_is_transmitting || i2c_transmit)
		i2c_transmit <= 0;
	  else begin
		 if(i2c_init_step == 0) begin
			i2c_tx_byte <= 8'h21; // turn on oscillator
			i2c_transmit <= 1;
			i2c_init_step <= 1;
		 end else if(i2c_init_step == 1) begin
			i2c_tx_byte <= 8'h81; // display on, blink off
			i2c_transmit <= 1;
			i2c_init_step <= 2;
		 end else if(i2c_init_step == 2) begin
			i2c_tx_byte <= 8'hEF; // max brightness
			i2c_transmit <= 1;
			i2c_init_step <= 3;
		 end else if(i2c_init_step == 3) begin
			i2c_tx_byte <= 0;
			more_bytes <= 16;
			i2c_transmit <= 1;
			i2c_init_step <= 4;
		 end else begin
			i2c_transmit <= 1;
		 end
	  end
   end


   wire 	   received;
   wire [7:0]  rx_byte;
   reg 		   transmit = 0;
   reg  [7:0]  tx_byte = 0;
   wire 	   is_receiving;
   wire 	   is_transmitting;

   uart #(.CLOCK_DIVIDE(`UART_DIVIDE)) uart (.clk(clk), .rx(uart_rx), .tx(uart_tx), .received(received), .transmit(transmit), .tx_byte(tx_byte), .rx_byte(rx_byte), .is_receiving(is_receiving), .is_transmitting(is_transmitting));

   assign led[4] = state != `STATE_WASTE_TIME;
//   assign led[2:0] = rom_op == 6 ? rom_led : 0;
//   assign led[3] = refresh_leds || i2c_is_transmitting;
//   assign led[0] = (leds[0] == 16'h000f);
//   assign led[1] = (leds[0] == 16'h00f0);
//   assign led[2] = (leds[0] == 16'h0111);
//   assign led[3] = (leds[0] == 16'hf00f);


   //assign led[3:0] = saved_news[0][3:0];
   //assign led[3:0] = program_counter[3:0];
   assign led[0] = dont_send;
   assign led[1] = dont_wait;
   assign led[2] = is_transmitting;

   always @(posedge clk) begin
	  case(state)
		`STATE_SEND: begin
		   if(transmit) begin
			  transmit <= 0;
		   end else if(uart_ptr == 4) begin
			  uart_ptr <= 0;
			  if(dont_wait)
				state <= `STATE_WASTE_TIME;
			  else if(rom_op == 6) // `OP_ROUTE
				state <= `STATE_WAIT_NEWS;
			  else
				state <= `STATE_WAIT_PROPAGATE;
		   end else if(!is_transmitting && !dont_send) begin
			  tx_byte <= rom_output[uart_ptr * 8 +: 8];
			  sent_byte[uart_ptr] <= rom_output[uart_ptr * 8 +: 8];
			  transmit <= 1;
			  bytes_sent <= bytes_sent + 1;
			  uart_ptr <= uart_ptr + 1;
		   end
		end

		`STATE_WAIT_PROPAGATE: begin
		   if(received) begin
			  state <= `STATE_WASTE_TIME;
		   end
		end

		`STATE_WASTE_TIME: begin
		   if(waste_counter == 50000) begin
			  waste_counter <= 0;
			  if(program_counter == 255)
				program_counter <= main;
			  else
				program_counter <= program_counter + 1;
			  state <= `STATE_SEND;
		   end else
			 waste_counter <= waste_counter + 1;
		end

		`STATE_WAIT_NEWS: begin
		   /** On a route instruction, we:
			   - receive the instruction back
			   - receive the news
			   - propagate the news
			   - go to `STATE_WASTE_TIME
			*/
		   if(uart_ptr == 8) begin
			  state <= `STATE_PROPAGATE_NEWS;
			  uart_ptr <= 0;
		   end else if(received) begin
			  if(uart_ptr[2]) /* uart_ptr >= 4 */
				saved_news[uart_ptr[1:0]] <= rx_byte;
			  uart_ptr <= uart_ptr + 1;
		   end
		end // case: `STATE_WAIT_NEWS

		`STATE_PROPAGATE_NEWS: begin
		   if(transmit) begin
			  transmit <= 0;
		   end else if(uart_ptr == 4) begin
			  if(rom_led) begin
				 leds[rom_led - 1] <= (saved_news[1] << 8) + saved_news[0];
			  end
			  state <= `STATE_WASTE_TIME;
			  uart_ptr <= 0;
		   end else if(!is_transmitting && !dont_send) begin
			  tx_byte <= saved_news[uart_ptr];
			  sent_byte[uart_ptr] <= saved_news[uart_ptr];
			  transmit <= 1;
			  bytes_sent <= bytes_sent + 1;
			  uart_ptr <= uart_ptr + 1;
		   end
		end // case: `STATE_PROPAGATE_NEWS
	  endcase
   end

endmodule
Commit	Line	Data
	1	`include "pll.v"
	2	`include "master_rom.v"
	3	`include "i2c.v"
	4	`include "uart.v"
	5
	6	`ifdef SIM
	7	`define UART_DIVIDE 1
	8	`define I2C_DIVIDE 4
	9	`else
	10	`define UART_DIVIDE 1024
	11	`define I2C_DIVIDE 256
	12	`endif
	13
	14	module master(input CLKin, output [4:0] led, output uart_tx, input uart_rx, output reg busy_out = 0, input busy_in, output scl, output sda);
	15	wire clk;
	16
	17	assign clk = CLKin;
	18
	19	// ROM
	20
	21	reg [7:0] program_counter = 0;
	22	// go here at end of program
	23	reg [7:0] main = 1;
	24	wire [31:0] rom_output;
	25
	26	master_rom master_rom (.clk(clk), .addr(program_counter), .data(rom_output));
	27
	28	wire [2:0] rom_op = rom_output[26:24];
	29	wire [2:0] rom_led = rom_output[14:12];
	30	wire [3:0] rom_chip_select = rom_output[31:28];
	31
	32	// if the 4th board won't execute this instruction,
	33	// then we won't receive propagation or news
	34	wire dont_wait = !rom_chip_select[3];
	35	reg [25:0] dont_send = 23'b11111111111111111111111;
	36
	37	always @(posedge clk) begin
	38	if(busy_in)
	39	dont_send <= 21'b111111111111111111111;
	40	else if(dont_send)
	41	dont_send <= dont_send - 1;
	42	end
	43
	44	// state
	45
	46	`define STATE_SEND 0
	47	`define STATE_WAIT_PROPAGATE 1
	48	`define STATE_WAIT_NEWS 2
	49	`define STATE_PROPAGATE_NEWS 3
	50	`define STATE_SET_LEDS 4
	51	`define STATE_WASTE_TIME 5
	52
	53	reg [5:0] state = `STATE_SEND;
	54	reg [5:0] uart_ptr = 0;
	55
	56	reg [30:0] waste_counter = 0;
	57	reg [7:0] saved_news [3:0];
	58	reg [7:0] sent_byte [3:0];
	59
	60	reg [7:0] bytes_sent = 0;
	61
	62	// i2c
	63	reg [15:0] leds [3:0];
	64
	65	initial begin
	66	leds[0] <= 16'hF00F;
	67	leds[1] <= 16'h0000;
	68	leds[2] <= 16'h0000;
	69	leds[3] <= 16'hFFFF;
	70	end
	71
	72	/* even rows are green, odd rows are red:
	73	* mb_leds[2 * k] is the kth row of green leds
	74	* mb_leds[2 * k + 1] is the kth row of red leds
	75	*/
	76	wire [7:0] mb_leds [15:0];
	77
	78	// all red leds are off
	79	assign mb_leds[1] = program_counter;
	80	assign mb_leds[3] = 0;
	81	assign mb_leds[5] = state;
	82	assign mb_leds[7] = uart_ptr;
	83	assign mb_leds[9] = 0;
	84	assign mb_leds[11] = 0;
	85	assign mb_leds[13] = 0;
	86	assign mb_leds[15] = 0;
	87
	88	// green leds, first half
	89	assign mb_leds[0] = {leds[1][3:0], leds[0][3:0]};
	90	assign mb_leds[2] = {leds[1][7:4], leds[0][7:4]};
	91	assign mb_leds[4] = {leds[1][11:8], leds[0][11:8]};
	92	assign mb_leds[6] = {leds[1][15:12], leds[0][15:12]};
	93
	94	// green leds, second half
	95	assign mb_leds[8] = {leds[3][3:0], leds[2][3:0]};
	96	assign mb_leds[10] = {leds[3][7:4], leds[2][7:4]};
	97	assign mb_leds[12] = {leds[3][11:8], leds[2][11:8]};
	98	assign mb_leds[14] = {leds[3][15:12], leds[2][15:12]};
	99
	100	wire [7:0] mb_in;
	101	wire [5:0] mb_addr;
	102	assign mb_in = mb_leds[mb_addr];
	103
	104	reg [7:0] i2c_tx_byte;
	105	reg [5:0] more_bytes = 0;
	106	reg i2c_transmit = 0;
	107	wire i2c_is_transmitting;
	108
	109	i2c_write #(.CLOCK_DIVIDE(`I2C_DIVIDE)) i2c (.clk(clk), .scl(scl), .sda(sda), .tx_byte(i2c_tx_byte), .transmit(i2c_transmit), .is_transmitting(i2c_is_transmitting), .more_bytes(more_bytes), .mb_in(mb_in), .mb_addr(mb_addr));
	110
	111	reg [3:0] i2c_init_step = 0;
	112
	113	always @ (posedge clk) begin
	114	if(i2c_is_transmitting \|\| i2c_transmit)
	115	i2c_transmit <= 0;
	116	else begin
	117	if(i2c_init_step == 0) begin
	118	i2c_tx_byte <= 8'h21; // turn on oscillator
	119	i2c_transmit <= 1;
	120	i2c_init_step <= 1;
	121	end else if(i2c_init_step == 1) begin
	122	i2c_tx_byte <= 8'h81; // display on, blink off
	123	i2c_transmit <= 1;
	124	i2c_init_step <= 2;
	125	end else if(i2c_init_step == 2) begin
	126	i2c_tx_byte <= 8'hEF; // max brightness
	127	i2c_transmit <= 1;
	128	i2c_init_step <= 3;
	129	end else if(i2c_init_step == 3) begin
	130	i2c_tx_byte <= 0;
	131	more_bytes <= 16;
	132	i2c_transmit <= 1;
	133	i2c_init_step <= 4;
	134	end else begin
	135	i2c_transmit <= 1;
	136	end
	137	end
	138	end
	139
	140
	141	wire received;
	142	wire [7:0] rx_byte;
	143	reg transmit = 0;
	144	reg [7:0] tx_byte = 0;
	145	wire is_receiving;
	146	wire is_transmitting;
	147
	148	uart #(.CLOCK_DIVIDE(`UART_DIVIDE)) uart (.clk(clk), .rx(uart_rx), .tx(uart_tx), .received(received), .transmit(transmit), .tx_byte(tx_byte), .rx_byte(rx_byte), .is_receiving(is_receiving), .is_transmitting(is_transmitting));
	149
	150	assign led[4] = state != `STATE_WASTE_TIME;
	151	// assign led[2:0] = rom_op == 6 ? rom_led : 0;
	152	// assign led[3] = refresh_leds \|\| i2c_is_transmitting;
	153	// assign led[0] = (leds[0] == 16'h000f);
	154	// assign led[1] = (leds[0] == 16'h00f0);
	155	// assign led[2] = (leds[0] == 16'h0111);
	156	// assign led[3] = (leds[0] == 16'hf00f);
	157
	158
	159	//assign led[3:0] = saved_news[0][3:0];
	160	//assign led[3:0] = program_counter[3:0];
	161	assign led[0] = dont_send;
	162	assign led[1] = dont_wait;
	163	assign led[2] = is_transmitting;
	164
	165	always @(posedge clk) begin
	166	case(state)
	167	`STATE_SEND: begin
	168	if(transmit) begin
	169	transmit <= 0;
	170	end else if(uart_ptr == 4) begin
	171	uart_ptr <= 0;
	172	if(dont_wait)
	173	state <= `STATE_WASTE_TIME;
	174	else if(rom_op == 6) // `OP_ROUTE
	175	state <= `STATE_WAIT_NEWS;
	176	else
	177	state <= `STATE_WAIT_PROPAGATE;
	178	end else if(!is_transmitting && !dont_send) begin
	179	tx_byte <= rom_output[uart_ptr * 8 +: 8];
	180	sent_byte[uart_ptr] <= rom_output[uart_ptr * 8 +: 8];
	181	transmit <= 1;
	182	bytes_sent <= bytes_sent + 1;
	183	uart_ptr <= uart_ptr + 1;
	184	end
	185	end
	186
	187	`STATE_WAIT_PROPAGATE: begin
	188	if(received) begin
	189	state <= `STATE_WASTE_TIME;
	190	end
	191	end
	192
	193	`STATE_WASTE_TIME: begin
	194	if(waste_counter == 50000) begin
	195	waste_counter <= 0;
	196	if(program_counter == 255)
	197	program_counter <= main;
	198	else
	199	program_counter <= program_counter + 1;
	200	state <= `STATE_SEND;
	201	end else
	202	waste_counter <= waste_counter + 1;
	203	end
	204
	205	`STATE_WAIT_NEWS: begin
	206	/** On a route instruction, we:
	207	- receive the instruction back
	208	- receive the news
	209	- propagate the news
	210	- go to `STATE_WASTE_TIME
	211	*/
	212	if(uart_ptr == 8) begin
	213	state <= `STATE_PROPAGATE_NEWS;
	214	uart_ptr <= 0;
	215	end else if(received) begin
	216	if(uart_ptr[2]) /* uart_ptr >= 4 */
	217	saved_news[uart_ptr[1:0]] <= rx_byte;
	218	uart_ptr <= uart_ptr + 1;
	219	end
	220	end // case: `STATE_WAIT_NEWS
	221
	222	`STATE_PROPAGATE_NEWS: begin
	223	if(transmit) begin
	224	transmit <= 0;
	225	end else if(uart_ptr == 4) begin
	226	if(rom_led) begin
	227	leds[rom_led - 1] <= (saved_news[1] << 8) + saved_news[0];
	228	end
	229	state <= `STATE_WASTE_TIME;
	230	uart_ptr <= 0;
	231	end else if(!is_transmitting && !dont_send) begin
	232	tx_byte <= saved_news[uart_ptr];
	233	sent_byte[uart_ptr] <= saved_news[uart_ptr];
	234	transmit <= 1;
	235	bytes_sent <= bytes_sent + 1;
	236	uart_ptr <= uart_ptr + 1;
	237	end
	238	end // case: `STATE_PROPAGATE_NEWS
	239	endcase
	240	end
	241
	242	endmodule