Published February 9, 2021 © GPL3+

FPGA Beginner Tool with Arduino Nano 33 BLE

Verilog quick learning. Feasibility model creation. Accurate logic volume estimation. I2C connection. Education purpose.

IntermediateFull instructions provided3,542

FPGA Beginner Tool with Arduino Nano 33 BLE

Things used in this project

Hardware components

Mouser Project

Arduino Nano 33 BLE

Hand tools and fabrication machines

Crowd Supply Reflo Air

Story

OUTLINE

The Arduino ecosystem has dramatically lowered the barriers to embedded system development.

As a next step, the FPGA (Field-programable gate array) further increases the potential of the system by offloading the portion of CPU work.

Resource savings associated with timers and frequent interrupts

Simplify and accelerate processing, lower power consumption

Release CPU power/resources for major processing such as AI

I expect this could significantly enhances the possibilities of Makers.

What exactly is the FPGA? What can FPGA do and what can't? To know that, I created an FPGA learning tool.

Short-term learning of Verilog (HDL:Hardware Description Language)

Creating a feasibility model

Get an accurate estimate of the logic volume

I hope that this tool will make the FPGA more accessible and will give Makers lots of new Make tips.

ON THE BOARD

USB connector for writing generated circuit data

Implemented components such as LEDs, IR transceiver/receiver, Tact switch, Piezo speaker

Connectors for connecting Servo Motor/DC Motor

Connectors for test points and external connections

Connector to attach Arduino Nano / Nano 33

WHAT YOU CAN DO

Automatic encoding/decoding/transfer of communication

Free the CPU from processing that requires direct control of CPU resources such as NeoPixel

Semi-automatic playback of buzzer sounds, etc

Motor Slow operation, acceleration/deceleration, trapezoidal control

Run with minimal CPU intervention

In any case, parameters / data can be exchanged with the CPU via I2C. (regardless of the CPU type. The results can also be used for Pi.)

These multiple processes are executed independently at the same time on the FPGA. It's an inspiring experience if you're used to programs that are processed serially or pseudo-parallel on the processor.

DEVELOP ENVIRONMENT

Lattice MachOX2 FPGA data sheet used for this board

I referred to here for the MachOX2 I2C library. thanks you. Craftsman Kodera-san

Install from IDE Diamond link (Windows only) This software is light, so you can use an old computer sleeping in a corner of the laboratory

Link to the writing tool Tiny FPGA Programmer. Just select the generated jed file and transfer it. To be honest, I think I had a lot of trouble without this. Thanks Mr. Valenty

fpga4fun.com it's amazing. My textbook. Thank you Mr. Jean P. Nicole

SIMPLE LOGIC ANALYZER/LED BLINK

You can start by blinking the LED, learn and check the operation by using a simple logic analyzer that uses the Arduino IDE Serial Plotter function.

You might imagine that you have to use a simulation tool or an oscilloscope, but even if you don't have it, you can do various things!

The figure shows the case of sampling at 40us. Can we monitor only signals around 10kHz?

However, if you operate it slowly and raise the clock after checking the logic, you can make a high-speed circuit.

A0 - pin9 Ex pin

A1 - pin14 Ex pin

A2 - pin17 IR Transmitter

A3 - pin8 Buzzer

A6 - pin12 Servo Motor

A7 - pin13 Ex pin

PROGRAM YOURS

Now it's time to deploy to your system.

This board also has an external writing function.

Switch Jumper plugs, and connect your system to GO.

NEXT STEP

In the previous Arduino Nano 33 BLE OV7670 Camera Shield, in order to resolve conflicts such as camera real-time image processing operation and servo control interrupts, a PWM-dedicated IC (PCA9685) was implemented and 10-bit servo control via I2C was adopted.

However, even with this, the sweep operation of the servo required MPU intervention (sequential update of the servo angle during movement) that interrupted image processing every several tens of ms.

Therefore, based on this learning, I will use FPGA to perform slow panning or semi-automatic control of foot acceleration / deceleration moving.

The next report will show how much the CPU can concentrate on image processing while performing related operations at the same time.

*PARTS LIST

Schematics

Code

 /*******************************************************************
 * SYSTEM CLOCK                                                     *
 ********************************************************************/
