import serial # pip install pyserial
import binascii # pip install binascii
try:
# Change Serial('COM Port to your environment')
ser = serial.Serial('COM5', 115200)
except serial.SerialException as e:
print(f"Error opening serial port: {e}")
exit(1)
while True:
if ser.readable():
s = ser.read(1) # Reading 1 byte at a time
hex_string = binascii.hexlify(s).decode('utf-8')
print(hex_string, end=" ")
if hex_string == 'fa':
print("\n")
Python 코드의 결과로 위 사진과 같은 hex 배열을 얻게 된다.
0x55 0xAA 는 헤더고, 0xFA 는 end sign 이다. 데이터시트를 보면 예시도 있으므로 참고하면 되겠다.
예시를 한 번 보자.
현재 아두이노 코드는 command 를 measuring distance 하나만 보내고 있다.
detect 되는 거리는 3cm ~ 2m 까지이기 때문에 최대 2000 mm 까지 감지 가능하다.
참고) 2000 은 0x07D0
참고) 앞에 나왔던 55 AA 81 03 에서 03 은 다음과 같음
03은 뒤에 나오는 parameter 길이
그럼 길이를 한번 다시 재본다.
코드는 다음과 같다.
import serial # pip install pyserial
import binascii # pip install binascii
idx = 0
distance = 0
try:
# Change Serial('COM Port to your environment')
ser = serial.Serial('COM5', 115200)
except serial.SerialException as e:
print(f"Error opening serial port: {e}")
exit(1)
while True:
if ser.readable():
s = ser.read(1) # Reading 1 byte at a time
hex_string = binascii.hexlify(s).decode('utf-8')
if idx == 4 or idx == 5:
# Append incoming hex values and convert to decimal
if idx == 4:
distance = int(hex_string, 16) << 8 # Shift left by 8 bits for the high byte
elif idx == 5:
distance += int(hex_string, 16) # Add the low byte value
print(f"Distance: {distance} mm") # Print the distance
if idx == 6 and hex_string != '00':
print("WARNING: Out of range!")
# Index increment
idx += 1
if hex_string == 'fa':
# Reset packet on end signal
idx = 0
distance = 0
print("\n")
정상적으로 출력되는 것을 볼 수 있다.
time.sleep() 을 사용해서 딜레이도 줘 봤는데, UART 통신이 뭔가 이상해져서 다시 뺐다.
from PIL import Image
import torchvision.transforms as transforms
import torch
image_path = "img.png"
image = Image.open(image_path)
transform = transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor()
])
image_tensor = transform(image)
image_tensor = image_tensor.unsqueeze(0)
tensor_values = image_tensor.numpy()
with open("tensor_values.txt", "w") as f:
for layer in tensor_values:
for row in layer:
for value in row:
f.write(f"{value} ")
f.write("\n")
f.write("\n")
tensor_value.txt
텍스트 파일을 보면 알 수 있는 점이 있다.
다시 그림을 한 번 보자.
보면 오른쪽으로 1픽셀 정도 치우쳐져 있는 그림이다.
값을 한 번 보자.
0.33 .. 값은 첫 번째를 1번이라고 했을 때 14번부터 16번의 값을 가진다!
28x28 의 정 중앙이 14 라는 점을 보았을 때, 딱 1픽셀 밀려 있는 것을 확인 가능하다.
이번에는
0.33 ... 값이 가득한 부분을 한 번 본다.
위에서 부터 1번 row 라고 했을 때 7번에 위치한다.
잘 보면 첫 번째만 값이 이상한데, 이는 의도된 그림이다. 그림을 다시 보면 가장 처음 픽셀만 살짝 연한 것을 볼 수 있다.
따라서, 이 정보들을 보면, 텐서는
저 방향으로 하나의 row 를 끝날 때까지 읽고, 끝나면 다음 row를 출력한다고 보면 되겠다.
그리고 총 형태를 보면,
이다. 우리가 지금까지 봤었던 것은 한 차원의 값이다. 아마 RGB 중 R 값을 본 것 같다.
이는 B의 0.33 ... 값을 보면 더 잘 알 수 있다.
이쪽 부분만 0.58431375 로 값이 같은 것을 알 수 있다.
처음에 값 지정할 때 #555595 로 설정했기 때문에 혼자만 다르게 나오는 것을 볼 수 있다.
커널이 있으면 위 사진처럼 계산도 가능하겠다.
이제 다시 넘파이 배열를 이미지로 변환해 볼 차례이다.
하나 예시를 들어보면, #999999의 RGB 값은 (153, 153, 153) 이다.
153 을 RGB 범위인 255로 나누게 되면 0.6 이라는 값이 나오게 된다.
#555595 는 어떨까? (85, 85, 149) 의 값을 가진다.
85를 RGB 범위인 255로 나누게 되면 0.33333... 의 값이 나온다.
컴퓨터에서는 32비트 범위에서 잘리게 되므로 약간의 소수점 변동이 생길 수 있다.
텐서의 경우 0.33333334 의 값을 가지게 되었다.
149를 255로 나눠보면?
0.5843137254 ... 값이 나온다. 이도 소수점 7번째 자리까지 동일한 값이 나오는 것을 확인 가능하다.
다르게 생각해 보면 R 채널에서는 회색 범위는 153의 값을 가지고, 보라색 범위는 85의 값을 가지는 텐서들로 이루어져 있다.
G 채널에서도 같다.
B 채널에서만 회색 범위가 153이라는 값을 가지고, 보라색 범위가 149의 값을 가지게 된다. 그래서 값 차이가 크게 나지 않는다.
아무튼 다시 이미지로 변경을 한다.
import torchvision.transforms as transforms
import torch
from PIL import Image
# Load the image
image_path = "./img.png"
image = Image.open(image_path)
# Define the transformation
transform = transforms.Compose([
transforms.ToTensor()
])
# Convert the image to a tensor
image_tensor = transform(image)
print(image_tensor.shape)
tf = transforms.ToPILImage()(image_tensor).show()
변형한 것이 없기 때문에 깔끔하게 다시 나온다.
이건 기존에 했던 이미지 - > 바이트 배열 -> 텐서 -> 넘파이 배열 -> 텐서 -> 이미지 변환이다.
from PIL import Image
import torchvision.transforms as transforms
import torch
import numpy as np
# 이미지 불러오기
image_path = "./img.png"
image = Image.open(image_path)
# 이미지 전처리
transform = transforms.Compose([
transforms.Resize((28, 28)), # 모델의 입력 크기로 리사이즈
transforms.ToTensor() # 텐서로 변환
])
image_tensor = transform(image) # 텐서 변환
image_tensor = image_tensor.unsqueeze(0) # 배치 차원 추가
# 텐서를 바이트 값으로 변환하여 바이트 파일로 저장
tensor_bytes = image_tensor.numpy().tobytes() # 텐서를 numpy 배열로 변환 후 바이트로 변환
# 바이트 파일 저장
with open("D:/tensor_values.bytes", "wb") as f:
f.write(tensor_bytes)
# 바이트 파일을 읽어 텐서로 변환
with open("D:/tensor_values.bytes", "rb") as f:
tensor_bytes = f.read()
# 바이트 데이터를 numpy 배열로 변환
tensor_array = np.frombuffer(tensor_bytes, dtype=np.float32)
tensor_array = tensor_array.reshape((1, 3, 28, 28)) # 원래 텐서의 형태로 변환
# numpy 배열을 텐서로 변환
reconstructed_tensor = torch.tensor(tensor_array)
# 텐서를 이미지로 변환
reconstructed_image = transforms.ToPILImage()(reconstructed_tensor.squeeze(0))
# 이미지 저장
reconstructed_image.save("D:/reconstructed_image.jpg")
import torch
from ultralytics import YOLO
# ------------ 모델 경로 및 파일 수정 시간은 수정하기 --------------
model_path = '../best.pt'
model_generated_time = " 24-06-04, 20:02"
# --------------------------------------------------------------
model = YOLO(model_path)
# 모델의 가중치 확인
model_weights = model.model.state_dict()
torch.set_printoptions(threshold=torch.inf)
idx = 0
while idx < len(model_weights):
name = list(model_weights.keys())[idx]
param = model_weights[name]
if "model." in name:
output_file = f"{name}.txt"
with open(output_file, "w") as f:
f.write("Weights Information:\n")
f.write("# weights ver.2\n\n")
f.write(f"Model Path: {model_path}\n")
f.write(f"Model Generated Time: {model_generated_time}\n\n")
f.write(f"Layer: {name} | Size: {param.size()}\n")
f.write(str(param) + "\n")
idx += 1
다음은 레이어 정보만 가져오는 코드임.
# 레이어 정보만 가져오기
import torch
from ultralytics import YOLO
# 모델 경로 및 파일 수정 시간 설정
model_path = '../best.pt'
model_generated_time = "24-06-04, 20:02"
# YOLO 모델 로드
model = YOLO(model_path)
# 모델의 가중치 확인
model_weights = model.model.state_dict()
# 레이어 정보를 저장할 파일 생성
with open("layers.txt", "w") as f:
f.write("Layer Information:\n")
f.write(f"Model Path: {model_path}\n")
f.write(f"Model Generated Time: {model_generated_time}\n\n")
# 각 레이어 정보를 파일에 기록
with open("layers.txt", "a") as f:
for idx, (name, param) in enumerate(model_weights.items()):
f.write(f"Layer {idx}:\n")
f.write(f"Name: {name}\n")
f.write(f"Size: {param.size()}\n")
from ultralytics import YOLO
# Load a model
model = YOLO("best.pt") # pretrained YOLOv8n model
# Run batched inference on a list of images
results = model(["peaches1.jpg", "peaches2.jpg", "peaches3.jpg", "plum1.jpg", "plum2.jpg"]) # return a list of Results objects
# Process results list
for result in results:
boxes = result.boxes # Boxes object for bounding box outputs
masks = result.masks # Masks object for segmentation masks outputs
keypoints = result.keypoints # Keypoints object for pose outputs
probs = result.probs # Probs object for classification outputs
obb = result.obb # Oriented boxes object for OBB outputs
result.show() # display to screen
result.save(filename="result.jpg") # save to disk
우리가 train 시킨 사과가 없으므로, no detection 이 뜨는 것이 당연하다.
다른 사과 이미지를 한 번 넣어본다.
train 시킨 사과 이미지와 다르면 된다.
학습 데이터가 적어서? detect 되지 않는 문제가 발생한다.
val 데이터를 한 번 넣어본다.
* val 데이터, train 데이터도 제대로 출력되지 않는다(?)
* yolov8n 모델로 돌리면 제대로 나온다.
* 데이터 학습이 제대로 안 되었다는 소리
아무튼 yolov8n 모델로 돌려 보았다.
yolov8n.pt
test 데이터는 더 있는데, 학습되지 않은 자두와 복숭아에 대해서 사과와 구분을 잘 못하는 모습을 보였다.
그래서, 다른 모델을 적용시켜 보기로 했다.
small, medium, large 까지만 사용해 보기로 했다.
yolov8s.pt
small 도 이상하다.
coco dataset 에 복숭아와 자두가 없는게 문제가 큰 것 같다.
yolov8m.pt
yolov8l.pt
train 시키지 않은 항목에 대해서 이미 있는것을 바탕으로 추측하고, 사과와 비슷하게 생겼기 때문에 사과로 인지하는 것 같다. 해당 사진은 '자두' 이다.
커스텀 데이터셋을 다시 train 시킬 필요가 있겠다.
epoch 를 60으로 늘렸다. train 데이터도 제대로 검출이 안 되기 때문.
아니면 항목이 하나밖에 없어서 그럴 수도 있다.
last.pt (epochs=60)
best.pt (epochs=60)
last 와 best 가 동일한 결과를 보였다.
이제 사과 비슷한 모양은 비슷하게 검출되는 것을 확인 가능하다. (best.pt 사용했다.)
Full code 도 첨부하도록 하겠다.
필요한 대로 수정하면서 사용하도록 한다.
# --------------------------------------------------
# from ultralytics import YOLO
# model = YOLO('yolov8n.pt')
# model.train(data="C:/Users/admin/Desktop/github/Apple Finder/data.yaml", epochs=60)
# --------------------------------------------------
# from ultralytics import YOLO
# import torch
# model = torch.load("./best.pt")
# print(model)
#----------------------------------------------------
### image predict
from ultralytics import YOLO
# Load a model
model = YOLO("best.pt") # pretrained YOLOv8n model
# Run batched inference on a list of images
# results = model(["app.jpg"]) # return a list of Results objects
results = model(["apple1.jpg",
"apple2.jpg",
"apple3.jpg",
"peaches1.jpg",
"peaches2.jpg",
"peaches3.jpg",
"plum1.jpg"])
# Process results list
for result in results:
boxes = result.boxes # Boxes object for bounding box outputs
masks = result.masks # Masks object for segmentation masks outputs
keypoints = result.keypoints # Keypoints object for pose outputs
probs = result.probs # Probs object for classification outputs
obb = result.obb # Oriented boxes object for OBB outputs
result.show() # display to screen
result.save(filename="result.jpg") # save to disk
#----------------------------------------------------------
WAIT_FRAME_START: begin //wait for VSYNC
FSM_state <= (!vsync) ? ROW_CAPTURE : WAIT_FRAME_START;
frame_done <= 0;
pixel_half <= 0;
end
VSYNC 가 1일 때 frame_start(현재 state) 를 유지하고, 0이면 ROW_CAPTURE state 로 넘어간다.
frame_done, pixel_half 는 아직 나온것이 없기 때문에 초기화 해 주는 내용이라고 생각하고 넘어간다.
ROW_CAPTURE: begin
FSM_state <= vsync ? WAIT_FRAME_START : ROW_CAPTURE;
frame_done <= vsync ? 1 : 0;
pixel_valid <= (href && pixel_half) ? 1 : 0;
if (href) begin
pixel_half <= ~ pixel_half;
if (pixel_half) pixel_data[7:0] <= p_data;
else pixel_data[15:8] <= p_data;
end
end
ROW_CAPTURE state 에서
VSYNC가 1이면 WAIT_FRAME_START, 0이면 ROW_CAPTURE(현재 유지)가 된다. 아까의 state 와 반대이다.
그리고, frame_done 도 VSYNC 에 따라 바뀐다.
VSYNC 가 1이 되면 state 를 프레임 시작을 기다리고, 현재 프레임을 끝났다 라고 생각하게 만든다. 라고 볼 수 있다.
href 가 활성화 된 경우
pixel_half 값 반전,
pixel_half 가 1이면 하위 8비트에 픽셀 데이터를 넣음.
pixel_half 가 0이면 상위 8비트에 픽셀 데이터를 넣음.
역시나 이것만으로는 동작에 대한 설명이 좀 부족하다.
vsync와 href 의 동작을 알아야 카메라에서 어떤 값을 어떤 방식으로 받아올 수 있는지 알 수 있을 것이다.
다음으로 ov7670_config.v 를 보도록 한다.(camera_configure.v 가 아니다)
module OV7670_config
#(
parameter CLK_FREQ = 25000000
)
(
input wire clk,
input wire SCCB_interface_ready,
input wire [15:0] rom_data,
input wire start,
output reg [7:0] rom_addr,
output reg done,
output reg [7:0] SCCB_interface_addr,
output reg [7:0] SCCB_interface_data,
output reg SCCB_interface_start
);
initial begin
rom_addr = 0;
done = 0;
SCCB_interface_addr = 0;
SCCB_interface_data = 0;
SCCB_interface_start = 0;
end
localparam FSM_IDLE = 0;
localparam FSM_SEND_CMD = 1;
localparam FSM_DONE = 2;
localparam FSM_TIMER = 3;
reg [2:0] FSM_state = FSM_IDLE;
reg [2:0] FSM_return_state;
reg [31:0] timer = 0;
always@(posedge clk) begin
case(FSM_state)
FSM_IDLE: begin
FSM_state <= start ? FSM_SEND_CMD : FSM_IDLE;
rom_addr <= 0;
done <= start ? 0 : done;
end
FSM_SEND_CMD: begin
case(rom_data)
16'hFFFF: begin //end of ROM
FSM_state <= FSM_DONE;
end
16'hFFF0: begin //delay state
timer <= (CLK_FREQ/100); //10 ms delay
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_SEND_CMD;
rom_addr <= rom_addr + 1;
end
default: begin //normal rom commands
if (SCCB_interface_ready) begin
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_SEND_CMD;
timer <= 0; //one cycle delay gives ready chance to deassert
rom_addr <= rom_addr + 1;
SCCB_interface_addr <= rom_data[15:8];
SCCB_interface_data <= rom_data[7:0];
SCCB_interface_start <= 1;
end
end
endcase
end
FSM_DONE: begin //signal done
FSM_state <= FSM_IDLE;
done <= 1;
end
FSM_TIMER: begin //count down and jump to next state
FSM_state <= (timer == 0) ? FSM_return_state : FSM_TIMER;
timer <= (timer==0) ? 0 : timer - 1;
SCCB_interface_start <= 0;
end
endcase
end
endmodule
처음 부분에서 초기화를 시키고 있다.
initial begin
rom_addr = 0;
done = 0;
SCCB_interface_addr = 0;
SCCB_interface_data = 0;
SCCB_interface_start = 0;
end
State 로 넘어간다.
FSM_IDLE: begin
FSM_state <= start ? FSM_SEND_CMD : FSM_IDLE;
rom_addr <= 0;
done <= start ? 0 : done;
end
start 입력이 들어오면 다음 state 인 FSM_SEND_CMD 로 넘어가고, 아니면 유지한다.
특이하게 done 값을 유지하고 있다. start 가 시작되면 다시 done 은 0으로 초기화된다.
FSM_SEND_CMD: begin
case(rom_data)
16'hFFFF: begin //end of ROM
FSM_state <= FSM_DONE;
end
16'hFFF0: begin //delay state
timer <= (CLK_FREQ/100); //10 ms delay
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_SEND_CMD;
rom_addr <= rom_addr + 1;
end
default: begin //normal rom commands
if (SCCB_interface_ready) begin
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_SEND_CMD;
timer <= 0; //one cycle delay gives ready chance to deassert
rom_addr <= rom_addr + 1;
SCCB_interface_addr <= rom_data[15:8];
SCCB_interface_data <= rom_data[7:0];
SCCB_interface_start <= 1;
end
end
endcase
end
rom_data 를 보고 FFFF signal(롬 종료 시그널) 이 오면 init command 보내는 것을 종료한다.
이 부분은 OV7670 내부 레지스터 초기 세팅을 하는 부분이라고 봐도 좋다.
여기도 따로 delay state 를 생성해 유지한다. FFF0 signal 이 오면 delay 10ms 만큼 delay 시킨다.
기본적으로는 SCCB interface ready flag가 뜨면 command 를 계속 보낸다.
rom 파일을 보게 되면 이상하게도 16비트가 나오는데, 앞은 reg address, 뒤는 value 로 나뉘는 것을 여기서 볼 수 있다.
결론은 rom 파일 내부 init command 를 모두 버스로 보내기 위해 사용하는 모듈이라고 보면 되겠다.
이런 경우 아마 내부에 ready 플래그를 둬서 start 입력에도 내부 동작이 끝나지 않았다면 동작하지 않게 만들 가능성이 크다.
SCCB interface 코드를 한 번 보도록 한다.
module SCCB_interface
#(
parameter CLK_FREQ = 25000000,
parameter SCCB_FREQ = 100000
)
(
input wire clk,
input wire start,
input wire [7:0] address,
input wire [7:0] data,
output reg ready,
output reg SIOC_oe,
output reg SIOD_oe
);
localparam CAMERA_ADDR = 8'h42;
localparam FSM_IDLE = 0;
localparam FSM_START_SIGNAL = 1;
localparam FSM_LOAD_BYTE = 2;
localparam FSM_TX_BYTE_1 = 3;
localparam FSM_TX_BYTE_2 = 4;
localparam FSM_TX_BYTE_3 = 5;
localparam FSM_TX_BYTE_4 = 6;
localparam FSM_END_SIGNAL_1 = 7;
localparam FSM_END_SIGNAL_2 = 8;
localparam FSM_END_SIGNAL_3 = 9;
localparam FSM_END_SIGNAL_4 = 10;
localparam FSM_DONE = 11;
localparam FSM_TIMER = 12;
initial begin
SIOC_oe = 0;
SIOD_oe = 0;
ready = 1;
end
reg [3:0] FSM_state = 0;
reg [3:0] FSM_return_state = 0;
reg [31:0] timer = 0;
reg [7:0] latched_address;
reg [7:0] latched_data;
reg [1:0] byte_counter = 0;
reg [7:0] tx_byte = 0;
reg [3:0] byte_index = 0;
always@(posedge clk) begin
case(FSM_state)
FSM_IDLE: begin
byte_index <= 0;
byte_counter <= 0;
if (start) begin
FSM_state <= FSM_START_SIGNAL;
latched_address <= address;
latched_data <= data;
ready <= 0;
end
else begin
ready <= 1;
end
end
FSM_START_SIGNAL: begin //comunication interface start signal, bring SIOD low
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_LOAD_BYTE;
timer <= (CLK_FREQ/(4*SCCB_FREQ));
SIOC_oe <= 0;
SIOD_oe <= 1;
end
FSM_LOAD_BYTE: begin //load next byte to be transmitted
FSM_state <= (byte_counter == 3) ? FSM_END_SIGNAL_1 : FSM_TX_BYTE_1;
byte_counter <= byte_counter + 1;
byte_index <= 0; //clear byte index
case(byte_counter)
0: tx_byte <= CAMERA_ADDR;
1: tx_byte <= latched_address;
2: tx_byte <= latched_data;
default: tx_byte <= latched_data;
endcase
end
FSM_TX_BYTE_1: begin //bring SIOC low and and delay for next state
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_TX_BYTE_2;
timer <= (CLK_FREQ/(4*SCCB_FREQ));
SIOC_oe <= 1;
end
FSM_TX_BYTE_2: begin //assign output data,
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_TX_BYTE_3;
timer <= (CLK_FREQ/(4*SCCB_FREQ)); //delay for SIOD to stabilize
SIOD_oe <= (byte_index == 8) ? 0 : ~tx_byte[7]; //allow for 9 cycle ack, output enable signal is inverting
end
FSM_TX_BYTE_3: begin // bring SIOC high
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_TX_BYTE_4;
timer <= (CLK_FREQ/(2*SCCB_FREQ));
SIOC_oe <= 0; //output enable is an inverting pulldown
end
FSM_TX_BYTE_4: begin //check for end of byte, incriment counter
FSM_state <= (byte_index == 8) ? FSM_LOAD_BYTE : FSM_TX_BYTE_1;
tx_byte <= tx_byte<<1; //shift in next data bit
byte_index <= byte_index + 1;
end
FSM_END_SIGNAL_1: begin //state is entered with SIOC high, SIOD high. Start by bringing SIOC low
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_END_SIGNAL_2;
timer <= (CLK_FREQ/(4*SCCB_FREQ));
SIOC_oe <= 1;
end
FSM_END_SIGNAL_2: begin // while SIOC is low, bring SIOD low
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_END_SIGNAL_3;
timer <= (CLK_FREQ/(4*SCCB_FREQ));
SIOD_oe <= 1;
end
FSM_END_SIGNAL_3: begin // bring SIOC high
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_END_SIGNAL_4;
timer <= (CLK_FREQ/(4*SCCB_FREQ));
SIOC_oe <= 0;
end
FSM_END_SIGNAL_4: begin // bring SIOD high when SIOC is high
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_DONE;
timer <= (CLK_FREQ/(4*SCCB_FREQ));
SIOD_oe <= 0;
end
FSM_DONE: begin //add delay between transactions
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_IDLE;
timer <= (2*CLK_FREQ/(SCCB_FREQ));
byte_counter <= 0;
end
FSM_TIMER: begin //count down and jump to next state
FSM_state <= (timer == 0) ? FSM_return_state : FSM_TIMER;
timer <= (timer==0) ? 0 : timer - 1;
end
endcase
end
endmodule
위의 테스트벤치에서 CLK_FREQ를 800, SCCB_FREQ를 20으로 제한했다.
initial begin
SIOC_oe = 0;
SIOD_oe = 0;
ready = 1;
end
내부 파라미터는 넘어가고, SIOC_oe, SIOD_oe, ready 를 init 에서 할당해주고 있다. 순차적으로 안 해도 될 것 같은 부분이다.
State machine 을 한 번 본다.
FSM_IDLE: begin
byte_index <= 0;
byte_counter <= 0;
if (start) begin
FSM_state <= FSM_START_SIGNAL;
latched_address <= address;
latched_data <= data;
ready <= 0;
end
else begin
ready <= 1;
end
end
IDLE 상태에서 입력(start)이 들어오면 다음 상태로 변화시키는 코드다.
기본 값들은 초기화 혹은 리셋 시켜주면서, 입력이 들어오면 현재 address, data 를 레지스터에 저장한다.
뒤에서 이 값들(latched_address, latched_data)을 변화시키는 부분이 없었으므로 계속 값을 가져갈 것으로 보인다.
START_SIGNAL 부분은 IDLE에서 start 입력이 들어오면 다음 클럭에서 state가 변화되는 부분이다.
특이하게 return state 를 지정하고 있는데, 이는 다음 state 인 TIMER 로 인해 필요한 부분이다.
또, timer 는 FPGA의 클럭과 버스를 동기화하기 위해 사용하고,
SIOC_oe(SCL) 은 0을 유지하고, SIOD_oe(SDA) 는 1로 올라간다. 이는 SCCB의 start signal이다.
I2C 와 다른 인터페이스인 이유이기도 하다.
FSM_TIMER: begin //count down and jump to next state
FSM_state <= (timer == 0) ? FSM_return_state : FSM_TIMER;
timer <= (timer==0) ? 0 : timer - 1;
end
자주 등장하는 TIMER state 를 본다.
다른 건 없고, 시간 때우기 용으로 넣어 놓은 state 라고 보면 좋다.
timer 가 0이 될 때 까지 현재 상태를 유지하는데, 이 때 SCL, SDA 값도 유지된다.
위의 waveform 에서 FSM_state 가 1100(decimal 값으로 12)에서 길게 유지하는 것을 볼 수 있다.
실제로 파형을 보면 timer 이외에는 FSM_state 가 1100(binary) 인 때는 움직이지 않고 유지하는 것을 볼 수 있음.
timer가 0이 되어 return_state 로 돌아가도록 한다.
현재 return_state 는 FSM_LOAD_BYTE 로 지정되어 있다.
FSM_LOAD_BYTE: begin //load next byte to be transmitted
FSM_state <= (byte_counter == 3) ? FSM_END_SIGNAL_1 : FSM_TX_BYTE_1;
byte_counter <= byte_counter + 1;
byte_index <= 0; //clear byte index
case(byte_counter)
0: tx_byte <= CAMERA_ADDR;
1: tx_byte <= latched_address;
2: tx_byte <= latched_data;
default: tx_byte <= latched_data;
endcase
end
FSM_state 가 byte_counter 가 3이면 분기하는 조건이 있는걸 봐선 여기서 바이트 카운터를 올리는 것이 있던지, 다른 state 에서 바이트 카운터를 올리는 옵션이 있을 것이다.
실제로 다음 코드에서 바이트코드를 증가시키는 코드가 있다.
그리고 뭔지 모르겠지만 바이트 인덱스를 0으로 만든다. 다른 곳에서 바이트 인덱스를 사용하고 여기 다시 돌아와서 뭔가 한다는 의미일 확률이 높겠다.
그리고 바이트카운터에 따라서 tx_byte 의 값을 조정한다.
CAMERA_ADDR 은 localparam 에서 42로 지정했다.
현재 LOAD_BYTE 에서의 값은 다음과 같다.
현재 막 LOAD_BYTE에 도착했다.
다음 클럭에서 바뀌는 값들을 보도록 한다.
FSM_state 는 byte_counter 가 3이 아니므로(0임) FSM_TX_BYTE_1
byte_counter 은 다음 클럭에 1로
byte_index 는 다음 클럭에 0으로
tx_byte 는 다음 클럭에 CAMERA_ADDR 의 값을 가짐.
non-blocking(<=) 이기 때문에 순차적 처리가 아닌 병렬 처리를 함.
실제 다음 클럭의 값임.
이번에 온 TX_BYTE_1 을 살펴본다.
FSM_TX_BYTE_1: begin //bring SIOC low and and delay for next state
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_TX_BYTE_2;
timer <= (CLK_FREQ/(4*SCCB_FREQ));
SIOC_oe <= 1;
end
다음 클럭에 SCL 을 변화시킨다. 실제로 통신을 시작하려는 부분임.
이 부분에서 SCL = 1, SDA = 1 이 되므로 통신 시작, 이제 8비트의 데이터를 보내고 1비트의 ACK 를 수신해야 함.
하지만 다음 state 가 TIMER 로 다시 간다.
이로 인해 SCCB 인터페이스와 FPGA 사이의 클럭 차이가 굉장히 많이 나기 때문에 클럭 손실이 크다.
따라서 I2C 를 느려터진 인터페이스라고 하는 이유다.
현재 코드 상에서는 시뮬레이션이 아닌, 기기에서의 클럭을 25Mhz, SCCB freq 를 100Khz 로 정의해 놓았다.
timer 에서 SCCB 주파수에 4를 곱하는 이유는 아마 I2C 처럼 고속 모드(400Khz) 지원을 위함이지 싶다.
아무튼 저 값을 나누면 62.5 가 나오는데 소수 버림으로 62 가 나온다.
아무것도 안하고 벌써 62 클럭을 2번이나 낭비했다.
아무튼 return state 를 TX_BYTE_2 로 정의하고 다시 timer 에 갔다 온다.
FSM_TX_BYTE_2: begin //assign output data,
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_TX_BYTE_3;
timer <= (CLK_FREQ/(4*SCCB_FREQ)); //delay for SIOD to stabilize
SIOD_oe <= (byte_index == 8) ? 0 : ~tx_byte[7]; //allow for 9 cycle ack, output enable signal is inverting
end
timer 에 갔다 다시 돌아온 state 다.
근데 다음 state 가 다시 timer 이다.
여기서는 잘 보니, 한 바이트에 대해 처리하고 있는 것을 볼 수 있다.
SDA 에 byte index 가 8(9번째 비트, ACK) 가 아니면 tx_byte[7]을 반전시켜 넣고 있다.
return state 를 TX_BYTE_3으로 지정하고 다시 timer 로 간다. (62*3)
FSM_TX_BYTE_3: begin // bring SIOC high
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_TX_BYTE_4;
timer <= (CLK_FREQ/(2*SCCB_FREQ));
SIOC_oe <= 0; //output enable is an inverting pulldown
end
이번에도 다음 state 는 TIMER 이다.
여기서는 SCL 을 0으로 바꾼다.
다른 건 없다.
return state 를 TX_BYTE_4 로 지정하고 다음 timer 로 간다. (62*4)
FSM_TX_BYTE_4: begin //check for end of byte, incriment counter
FSM_state <= (byte_index == 8) ? FSM_LOAD_BYTE : FSM_TX_BYTE_1;
tx_byte <= tx_byte<<1; //shift in next data bit
byte_index <= byte_index + 1;
end
byte index 가 8이 아니면(ack) 다시 TX_BYTE_1 로 돌아간다. 아니면 LOAD_BYTE 로 간다.
tx_byte 는 하나 shift 하는데, 이는 이미 우리가 반전시킨 tx_byte[7] 을 SDA 로 보냈기 때문이다.
그럼 이제 CAMERA_ADDRESS 를 SCCB interface 로 보내는 것이 완료 된 것이다.
그리고 다시 LOAD_BYTE 로 오게 된다.
byte_counter 에 따라, 3이 될 때 까지 반복한다. (기기 address, 내부 레지스터 address, 쓸 값)
3이 되었으면, END_SIGNAL_1 로 간다.
FSM_END_SIGNAL_1: begin //state is entered with SIOC high, SIOD high. Start by bringing SIOC low
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_END_SIGNAL_2;
timer <= (CLK_FREQ/(4*SCCB_FREQ));
SIOC_oe <= 1;
end
여기서는 통신을 종료하기 위해 STOP 시그널을 만드려는 쪽 같다.
SCL 을 1로 만든다.
return state 를 END_SIGNAL_2 로 지정하고, timer 로 간다.
파형으로 보면 저 위치이다.
자세하게 보면 이렇다.
FSM_END_SIGNAL_2: begin // while SIOC is low, bring SIOD low
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_END_SIGNAL_3;
timer <= (CLK_FREQ/(4*SCCB_FREQ));
SIOD_oe <= 1;
end
이번엔 SDA를 1로 만든다.
return state 를 END_SIGNAL_3 으로 지정하고 timer 로 간다.
파형은 다음과 같다.
FSM_END_SIGNAL_3: begin // bring SIOC high
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_END_SIGNAL_4;
timer <= (CLK_FREQ/(4*SCCB_FREQ));
SIOC_oe <= 0;
end
이번에 SCL 을 다시 0으로 만든다.
return state 를 END_SIGNAL_4 로 지정하고 timer 로 간다.
파형은 다음과 같다.
FSM_END_SIGNAL_4: begin // bring SIOD high when SIOC is high
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_DONE;
timer <= (CLK_FREQ/(4*SCCB_FREQ));
SIOD_oe <= 0;
end
마지막으로 SDA 를 0으로 내린다.
주석 적어놓은 거 보면 I2C 를 완전히 반대로 구현해 놓은 것과 동일한 것 같다.
timer 를 지나고, 마지막 done state 로 간다.
I2C를 보게 되면 마지막이 모두 HIGH로 끝나고, SCCB 는 정 반대이다.
FSM_DONE: begin //add delay between transactions
FSM_state <= FSM_TIMER;
FSM_return_state <= FSM_IDLE;
timer <= (2*CLK_FREQ/(SCCB_FREQ));
byte_counter <= 0;
end
Done state 는 다음 트랜잭션이 오기 전의 딜레이 역할을 한다.
딱히 byte_counter 를 초기화 안 해도 동작에는 지장이 없을 것 같다.(IDLE에서 초기화를 하기 때문)