wire CLK;  // base clock 29.56MHz 33.25ns
OSCH #(.NOM_FREQ("29.56")) internal_oscillator_inst (.STDBY(1'b0), .OSC(CLK)); //  
assign clk = CLK;
 /*******************************************************************
 * RGB LED controller                                               *
  [11:8](byte cont RGB+5byte blank) [7:5](8bit cntr) [4:0](0(10/22), 1(16/16) plse form)
 _|-200-500ns-|__650--950ns______| "0"  _|--550--650ns---|__450--750ns__| "1" 
 -|___//__>50us(*1024)__|-- "reset"    G-R-B 24bit  
 *******************************************************************/
reg rgbOUT;    	    // output signal
reg [23:0] RGBreg;	// 8bit x 3 RGB color set through I2C
reg [11:0] ctRGB;	// rgb clock(33.25ns) counter
reg [4:0] dptn; 		// data pattern "0/1" compare reg
always @(posedge clk) begin ctRGB <= ctRGB + 1;
  if(ctRGB[11:8] == 4'b0000 || ctRGB[11:8] == 4'b0001 || ctRGB[11:8] == 4'b0010) begin
  if(RGBreg[ctRGB[9:5]] == 0)	dptn <= 5'b01010; 	// "0" rgbout = 1'b1; 360/800
	else 							dptn <= 5'b10001; 	// "1" rgbout = 1'b1; 580/600
	      rgbOUT = ctRGB[4:0] < dptn[4:0];				// data pattarn control
	end else rgbOUT = 1'b0;     							// "0" reset mode
end
assign RGB = rgbOUT;	// pin23
 /*******************************************************************
 * BUZZ controll                                                    *
 ********************************************************************/
reg speaker;		// sound pulse
reg [27:0] tone;
always @(posedge clk) tone <= tone+1;
wire [6:0] fastsweep = (tone[22] ? tone[21:15] : ~tone[21:15]);
wire [6:0] slowsweep = (tone[25] ? tone[24:18] : ~tone[24:18]);
wire [14:0] clkdivider = {2'b01, (tone[27] ? slowsweep : fastsweep), 6'b000000};

reg [14:0] counter;
always @(posedge clk) if(counter==0) counter <= clkdivider; else counter <= counter-1;

always @(posedge clk) if(counter==0 && Enable) speaker <= ~speaker;
assign BUZ = speaker;
 /*******************************************************************
 * SERVO controller     0.5ms---1.5ms---2.5ms                       *
      ____________ _________                                        ______
 ____|set         ^         |reset__________reset____//____reset___|set  ^ 
 con=0xAEFE  con=0xB4A2->0  con[11:2]==act[9:0] 0x0000-0x2d0(0-2ms) con=0xAEFE
 ********************************************************************/
reg [3:0] svOUT;    	   						 	// output signalx4 lines
parameter CYCL = 20'h80000;						// 16ms Servo cycle
parameter PPAL = 16'h3f00;						// 0.5ms Pre Pulse    
reg [19:0] svREG; 	     						// Servo base counter
  
reg [7:0] svTGT[3:0];							// 8bit I2C reg
reg [9:0] svCRT[3:0];							// 10bit current count up
reg [9:0] svocpm; 								// set speed by I2C 
always @(posedge clk) begin svREG <= svREG + 1; // timer count up
	//-20bit----[4bit----10bit---6bit]-----------------------------
if(svREG < {4'h0, svCRT[0], 6'h0}) svOUT[0] <= 1'b1; else svOUT[0] <= 1'b0; // PULSE GENERATE0
if(svREG < {4'h0, svCRT[1], 6'h0}) svOUT[1] <= 1'b1; else svOUT[1] <= 1'b0; // PULSE GENERATE1
if(svREG < {4'h0, svCRT[2], 6'h0}) svOUT[2] <= 1'b1; else svOUT[2] <= 1'b0; // PULSE GENERATE2
if(svREG < {4'h0, svCRT[3], 6'h0}) svOUT[3] <= 1'b1; else svOUT[3] <= 1'b0; // PULSE GENERATE3	
	//----------------------------------------------------------
if(svREG > CYCL - PPAL + 3000) svOUT <= 4'hf;	// BASE 0.5ms PULSE
if(svREG > CYCL) svREG <= 0; 					// END CYCLE
end
reg SVCOMP;				// complete   
always @(posedge clk) begin 
svocpm <= 8'b00010000; // set data from I2C
if({svTGT[0], 2'b00} == svCRT[0] && {svTGT[1], 2'b00} == svCRT[1] &&
	{svTGT[2], 2'b00} == svCRT[2] && {svTGT[3], 2'b00} == svCRT[3]) SVCOMP <= 1'b1;
else SVCOMP <= 1'b0;	// SEEK COMPLETE		 
end	
 /***********************************************************************
 * IR receiver                  32bit from MSB to LSB
 --|_9ms_start_|-4ms-|_600us_|-("0")600us-|_600us_|-("1")1600us-|_600us_stop_|-- 
 ***********************************************************************/
  wire IRn; reg IRnn;
  reg [7:0] rep;				// decoded 8bit char data (to I2C)
  reg [19:0] ctirL, ctirH; 	// rgb clock(33.8ns) counter 4000us
  reg ena, pena;				// enable gate flags

  reg [7:0] IRcntL, IRcntH;	// input signal glidge reduction
  always @(posedge clk) begin 	// remove glidge
	if(IRn == 0) begin IRcntL <= IRcntL + 1; IRcntH <= 0;	end
	if(IRn == 1) begin	IRcntH <= IRcntH + 1; IRcntL <= 0;	end
	if(IRcntL > 20) IRnn <= 0;
	if(IRcntH > 20) IRnn <= 1;
  end
  
  reg flgg, flgg2;			// monitor flag
  reg [31:0] IRreg; 		// 32bit receive data buffer
  reg [5:0] irseq; 			// ir receive sequence 
  always @(posedge clk) begin		// enable signal from Startbit && H
	if(ctirH > 20'h30000) begin pena <= 0; ena <= 1'b0; irseq <= 0; 	end // idle
	if(ctirL > 20'h30000) begin pena <= 1;  						end // prenable
	if(pena == 1 && IRnn == 1) begin ena  <= 1'b1; 			end	// enable
	if(irseq == 1) flgg2 <= 1'b1;											// debug flag
	// receive 32 bit data
	if(ena == 1) 	begin
	if(IRnn == 0) 	begin	// "L" ---- 
		if(ctirL == 0) begin flgg <= 1'b0;
			if(irseq > 0) begin
			if(ctirH > 18'h4557) 	begin IRreg[32-irseq[5:0]] = 1'b1; end // > 600us 
			else                 	begin IRreg[32-irseq[5:0]] = 1'b0; end // < 600us	
			if(irseq == 32) begin flgg2 <= 1'b0;			
				case(IRreg[31:0]) // decode data 32bit >> char 8bit
					32'h00FFA25D: rep <= 8'h31; // "1(0x31)" 
					32'h00FF629D: rep <= 8'h32; // "2(0x32)" 
					32'h00FFE21D: rep <= 8'h33; // "3(0x33)" 
					32'h00FF22DD: rep <= 8'h34; // "4(0x34)" 
					32'h00FF02FD: rep <= 8'h35; // "5(0x35)" 
					32'h00FFC23D: rep <= 8'h36; // "6(0x36)" 
					32'h00FFE01F: rep <= 8'h37; // "7(0x37)" 
					32'h00FFA857: rep <= 8'h38; // "8(0x38)"
					32'h00FF906F: rep <= 8'h39; // "9(0x39)" 
					32'h00FF9867: rep <= 8'h30; // "0(0x30)" 
					32'h00FF6897: rep <= 8'h2A; // "*(0x2A)" 
					32'h00FFB04F: rep <= 8'h23; // "#(0x23)" 
					32'h00FF18E7: rep <= 8'h55; // "U(0x55)" 
					32'h00FF4AB5: rep <= 8'h44; // "D(0x44)" 
					32'h00FF10EF: rep <= 8'h4C; // "L(0x4C)" 
					32'h00FF5AA5: rep <= 8'h52; // "R(0x52)" 
					32'h00FF38C7: rep <= 8'h4B; // "K(0x4B)"
				endcase			
			end
			end
		end
	end else  		begin	// "H" ----	
		if(ctirH == 0) begin flgg <= 1'b1;
			irseq <= irseq + 1;			// next step	
		end
	end
	end
	// L/H pulse width counters
	if(IRnn == 0) 	begin				// "L" ---- 
		if(ctirL != 0) ctirH <= 0; 	// first entry after H >> L(counter == 0)
		if(ctirL < 20'h45000) ctirL <= ctirL + 1; 	// "L" timer count up	
	end else  		begin				// "H" ----	
		if(ctirH != 0) ctirL <= 0; 	// first entry after L >> H(counter == 0)
		if(ctirH < 20'h45000) ctirH <= ctirH + 1; 	// "H" timer count up
	end
  end
  assign IRp = IRn;					// pin21

// ============================================
// MEDAMA/4Legged ROBOT CONTROL program
//  for Arduino nano 33 (Sense) https://store.arduino.cc/usa/nano-33-ble-sense
// ============================================
#include "para.h"               // parameter/memo
 UART mySerial(digitalPinToPinName(A5), digitalPinToPinName(A4), NC, NC); // uart TX(A5->[28])/RX(A4<-[27])
// ============================================
// SETUP     +fpga--+
//    IR--->21      23--->RGB             
//    SW--->20      11--->LED1
//           |      10--->LED2
//           |       4-+->LED3
//           |      |  +---->DCM PH
//           |       5------>DCM EN  +-nano33-+
//           |      12--->SVO------->A6       |   
//           |      17->IR TR------->A2       |
//           |       9<-->TP1<------>A0       |
//           |       8<->TP2/BUZZ<-->A3       |
//           |      14<-->TP3<------>A1       |
//           |      13<-->TP4<------>A7       |
//           |   RX 28<--(SCL)<------A5 TX    |
//           |   TX 27-->(SDA)------>A4 RX    |
//           +------+                 +-------+
// ============================================
void setup() {
  pinMode(13, OUTPUT);          // nano 33 on board LED(D13)  
  Serial.begin(9600);           // serial monitor
  //mySerial.begin(14400);        // 14400 69.6us/bit (11bit 67.8us) 28800 34.8us/bit (10bit 33.9us)
  //                              // 57600 17.4us/bit ( 9bit 17us), 115200  8.7us/bit ( 8bit  8.5us) 
  //mySerial.begin(115200);        // 115200  8.7us/bit (8.5us)                                  
  //mySerial.print(0x01, HEX);                                 
}
// ============================================
// EZ logic analyzer
long itime; int tgll;
#define NofP 500
// ============================================
int  memo[NofP];   // raw
int  chA[NofP];    // raw
int  chB[NofP];    // raw
int  chC[NofP];    // raw
int  chD[NofP];    // raw
int  chE[NofP];    // raw
int  chF[NofP];    // raw
int  cc; int tgl;
void loop() {
      while(!digitalRead(A3)) {   }      // Trigger
      for(int n = 0; n < NofP; n++) { 
         cc++; if(cc > 10) { cc = 0; tgl = !tgl; }
         chA[n] = digitalRead(A0) + 3;    // [9] TP1
         chB[n] = digitalRead(A1) + 5;    // [14] TP3
         chC[n] = digitalRead(A2) + 7;    // [17] 
         chD[n] = digitalRead(A3) + 9;    // [8] TP2/BUZZ
         chE[n] = digitalRead(A6) + 11;   // [12] SVO   
         chF[n] = digitalRead(A7) + 13;   // [13] TP4      
         memo[n]  = tgl + 1;
         delayMicroseconds(20); // sampling rate
      }  
      for(int n = 0; n < NofP; n++) { 
         Serial.print(memo[n]);   Serial.print("\t");         
         Serial.print(chA[n]);    Serial.print("\t"); 
         Serial.print(chB[n]);    Serial.print("\t");
         Serial.print(chC[n]);    Serial.print("\t"); 
         Serial.print(chD[n]);    Serial.print("\t"); 
         Serial.print(chE[n]);    Serial.print("\t"); 
         Serial.print(chF[n]);    Serial.println(""); 
      }     
}

Credits

ebaera

0 projects • 11 followers

FPGA Beginner Tool with Arduino Nano 33 BLE

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

OUTLINE

ON THE BOARD

WHAT YOU CAN DO

DEVELOP ENVIRONMENT

SIMPLE LOGIC ANALYZER/LED BLINK

PROGRAM YOURS

NEXT STEP

Custom parts and enclosures

Gerber data

3D print data

Schematics

Schematic Drawing

Code

Sample code

EZ Logic Analyzer

Credits

ebaera

Comments

Embed the widget on your own site

FPGA Beginner Tool with Arduino Nano 33 BLE

FPGA Beginner Tool with Arduino Nano 33 BLE

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

OUTLINE

ON THE BOARD

WHAT YOU CAN DO

DEVELOP ENVIRONMENT

SIMPLE LOGIC ANALYZER/LED BLINK

PROGRAM YOURS

NEXT STEP

Custom parts and enclosures

Gerber data

3D print data

Schematics

Schematic Drawing

Code

Sample code

EZ Logic Analyzer

Credits

ebaera

Comments

Related channels and tags