hong.com

Final
- 2025-08-06
- 2025-08-07
- 2025-08-08
- 2025-08-11
- 2025-08-12
- 2025-08-13
- 2025-08-14
- 2025-08-18
- 2025-08-19
- 2025-08-20
- 2025-08-21
- 2025-08-27
- 2025-08-28
- 2025-08-29
- 2025-09-01
- 2025-09-02
- 2025-09-03
- 2025-09-04
- 2025-09-05
- 2025-09-08
- 2025-09-09
- 2025-09-10
- 2025-09-11
Project
- C Language
  - game instructions
- FFT
  - game instructions
Study
- C Language
- Linux
  - Day1
  - Day2
  - Day3
  - Day4
  - Day5
  - Day6
  - Day7
  - Day8
  - SKIN_Project copy
  - SKIN_Project
  - perceptron
- System Verilog
  - Day1
  - Day2
  - Day3
- VLSI Circuits Design
Home

Contact

Copyright © 2024 | Yankos

Home > Final

💖 星野アイ (◍•ᴗ•◍)♡ ✧*。

Final

2025-09-11
매번 비트스트림하지 않고 보드 켜면 바로 올릴 수 있는 방법 비트스트림 만든 걸 보드에 다운로드해서 저장 SPI Quad mode Flash : 비트스트림 다운받은 걸 읽어옴 Settings -> Bitstream -> -bin_file (Check) Generate Bitstream -> binary 파일을 만들어서 Flash Memory 에 저장 Path : “C:\Working\FPGA_AI_25_2\250910_VGA_OV7670\250910_VGA_OV7670.runs\impl_1\VGA_Camera_Display.bin” Open Target Add Configuration Memory Device -> (Basys3) Manufacturer = Macronix, Density = 32, Name = mx25l3233f-spi-x1_x2_x4 (OK) mx25l3233f-spi-x1_x2_x4 우클릭 -> Program Configuration Memory Device -> Configuration file -> VGA_Camera_Display.bin (OK) FPGA 보드 재부팅 시 Roding 할 시간이 필요함 (QSPI Flash Mode, 전원인가 시 Data Loading 시간이 10초~1분 정도)
Final · 2025-09-11
2025-09-10
HW Setting < ov7670 datasheet > SCCB 인터페이스로 통신 = I2C 최대 30 frames RGB565/555/444 지원 자체 Clock이 없기 때문에 외부 Clock을 써야함 (XCLK) porch가 없음. posedge에서 HREF = 1 이고 이때 나오는 Data 유효 640, 480 라인존재 VSYNC=H : 1 Frame이 끝나고 다음 Line을 받음 Back Porch, Front Porch 사이의 영상처리를 끝내야 함, Line Buffer 필요 RGB565 : 16bit Data Format First Byte(8bit) + Second Byte(8bit) = Pixel Data(16bit) Pixel Data Bit = | 76543 | 210 / 765 | 43210 | HREF=H, VSYNC=L 일때 Data 받음 < Block Diagram> 수정 필요함 Data 2번 받아서 Memory 에 1번 저장 (8bit, 8bit 받아서 16bit 저장) 각 Data 마다 구분이 필요함 16bit 를 다 받았을 때 Address와 Data, WriteEnable 신호를 내보냄 한 Frame 에 대해 내보낸 신호를 처리할 때는 VGA Decoder 에서 Pclk을 받아서 Frame Buffer 에서 Read Clock 으로 사용 Frame Buffer 를 기준으로 좌, 우는 다른 클럭이다.(Camera Domain, VGA Display Domain) -> CDC (Clock Domain Crossing) 카메라에서는 QVGA로 들어옴 < STM32 CubeIDE > 초반에 카메라 내부 설정을 STM32에서 내려주기 위해 작업 STM32 create Project f411re 검색 후 STM32F411RETx LQFP64 < 기본설정 > System Core -> RCC (Clock 설정) : HSE = Crystal/Ceramic Resonator Connectivity -> USART2 (Uart 설정) : Mode = Asynchronous Connectivity -> I2C1 (I2C 설정) : I2C = I2C Clock Configuration 들어가서 설정 톱니바퀴모양 클릭 -> C코드가 자동으로 생성됨 /* USER CODE BEGIN Header */ /** ****************************************************************************** * @file : main.c * @brief : Main program body ****************************************************************************** * @attention * * Copyright (c) 2025 STMicroelectronics. * All rights reserved. * * This software is licensed under terms that can be found in the LICENSE file * in the root directory of this software component. * If no LICENSE file comes with this software, it is provided AS-IS. * ****************************************************************************** */ /* USER CODE END Header */ /* Includes ------------------------------------------------------------------*/ #include "main.h" /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ /* USER CODE END Includes */ /* Private typedef -----------------------------------------------------------*/ /* USER CODE BEGIN PTD */ /* USER CODE END PTD */ /* Private define ------------------------------------------------------------*/ /* USER CODE BEGIN PD */ /* USER CODE END PD */ /* Private macro -------------------------------------------------------------*/ /* USER CODE BEGIN PM */ /* USER CODE END PM */ /* Private variables ---------------------------------------------------------*/ I2C_HandleTypeDef hi2c1; UART_HandleTypeDef huart2; /* USER CODE BEGIN PV */ /* USER CODE END PV */ /* Private function prototypes -----------------------------------------------*/ void SystemClock_Config(void); static void MX_GPIO_Init(void); static void MX_I2C1_Init(void); static void MX_USART2_UART_Init(void); /* USER CODE BEGIN PFP */ /* USER CODE END PFP */ /* Private user code ---------------------------------------------------------*/ /* USER CODE BEGIN 0 */ /* USER CODE END 0 */ /** * @brief The application entry point. * @retval int */ int main(void) { /* USER CODE BEGIN 1 */ /* USER CODE END 1 */ /* MCU Configuration--------------------------------------------------------*/ /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ HAL_Init(); /* USER CODE BEGIN Init */ /* USER CODE END Init */ /* Configure the system clock */ SystemClock_Config(); /* USER CODE BEGIN SysInit */ /* USER CODE END SysInit */ /* Initialize all configured peripherals */ MX_GPIO_Init(); MX_I2C1_Init(); MX_USART2_UART_Init(); /* USER CODE BEGIN 2 */ /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); HAL_Delay(300); /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ } /* USER CODE END 3 */ } /** * @brief System Clock Configuration * @retval None */ void SystemClock_Config(void) { RCC_OscInitTypeDef RCC_OscInitStruct = {0}; RCC_ClkInitTypeDef RCC_ClkInitStruct = {0}; /** Configure the main internal regulator output voltage */ __HAL_RCC_PWR_CLK_ENABLE(); __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1); /** Initializes the RCC Oscillators according to the specified parameters * in the RCC_OscInitTypeDef structure. */ RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE; RCC_OscInitStruct.HSEState = RCC_HSE_ON; RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE; RCC_OscInitStruct.PLL.PLLM = 4; RCC_OscInitStruct.PLL.PLLN = 100; RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2; RCC_OscInitStruct.PLL.PLLQ = 4; if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) { Error_Handler(); } /** Initializes the CPU, AHB and APB buses clocks */ RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2; RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2; RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1; if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK) { Error_Handler(); } } /** * @brief I2C1 Initialization Function * @param None * @retval None */ static void MX_I2C1_Init(void) { /* USER CODE BEGIN I2C1_Init 0 */ /* USER CODE END I2C1_Init 0 */ /* USER CODE BEGIN I2C1_Init 1 */ /* USER CODE END I2C1_Init 1 */ hi2c1.Instance = I2C1; hi2c1.Init.ClockSpeed = 100000; hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2; hi2c1.Init.OwnAddress1 = 0; hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE; hi2c1.Init.OwnAddress2 = 0; hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE; hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE; if (HAL_I2C_Init(&hi2c1) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN I2C1_Init 2 */ /* USER CODE END I2C1_Init 2 */ } /** * @brief USART2 Initialization Function * @param None * @retval None */ static void MX_USART2_UART_Init(void) { /* USER CODE BEGIN USART2_Init 0 */ /* USER CODE END USART2_Init 0 */ /* USER CODE BEGIN USART2_Init 1 */ /* USER CODE END USART2_Init 1 */ huart2.Instance = USART2; huart2.Init.BaudRate = 115200; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX_RX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart2.Init.OverSampling = UART_OVERSAMPLING_16; if (HAL_UART_Init(&huart2) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN USART2_Init 2 */ /* USER CODE END USART2_Init 2 */ } /** * @brief GPIO Initialization Function * @param None * @retval None */ static void MX_GPIO_Init(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; /* USER CODE BEGIN MX_GPIO_Init_1 */ /* USER CODE END MX_GPIO_Init_1 */ /* GPIO Ports Clock Enable */ __HAL_RCC_GPIOH_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); /*Configure GPIO pin Output Level */ HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET); /*Configure GPIO pin : PA5 */ GPIO_InitStruct.Pin = GPIO_PIN_5; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USER CODE BEGIN MX_GPIO_Init_2 */ /* USER CODE END MX_GPIO_Init_2 */ } /* USER CODE BEGIN 4 */ /* USER CODE END 4 */ /** * @brief This function is executed in case of error occurrence. * @retval None */ void Error_Handler(void) { /* USER CODE BEGIN Error_Handler_Debug */ /* User can add his own implementation to report the HAL error return state */ __disable_irq(); while (1) { } /* USER CODE END Error_Handler_Debug */ } #ifdef USE_FULL_ASSERT /** * @brief Reports the name of the source file and the source line number * where the assert_param error has occurred. * @param file: pointer to the source file name * @param line: assert_param error line source number * @retval None */ void assert_failed(uint8_t *file, uint32_t line) { /* USER CODE BEGIN 6 */ /* User can add his own implementation to report the file name and line number, ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */ /* USER CODE END 6 */ } #endif /* USE_FULL_ASSERT */ 망치질 하면 깜빡거림 재생버튼, OK 누르면 다운로드함 (Upgrage) 보드동작완! drag and drop : OV7670.c -> 250910_OV7670/Core/Src drag and drop : OV7670.h, OV7670_REG.h -> 250910_OV7670/Core/Src /* USER CODE BEGIN Includes */ #include "OV7670.h" // ... /* USER CODE BEGIN 2 */ OV7670_Init(&hi2c1); OV7670_ResetSW(); OV7670_SetResolution(QVGA); OV7670_SetColorFormat(RGB565); OV7670_ShowColorBar(1); main.c 에 코드 추가 후 프로그램 올리고 Vivado 로 돌아와서 xdc 파일 생성 xdc 파일에서 ov7670_pclk을 JB10 으로 옮기고 다시 Bitstream /* USER CODE BEGIN 2 */ OV7670_Init(&hi2c1); OV7670_ResetSW(); OV7670_SetResolution(QVGA); OV7670_SetColorFormat(RGB565); //OV7670_ShowColorBar(1); OV7670_AutoExposureMode(1); OV7670_SetBrightness(120); OV7670_AutoGainMode(1); ShowColorBar 대신 카메라 인식시킴. 마무리 stm32 nucleo-f411re 보드를 FPGA에서 동작시켜야 함. 설정파일에 대한 정보를 롬파일에 다 넣어야함 (SCCB Interface) 역할 잘 나눠서 필터설계, 롬파일 등등 < 파일 > sources (HW) VGA_Camera_Display.sv OV7670_MemController.sv frame_buffer.sv VGA_MemController.sv GrayScaleFilter.sv VGA_Decoder.sv constrs (HW) Basys-3-Master.xdc
Final · 2025-09-10
2025-09-09
MUX -> Switch Color / Color Bar < Block Diagram> color bar 모듈 따로 만들고 탑에서 먹스추가해서 결과잘나옴 < 파일 > sources (Class) VGA_Display_Switch.sv VGA_Decoder.sv VGA_RGB_SWITCH.sv VGA_Color_Bar.sv constrs (Class) Basys-3-Master.xdc ROM 에 이미지 넣어서 고고 이미지 데이터는 16bit data, 보통 RGB888 RGB565 씀 알씨 다운로드 ezBMP.exe Tool 다운로드 < ImgROM 추가 > (0,0) … (639,0) (0,2) … (639,1) < ImgReader 추가 > RGB565 -> RGB444로 하위비트를 잘라줘야 함 (빛 data 적음) 또한 ROM 사이즈 640x480 가 안나와서 320x240 로 자르거나 낮춰야함 < 알씨 > 꾸미기 자르기 4:3 적용 (자르기 비율 유지, 가로로 길게) 크기변경 320x240 적용 (해상도로 조절) 모두 저장 < ezBMP > 그림읽기 RGB565 변환 저장 파일이름 변경후 저장(c파일) < .c 파일 수정 > 16bit 부분만 남기고 삭제 (imgReader 입력데이터 16bit) “0x” -> “” (공백) ”,” -> “ “ Vivado -> Memory File 추가 후 파일 내용 붙여넣기 < imgReader 수정 > //assign addr = DE ? (320 * y + x) : 17'bz; assign addr = (DE && (x < 320) && (y < 240)) ? (320 * y + x) : 17'bz; 화면에서 사진외에 나머지 부분에도 data가 들어가므로 코드 수정 logic img_show; assign img_show = (DE && (x < 320) && (y < 240)); assign addr = img_show ? (320 * y + x) : 17'bz; assign r_port = img_show ? data[15:12] : 4'bz; assign g_port = img_show ? data[10:7] : 4'bz; assign b_port = img_show ? data[4:1] : 4'bz; 나머지 부분에 검은색이 아닌 레나색으로 채워치므로 코드 수정 < ImgROM > LUT로 잡힌 거는 회로가 자동으로 생성된거임 - 비동기식 회로로 만들면 LUT 회로 생성 - clk을 받아줘서 동기식 회로로 만들면 BRAM으로 회로가 생성됨 VGA_Decoder 에서 pclk 를 뽑아서, ImgROM 의 clk 으로 넣어줌 BRAM 을 잡음으로 LUT에 회로를 더 구성할 수 있음 < Result > 영상처리와 함께 필터 고안 RAM에 주기적으로 계속 읽고 써주면서 memory 업데이트 이후 필터의 수학적 알고리즘을 추가할 수 있음 < 색상 필터 구현 > RGB_OnOff_Filter 모듈 설계 ! < Gray Filter > GrayScaleFilter 모듈 설계, 상위 4비트만 사용 매번 비트스트림하기 빡세니까 bmp 파일 읽고 쓰는거 해보자 < 알씨 > 꾸미기 자르기 4:3 적용 (자르기 비율 유지, 가로로 길게) 크기변경 640x480 적용 모두 저장 -> BMP 형식으로 저장 (24bit) < TestBench 작성 (SW) > 이후 sim 동작되는 위치에 bmp 파일을 넣어야함 -> ProjectName.sim/sim_1/behav/xsim/ 여기에넣고 시뮬레이션 `timescale 1ns / 1ps module tb_VGA (); byte bmp_total[640*480*3+54]; byte bmp_header[54]; byte bmp_data[640*480*3]; int bmp_size, bmp_data_offset, bmp_width, bmp_height, biBitCount; string sourcefileName = "Rengoku_640x480.bmp"; string targetfileName = "target_640x480.bmp"; task ReadBMP(); int fileID, readSize; fileID = $fopen(sourcefileName, "rb"); if (!fileID) begin $display("Open [%s] BMP File Error!", sourcefileName); $finish; end readSize = $fread(bmp_total, fileID); $fclose(fileID); $display("[%s] read size : %0d", sourcefileName, readSize); bmp_size = {bmp_total[5], bmp_total[4], bmp_total[3], bmp_total[2]}; $display("[%s] bmp size : %0d", sourcefileName, bmp_size); bmp_data_offset = { bmp_total[13], bmp_total[12], bmp_total[11], bmp_total[10] }; $display("[%s] bmp image offset : %0d", sourcefileName, bmp_data_offset); bmp_width = { bmp_total[21], bmp_total[20], bmp_total[19], bmp_total[18] }; bmp_height = { bmp_total[25], bmp_total[24], bmp_total[23], bmp_total[22] }; $display("[%s] bmp image %0d x %0d", sourcefileName, bmp_width, bmp_height); biBitCount = {bmp_total[29], bmp_total[28]}; $display("[%s] bmp bit %0d", sourcefileName, biBitCount); if (biBitCount != 24) begin $display("[%s] biBitCount need to be 24bit", sourcefileName); $finish; end if (bmp_width % 4) begin $display("[%s] bmp width %% 4 need to be zero!", sourcefileName); $finish; end // copy header for (int i = 0; i < bmp_data_offset; i++) begin bmp_header[i] = bmp_total[i]; end // copy image for (int i = bmp_data_offset; i < 640 * 480 * 3; i++) begin bmp_data[i-bmp_data_offset] = bmp_total[i]; end endtask task WriteBMP(); int fileID; fileID = $fopen(targetfileName, "wb"); for (int i = 0; i < bmp_data_offset; i++) begin $fwrite(fileID, "%c", bmp_header[i]); end for (int i = 0; i < bmp_size - bmp_data_offset; i++) begin $fwrite(fileID, "%c", bmp_data[i]); end $fclose(fileID); $display("Write BMP File Done!"); endtask initial begin ReadBMP(); WriteBMP(); end endmodule Class 로 TestBench 수정 // 안됨 < 파일 > sources (Class) imgReader.sv ImgROM.sv VGA_Display_Switch.sv GrayScaleFilter.sv RGB_OnOff_Filter.sv VGA_Color_Bar.sv VGA_Decoder.sv VGA_RGB_SWITCH.sv Lenna.mem Rengoku.mem sim (Class) tb_VGA.sv constrs (Class) Basys-3-Master.xdc
Final · 2025-09-09
2025-09-08
VGA(Video Graphics Array) Cathode Ray Tube 화면이 나오는 기본적인 원리(브라운관, Cathode Ray Tube) : 편향판(+)에 전압을 인가하여 통과하는 전자를 특정 방향(상/하/좌/우)으로 끌어당겨서 형광물질이 발려진 화면의 원하는 위치에 전자가 도착함 Heater : 열을 발생시킴 (전자의 이동도 증가), electronic gun 역할을 함 Cathode : 전자가 모임 accelerating anode / focusing anode : 전자의 이동을 가속시킴, 전자의 이동 속도에 따른 명암 조절이 가능(밝기) plates for horizontal deflection / plates for vertical deflection : +전압을 인가하여 전자의 이동 경로를 조절 1 픽셀 당 8bit 짜리 R, G, B 묶음 VGA (640x480 size) 편향판의 오른쪽으로 갈수록 강도가 세짐 = 전류가 세짐 Display Surface 에 왼쪽에서 오른쪽으로 전자가 도착함. 오른쪽에 다다르면 다시 왼쪽으로 돌아가야함. 이때 전류의 세기를 낮춰서 돌아감. 전류의 세기가 스무스하게 떨어지는 구간에는 마진이 필요하게 됨 -> porch porch : 옛날 Tv의 가장자리 부분(가려놓음), 돌아오는 구간(Retrace), 편향판 방전 front porch : sync 신호 앞에 있음 back porch : sync 신호 뒤에 있음 Display -> Front Portch -> Sync Pulse -> Back Porch 전원을 주면 신호 무한 반복 VGA Signal 640x480 들어가면 사이즈 나옴 한 프레임을 찍기 위해800, 525 만큼의 점/시간이 필요함 1초 : 800Pix * 525Line * 60Frame = 25.2MHz =~ 25MHz Scanline part Pixels Frame part Lines Visible area 640 Visible area 480 Front porch 16 Front porch 10 Sync pulse 96 Sync pulse 2 Back porch 48 Back porch 33 포트와 구조는 이런 식으로 display 설계 가능 < Block Diagram > VGA 에서 sync를 맞추는 신호가 필요함. pixels 같은 경우 640+16 까지 High, 96 까지 Low, 48 까지 High x, y 좌표에 맞는 display를 할 수 있게 해야함 (640 x 840 영역에서만!) pixel clock 을 받아서 영상처리에 대한 모듈을 동작시키는 경우가 많음 pixel_counter에서 pclk 에 대해 negedge 일때 처리하는 이유는? 안정적으로 RGB Data를 읽기 위함 추후 ISP 설계시 posedge, regedge를 적절히 분배할 필요가 있음 (Timing 고려) < Simulation > < 파일 > sources (Class) VGA_Display_Switch.sv VGA_Decoder.sv VGA_RGB_SWITCH.sv sim (Class) tb_vga_sw.sv constrs (Class) tb_vga_sw.sv HW < Design Specification > < Result > < 파일 > sources (HW) VGA_Display_Switch.sv VGA_Decoder.sv VGA_RGB_SWITCH.sv constrs (HW) Basys-3-Master.xdc
Final · 2025-09-08
2025-09-05
AXI_Introduction_to_AMBA_AXI < READ Transaction : R, AR Channel transfer > 코딩 쭉쭉 시뮬결과 사진1 코드들 사진2 < Vivado : 스위치같은거 > 만든 IP에 맞게 수정해서 사용할 수 있음 블록도 사진3 단계 뭐가 많네 (클래스룸노트참고) 코드분석 드가자 // Width of S_AXI data bus parameter integer C_S_AXI_DATA_WIDTH = 32, // Width of S_AXI address bus parameter integer C_S_AXI_ADDR_WIDTH = 4 // Example-specific design signals // local parameter for addressing 32 bit / 64 bit C_S_AXI_DATA_WIDTH // ADDR_LSB is used for addressing 32/64 bit registers/memories // ADDR_LSB = 2 for 32 bits (n downto 2) // ADDR_LSB = 3 for 64 bits (n downto 3) localparam integer ADDR_LSB = (C_S_AXI_DATA_WIDTH/32) + 1; localparam integer OPT_MEM_ADDR_BITS = 1; ADDR_LSB = (32/32) + 1 = 2 // AXI4LITE signals reg [C_S_AXI_ADDR_WIDTH-1 : 0] axi_awaddr; reg axi_awready; reg axi_wready; reg [1 : 0] axi_bresp; reg axi_bvalid; reg [C_S_AXI_ADDR_WIDTH-1 : 0] axi_araddr; reg axi_arready; reg [C_S_AXI_DATA_WIDTH-1 : 0] axi_rdata; reg [1 : 0] axi_rresp; reg axi_rvalid; [3:0] axi_awaddr [3:0] axi_araddr [31:0] axi_rdata //---------------------------------------------- //-- Signals for user logic register space example //------------------------------------------------ //-- Number of Slave Registers 4 reg [C_S_AXI_DATA_WIDTH-1:0] slv_reg0; reg [C_S_AXI_DATA_WIDTH-1:0] slv_reg1; reg [C_S_AXI_DATA_WIDTH-1:0] slv_reg2; reg [C_S_AXI_DATA_WIDTH-1:0] slv_reg3; wire slv_reg_rden; wire slv_reg_wren; reg [C_S_AXI_DATA_WIDTH-1:0] reg_data_out; integer byte_index; reg aw_en; slv_reg0, slv_reg1, slv_reg2, slv_reg3 : 32bit // Implement axi_awready generation // axi_awready is asserted for one S_AXI_ACLK clock cycle when both // S_AXI_AWVALID and S_AXI_WVALID are asserted. axi_awready is // de-asserted when reset is low. always @( posedge S_AXI_ACLK ) begin if ( S_AXI_ARESETN == 1'b0 ) begin axi_awready <= 1'b0; aw_en <= 1'b1; end else begin if (~axi_awready && S_AXI_AWVALID && S_AXI_WVALID && aw_en) begin // slave is ready to accept write address when // there is a valid write address and write data // on the write address and data bus. This design // expects no outstanding transactions. axi_awready <= 1'b1; aw_en <= 1'b0; end else if (S_AXI_BREADY && axi_bvalid) begin aw_en <= 1'b1; axi_awready <= 1'b0; end else begin axi_awready <= 1'b0; end end end 첫 번째 if : (리셋) 두 번째 if : (ready 0, AWADDr 입력, WDATA 입력, 처음수행) 이면 조건문 실행 else if : (Bchannel handshaking) write transaction이 끝나면 else : write transaction 수행중 // Implement axi_awaddr latching // This process is used to latch the address when both // S_AXI_AWVALID and S_AXI_WVALID are valid. always @( posedge S_AXI_ACLK ) begin if ( S_AXI_ARESETN == 1'b0 ) begin axi_awaddr <= 0; end else begin if (~axi_awready && S_AXI_AWVALID && S_AXI_WVALID && aw_en) begin // Write Address latching axi_awaddr <= S_AXI_AWADDR; end end end 입력된 AWADDR 임시 저장 다음 클럭에서는 ready=1 이므로 한 번만 동작 // Implement axi_wready generation // axi_wready is asserted for one S_AXI_ACLK clock cycle when both // S_AXI_AWVALID and S_AXI_WVALID are asserted. axi_wready is // de-asserted when reset is low. always @( posedge S_AXI_ACLK ) begin if ( S_AXI_ARESETN == 1'b0 ) begin axi_wready <= 1'b0; end else begin if (~axi_wready && S_AXI_WVALID && S_AXI_AWVALID && aw_en ) begin // slave is ready to accept write data when // there is a valid write address and write data // on the write address and data bus. This design // expects no outstanding transactions. axi_wready <= 1'b1; end else begin axi_wready <= 1'b0; end end end (WDATA 입력, AWADDR 입력, write tansaction 처음 수행) // Implement memory mapped register select and write logic generation // The write data is accepted and written to memory mapped registers when // axi_awready, S_AXI_WVALID, axi_wready and S_AXI_WVALID are asserted. Write strobes are used to // select byte enables of slave registers while writing. // These registers are cleared when reset (active low) is applied. // Slave register write enable is asserted when valid address and data are available // and the slave is ready to accept the write address and write data. assign slv_reg_wren = axi_wready && S_AXI_WVALID && axi_awready && S_AXI_AWVALID; always @( posedge S_AXI_ACLK ) if ( S_AXI_ARESETN == 1'b0 ) begin slv_reg0 <= 0; slv_reg1 <= 0; slv_reg2 <= 0; slv_reg3 <= 0; end else begin if (slv_reg_wren) begin case ( axi_awaddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] ) 2'h0: for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 ) if ( S_AXI_WSTRB[byte_index] == 1 ) begin // Respective byte enables are asserted as per write strobes // Slave register 0 slv_reg0[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8]; end 2'h1: for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 ) if ( S_AXI_WSTRB[byte_index] == 1 ) begin // Respective byte enables are asserted as per write strobes // Slave register 1 slv_reg1[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8]; end 2'h2: for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 ) if ( S_AXI_WSTRB[byte_index] == 1 ) begin // Respective byte enables are asserted as per write strobes // Slave register 2 slv_reg2[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8]; end 2'h3: for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 ) if ( S_AXI_WSTRB[byte_index] == 1 ) begin // Respective byte enables are asserted as per write strobes // Slave register 3 slv_reg3[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8]; end default : begin slv_reg0 <= slv_reg0; slv_reg1 <= slv_reg1; slv_reg2 <= slv_reg2; slv_reg3 <= slv_reg3; end endcase end end end handshaking 일어났을 때 저장하겠다는 뜻 case ([3:2]) : 4의 배수를 1, 2, 3, 4로 보겠음 byte_index : 0일때 // Implement write response logic generation // The write response and response valid signals are asserted by the slave // when axi_wready, S_AXI_WVALID, axi_wready and S_AXI_WVALID are asserted. // This marks the acceptance of address and indicates the status of // write transaction. always @( posedge S_AXI_ACLK ) begin if ( S_AXI_ARESETN == 1'b0 ) begin axi_bvalid <= 0; axi_bresp <= 2'b0; end else begin if (axi_awready && S_AXI_AWVALID && ~axi_bvalid && axi_wready && S_AXI_WVALID) begin // indicates a valid write response is available axi_bvalid <= 1'b1; axi_bresp <= 2'b0; // 'OKAY' response end // work error responses in future else begin if (S_AXI_BREADY && axi_bvalid) //check if bready is asserted while bvalid is high) //(there is a possibility that bready is always asserted high) begin axi_bvalid <= 1'b0; end end end end READY와 VALID 가 1이면 위에서 ready가 0이 됨, write transaction 끝나면 주소를 받지 않겠다 write transaction 수행 중 캡처사진 주르륵 IP 갔다쓰면됨 CPU 불러서 여기에 올리고 방금만든 IP를 붙힐거임 밥먹고와서 GPIO IP 만들고 비바도 자체 버그, Makefile 수정해야됨 makefile 경로캡처,
Final · 2025-09-05
2025-09-04
AXI_Introduction_to_AMBA_AXI RISC-V 직접 사용과는 별개로, Xilinx Vivado에서는 MicroBlaze soft CPU + AXI Interconnect (Switch) 구조를 기본으로 제공. FPGA에 올릴려면 마이크로 블레이즈, AXI 스위치 사용 < AXI protocol overview > AXI는 BUS가 아니라 protocol → 용어상 “AXI bus”라 하지 않고 AXI protocol이라고 함. Point-to-Point 연결: Master와 Slave가 직접 연결되며, Interconnect가 중재 역할을 함. 따라서 Master1–Slave1 통신과 동시에 Master2–Slave2 통신 가능 → 병렬성 보장. < AXI Channels 정리 > AXI 인터페이스 기본 구조 AXI는 point-to-point protocol Master ↔ Slave 간 통신은 5개의 채널을 통해 이루어짐: Write Address (AW) Write Data (W) Write Response (B) Read Address (AR) Read Data (R) Write Operation (쓰기 동작) Master → Slave: AW 채널: 쓰기 주소 전달 W 채널: 실제 데이터 전달 Slave → Master: B 채널: 쓰기 완료 후 응답(Return message) Read Operation (읽기 동작) Master → Slave: AR 채널: 읽고 싶은 주소 전달 Slave → Master: R 채널: 요청된 주소의 데이터 반환 오류 시 → Read Data 채널에서 에러 메시지 전달 (주소 무효, 데이터 오류, 권한 없음 등) 채널 특성 각 채널은 단방향(unidirectional) 구조. 따라서 Write Response(B) 채널이 별도로 필요함. 반면 읽기에는 별도의 Response 채널이 필요 없음 → Read Data(R)에 포함됨. Read 채널과 Write 채널은 서로 독립 → 동시에 동작 가능 → 대역폭 최적화. 신호 접두(prefix) AW : Write Address 채널 신호 AR : Read Address 채널 신호 W : Write Data 채널 신호 R : Read Data 채널 신호 B : Write Response 채널 신호 B = buffered → Slave가 모든 Write 완료 후 응답하는 의미 < Channel handshake 정리 > 기본 개념 AXI4의 모든 5개 채널은 VALID/READY 핸드셰이크 메커니즘을 사용. VALID: Source(송신자 → Master or Slave)에서 Destination으로 전송. READY: Destination(수신자 → Master or Slave)에서 Source로 전송. 두 신호가 모두 High일 때 데이터 전송이 유효하게 이루어짐. 동작 방식 Source 역할 유효한 데이터가 준비되면 VALID=1로 설정. Destination이 수락할 때까지 VALID는 유지해야 함. 이렇게 유지되는 VALID를 “sticky signal”이라고 부름. Destination 역할 데이터를 받을 수 있으면 READY=1로 설정. READY는 Destination → Source로 전달됨. 데이터 전송 조건 VALID=1 & READY=1 → rising edge에서 데이터 전송 성공. Master / Slave의 위치 Master/Slave가 Source인지 Destination인지는 채널에 따라 다름. 예: Read Address 채널에서는 Master가 Source, Slave가 Destination. 예: Read Data 채널에서는 Slave가 Source, Master가 Destination. 특성 이 메커니즘은 비동기(asynchronous) 핸드셰이크가 아님. 클록의 상승 에지(rising edge)에서 전송이 확정됨. < Transfers vs Transactions 정리 > Transfer VALID + READY 핸드셰이크 한 번으로 이루어지는 단일 데이터 교환. 구성: Source → Destination : VALID + INFO(데이터/주소 등) Destination → Source : READY 즉, 하나의 데이터 전송 단위. Transaction 여러 개의 Transfer 묶음 → 하나의 전체 동작. 예시: Write Transaction Address Transfer Write Address 채널: Master가 주소 전달 (VALID + ADDRESS) Slave가 수락 시 READY Data Transfer(s) Write Data 채널: Master가 실제 데이터 전송 (VALID + DATA) Slave가 수락 시 READY 데이터는 여러 개의 burst transfer 가능 Response Transfer Write Response 채널: Slave → Master 응답 (VALID + RESPONSE) Master가 수락 시 READY 핵심 차이 Transfer = 단일 교환 (VALID/READY 1번) Transaction = 여러 Transfer의 집합 (Address + Data + Response로 구성, burst도 포함 가능) VALID 신호가 들어오면 MASTER 쪽에 READY를 다시 줌 -> HAND SHAKE가 이루어지고 난 후에 떨어짐 화살표 2개 : 반드시 있어야함 화살표 1개 : 옵션 느낌 버스트신호가 없는 것이 Lite 더 정리? 타이밍별로 기다리는 입장 등등 < Block Diagram > < FSM > < Simulation > < 파일 > sources (Class) AXI4_Lite_Master.sv AXI4_Lite_Slave.sv simulation (Class) tb_AXI4_Lite.sv
Final · 2025-09-04
2025-09-03
SystemVerilog 검증 (RAM) < SystemVerilog 기반 RAM 검증의 핵심 포인트 > 입력값 자동화 (randomization 활용) Testbench에서 Stimulus(입력값)를 자동 생성하기 위해 class + randomize() 사용 특히 주소, 데이터, 제어 신호(write/read enable) 등을 랜덤하게 생성해 corner case 검증 가능 Class의 역할 (HW 접근 불가) class는 소프트웨어적 개념 transaction(데이터 묶음)을 정의하고, 랜덤 생성 및 처리하는 역할 직접 DUT의 핀에 접근할 수 없음 따라서 driver가 class 객체(transaction)를 받아서 → interface를 통해 HW 신호로 변환 Interface의 역할 (HW 신호 묶음) interface는 하드웨어적 개념 DUT와 testbench 간의 신호(주소, 데이터, write enable 등)를 묶어주는 역할 Virtual Interface (SW ↔ HW 연결 다리) class는 HW에 직접 접근 불가 → interface 핸들을 참조해야 함 하지만 class 내부에서 interface 인스턴스를 바로 사용할 수 없음 < Block Diagram > < Timing Diagram > // ram 에 write task run(); forever begin gen2drv_mbox.get(tr); ram_if.addr = tr.addr; ram_if.we = tr.we; if (tr.we) ram_if.wdata = tr.wdata; @(posedge ram_if.clk); end endtask ”===” : 조건문 내에서 x(Impedance)값 판단 가능 < 파일 > sources (Class) ram.sv simulation (Class) tb_ram.sv FND_periph Design < Block Diagram > < Design Specification > (en 신호) clk_div_1khz 제어 -> 카운터 멈춤 (en 신호) decoder_2x4 제어 -> 디스플레이 꺼줌 < SW 검증, C언어 분석 > #include<stdint.h> typedef struct { uint32_t CR; uint32_t FDR; } FND_TypeDef; #define APB_BASE 0x10000000 #define FND_BASE (APB_BASE + 0x4000) #define FND ((FND_TypeDef *)(FND_BASE)) // #define FND_CR (*(uint32_t *)(FND_BASE + 0x00)) // #define FND_FDR (*(uint32_t *)(FND_BASE + 0x04)) void FND_Init(FND_TypeDef *fnd); void FND_WriteData(FND_TypeDef *fnd, uint32_t d); void delay(uint32_t t); int main() { // FND_CR = 0x01; // FND_FDR = 1234; // FND->CR = 0x01; // FND->FDR = 1234; FND_Init(FND); uint32_t data = 0; while (1) { // FND->FDR = data; FND_WriteData(FND, data); data++; delay(1000); } return 0; } void FND_WriteData(FND_TypeDef *fnd, uint32_t d) { fnd->FDR = d; } void FND_Init(FND_TypeDef *fnd) { fnd->CR = 0x01; } void delay(uint32_t t) { for (int i=0; i<t; i++) { for (int j=0; j<1000; j++); } } (아래 해석은 수업중 해석이고 GPT 내용과 부분적으로 틀림) (int *)0x10000000 Data Type : 자료형, Data 형태, Data 모양, Data 크기 Data : Memory 안에 있는 값 Type : int를 뜻함 (4byte) => int 자료형이 의미하는 주소에 4byte의 메모리 공간 할당 (char *)0x10000008 0x1000_0008 : 주소 => 1Byte 만큼 할당 (FND_Typedef *)0x10004000 FND_Typedef : Data Type 으로 생각 4byte 2개가 붙어있는 8byte 메모리를 할당하며 CR, FDR 이라는 이름을 붙혔을 뿐 ((FND_Typedef *)(0x10004000))->CR = 0x01; ((FND_Typedef *)(0x1000_4000)).CR : 주소를 의미함 ((FND_Typedef *)(0x1000_4000))->CR : 해당 주소의 데이터를 의마함 (FND_TypeDef *) : type 캐스팅, 주소를 해당 타입의 포인터로 해석 포인터 이해 +——————-+ | 4 byte | <- FDR +——————-+ | 4 byte | <- CR +——————-+ 이중 포인터 예시 +——————-+ | 10 | <- A +——————-+ | 0x1000_0000 | <- pA +——————-+ | 0x1000_1000 | <- ppA +——————-+ (0x1000_0000) A = 10 값 (0x1000_1000) pA = 0x1000_0000 주소 (0x1000_2000) ppA = 0x1000_1000 주소 **ppA == 10 (A의 값) 머신 코드로 변경 시 참고 li sp,0x10001000 < 파일 > sources (Class) APB_Master.sv APB_Slave.sv code.mem ControlUnit.sv CPU_RV32I.sv DataPath.sv defines.sv fndController.sv GPI.sv GPIO.sv GPO.sv MCU.sv RAM.sv ROM.sv constrs (Class) Basys-3-Master.xdc
Final · 2025-09-03
2025-09-02
UVM 검증 System Verilog : 검증에 대한 표준이 되어가고 있음 UVM : 검증 Framework, System Verilog 로 설계 Verilog System Verilog OOP(객체지향) X(Class X) O(Class 문법 사용) DataType H/W 중심 DataType S/W 중심 DataType(S/W 기능 추가) interface X SW <=> HW 연결검증용 SW <=> DUT HW randomization random제한적기능 각 변수에 random 생성constraint 기능corner case 생성 System Verilog Data Type 4-state(벡터) : 0, 1, x, z -> logic, reg, wire 2-state(벡터) : 0, 1 -> bit 4-state(정수) : integer(32bit) 2-state(정수) : byte(8), shortint(16), int(32), longint(64) 배열 (SW 자료형) 고정 길이 배열 (fixed-size array, static array) 선언 시 크기가 고정되고 runtime에 크기 변경불가 예: bit arr[8]; // 8개의 bit 원소 byte arr2[4]; // 4개의 byte 원소 int arr3[16]; // 16개의 int 원소 동적 배열 (dynamic array) 선언만 해두고, runtime에 new를 통해 크기 결정 필요 시 크기 변경 가능 (new[] 재호출) 예: bit arr[]; arr = new[8]; // 크기 8로 할당 int arr2[]; arr2 = new[16]; // 크기 16으로 재할당 가능 delete() 사용 시 메모리 해제 가능 고정 길이 배열은 하드웨어에 가깝고 (Verilog 스타일), 동적 배열은 소프트웨어적 성격 (테스트벤치, 검증 환경)에서 주로 활용 Queue Type (FIFO) 크기가 가변적이고, 앞뒤로 push/pop 가능 선언: bit que[$]; // bit 타입 queue int que2[$]; // int 타입 queue 주요 메서드: que.push_back(1); // 뒤에 삽입 que.push_front(4); // 앞에 삽입 que.pop_front(); // 앞에서 꺼냄 que.pop_back(); // 뒤에서 꺼냄 그 외 자주 쓰이는 메서드: que.size() // 현재 크기 반환 que.delete() // 모든 원소 삭제 que.insert(idx, value) // 특정 위치에 삽입 que.delete(idx) // 특정 위치 원소 삭제 Queue는 UVM testbench에서 transaction 저장/전달, mailbox 대체 용도 등으로 자주 활용 Test Bench, UVM 구조의 System Verilog 검증 Test Bench generator(입력 data 생성) : stimulus 생성 (transaction 단위) driver(전달) : transaction을 핀 레벨 신호로 변환해 DUT 입력에 적용 monitor(감시) : DUT 입출력을 트랜잭션으로 변환해 전달 scoreboard(pass/fail 판단) : 예측값과 DUT 출력을 비교, 검증 수행 interface(연결) : 신호 묶음과 방향 제어, driver/monitor와 DUT 간 연결 DUT(HW) : testbench가 자극을 주고, 응답을 평가하는 대상 실습 class : generator, driver 만들고 감싸는 env 만들고 interface, dut 만들면 됨 데이터 묶음을 전달하기 위해 어떻게? 구조체를 지원하지만 class 를 쓰는 게 일반적임 transaction = 데이터 묶음 (stimulus 단위) → 보통 class로 정의 C언어에서 구조체(struct)는 단순 데이터 묶음에 적합 SystemVerilog class는 변수 + 메서드를 함께 넣을 수 있어 객체지향(OOP) 스타일의 재사용·확장이 가능 → UVM 검증 환경의 기본 단위 module tb_adder (); environment env; // Class adder_intf adder_if (); // HW(메모리가 아님) adder dut ( // HW .a(adder_if.a), .b(adder_if.b), .result(adder_if.result) ); initial begin env = new(adder_if); // new(virtual adder_intf adder_if(실제 HW정보 입력) = adder_if) 가명에 연결한 느낌 env.run(); end endmodule class environment; generator gen; driver drv; mailbox #(transaction) gen2drv_mbox; function new(virtual adder_intf adder_if); // 위의 new를 콜함. virtual(HW를 SW적으로 연결)는 가상인터페이스(HW를 그냥 전달하면 안됨, SW처럼 생각하자) gen2drv_mbox = new(); // 정보를 주고 gen = new(gen2drv_mbox); // 정보를 주고 drv = new(gen2drv_mbox, adder_if); // 정보를 주고 endfunction task run(); fork gen.run(20); drv.run(); join_any #(10 * 10) $finish; endtask endclass class driver; transaction tr; virtual adder_intf adder_if; mailbox #(transaction) gen2drv_mbox; function new(mailbox#(transaction) gen2drv_mbox, // 주소 virtual adder_intf adder_if); // HW정보 this.gen2drv_mbox = gen2drv_mbox; this.adder_if = adder_if; endfunction task run(); forever begin gen2drv_mbox.get(tr); adder_if.a = tr.a; adder_if.b = tr.b; end endtask endclass class generator; transaction tr; // handler mailbox #(transaction) gen2drv_mbox; function new(mailbox#(transaction) gen2drv_mbox); this.gen2drv_mbox = gen2drv_mbox; endfunction task run(int run_count); repeat (run_count) begin tr = new(); // make instance. 실체화 시킨다. heap memory에 class 자료형을 만든다. tr.randomize(); gen2drv_mbox.put(tr); // 해당 인터페이스의 주소값(tr)을 넣어줌 #10; end endtask endclass class environment; generator gen; driver drv; mailbox #(transaction) gen2drv_mbox; function new(virtual adder_intf adder_if); gen2drv_mbox = new(); gen = new(gen2drv_mbox); drv = new(gen2drv_mbox, adder_if); endfunction task run(); fork // 멀티 프로세서 실행 gen.run(20); // 독집적으로 돌아감 drv.run(); // 독집적으로 돌아감 join_any #(10 * 10) $finish; endtask endclass fork-join : SW적으로 병렬 실행을 지원, gen.run(20) 과 drv.run() 이 동시에 실행 (HW always 블록 2개가 병렬로 도는 것과 유사한 개념) 인스턴스네임.메서드 구조 : 메서드의 기능을 호출 fork-join : 전부 끝나야 다음으로 fork-join_any : 하나라도 끝나면 다음으로 (나머지는 계속 실행됨) fork-join_none : 시작만 시키고 바로 다음으로 forever : 조건 없는 무한 루프 비동기식 adder < adder.sv > `timescale 1ns / 1ps module adder ( input logic [7:0] a, input logic [7:0] b, output logic [8:0] result ); assign result = a + b; endmodule < tb_adder.sv > `timescale 1ns / 1ps interface adder_intf; logic [7:0] a; logic [7:0] b; logic [8:0] result; endinterface class transaction; rand bit [7:0] a; rand bit [7:0] b; bit [8:0] result; endclass class generator; transaction tr; // handler mailbox #(transaction) gen2drv_mbox; // mailbox 사용 → generator와 driver 간의 큐/통신 채널 function new(mailbox#(transaction) gen2drv_mbox); this.gen2drv_mbox = gen2drv_mbox; endfunction task run(int run_count); repeat (run_count) begin tr = new(); // Heap에 transaction 객체 생성 // make instance. 실체화 시킨다. heap memory에 class 자료형을 만든다. tr.randomize(); // 랜덤 입력 생성 gen2drv_mbox.put(tr); // driver 쪽으로 전달 #10; end endtask endclass class driver; transaction tr; virtual adder_intf adder_if; mailbox #(transaction) gen2drv_mbox; function new(mailbox#(transaction) gen2drv_mbox, virtual adder_intf adder_if); this.gen2drv_mbox = gen2drv_mbox; this.adder_if = adder_if; endfunction task run(); forever begin gen2drv_mbox.get(tr); // generator에서 transaction 받음 adder_if.a = tr.a; // DUT 입력에 할당 adder_if.b = tr.b; // DUT 입력에 할당 end endtask endclass class monitor; transaction tr; virtual adder_intf adder_if; mailbox #(transaction) mon2scb_mbox; function new(mailbox#(transaction) mon2scb_mbox, virtual adder_intf adder_if); this.mon2scb_mbox = mon2scb_mbox; this.adder_if = adder_if; endfunction task run(); forever begin #1; tr = new(); tr.a = adder_if.a; tr.b = adder_if.b; tr.result = adder_if.result; mon2scb_mbox.put(tr); #10; end endtask endclass class scoreboard; transaction tr; mailbox #(transaction) mon2scb_mbox; bit [7:0] a, b; function new(mailbox#(transaction) mon2scb_mbox); this.mon2scb_mbox = mon2scb_mbox; endfunction task run(); tr = new(); forever begin mon2scb_mbox.get(tr); a = tr.a; b = tr.b; if (tr.result == (a + b)) begin $display("PASS! : %d + %d = %d", a, b, tr.result); end else begin $display("FAIL! : %d + %d = %d", a, b, tr.result); end end endtask endclass class environment; // generator, driver 등 testbench 구성 요소를 묶는 top-level class generator gen; driver drv; monitor mon; scoreboard scb; mailbox #(transaction) gen2drv_mbox; mailbox #(transaction) mon2scb_mbox; function new(virtual adder_intf adder_if); gen2drv_mbox = new(); // mailbox 생성 mon2scb_mbox = new(); // mailbox 생성 gen = new(gen2drv_mbox); // generator 생성 drv = new(gen2drv_mbox, adder_if); // driver 생성 mon = new(mon2scb_mbox, adder_if); // monitor 생성 scb = new(mon2scb_mbox); // scoreboard 생성 endfunction task run(); fork gen.run(1000); // 20개 stimulus 생성 drv.run(); // DUT에 계속 적용 mon.run(); // DUT에 계속 적용 scb.run(); // DUT에 계속 적용 join_any #(10 * 10) $finish; endtask endclass module tb_adder (); // DUT와 interface 생성 → environment 실행 environment env; adder_intf adder_if (); // adder_if라는 interface를 생성하여 DUT와 TB를 연결 adder dut ( .a(adder_if.a), .b(adder_if.b), .result(adder_if.result) ); initial begin env = new(adder_if); // environment 생성 env.run(); // 시뮬레이션(generator/driver) 실행 end endmodule 동기식 adder < adder.sv > `timescale 1ns / 1ps module adder ( input logic clk, input logic [7:0] a, input logic [7:0] b, output logic [8:0] result ); always_ff @(posedge clk) begin result <= a + b; end endmodule < tb_adder.sv > `timescale 1ns / 1ps interface adder_intf; logic clk; logic [7:0] a; logic [7:0] b; logic [8:0] result; endinterface class transaction; rand bit [7:0] a; rand bit [7:0] b; bit [8:0] result; endclass class generator; transaction tr; // handler mailbox #(transaction) gen2drv_mbox; // mailbox 사용 → generator와 driver 간의 큐/통신 채널 function new(mailbox#(transaction) gen2drv_mbox); this.gen2drv_mbox = gen2drv_mbox; endfunction task run(int run_count); repeat (run_count) begin tr = new(); // Heap에 transaction 객체 생성 // make instance. 실체화 시킨다. heap memory에 class 자료형을 만든다. tr.randomize(); // 랜덤 입력 생성 gen2drv_mbox.put(tr); // driver 쪽으로 전달 #10; end endtask endclass class driver; transaction tr; virtual adder_intf adder_if; mailbox #(transaction) gen2drv_mbox; function new(mailbox#(transaction) gen2drv_mbox, virtual adder_intf adder_if); this.gen2drv_mbox = gen2drv_mbox; this.adder_if = adder_if; endfunction task run(); forever begin gen2drv_mbox.get(tr); // generator에서 transaction 받음 adder_if.a = tr.a; // DUT 입력에 할당 adder_if.b = tr.b; // DUT 입력에 할당 @(posedge adder_if.clk); end endtask endclass class monitor; transaction tr; virtual adder_intf adder_if; mailbox #(transaction) mon2scb_mbox; function new(mailbox#(transaction) mon2scb_mbox, virtual adder_intf adder_if); this.mon2scb_mbox = mon2scb_mbox; this.adder_if = adder_if; endfunction task run(); forever begin tr = new(); @(posedge adder_if.clk); #1; tr.a = adder_if.a; tr.b = adder_if.b; tr.result = adder_if.result; mon2scb_mbox.put(tr); end endtask endclass class scoreboard; transaction tr; mailbox #(transaction) mon2scb_mbox; bit [7:0] a, b; function new(mailbox#(transaction) mon2scb_mbox); this.mon2scb_mbox = mon2scb_mbox; endfunction task run(); // tr = new(); forever begin mon2scb_mbox.get(tr); a = tr.a; b = tr.b; if (tr.result == (a + b)) begin $display("PASS! : %d + %d = %d", a, b, tr.result); end else begin $display("FAIL! : %d + %d = %d", a, b, tr.result); end end endtask endclass class environment; // generator, driver 등 testbench 구성 요소를 묶는 top-level class generator gen; driver drv; monitor mon; scoreboard scb; mailbox #(transaction) gen2drv_mbox; mailbox #(transaction) mon2scb_mbox; function new(virtual adder_intf adder_if); gen2drv_mbox = new(); // mailbox 생성 mon2scb_mbox = new(); // mailbox 생성 gen = new(gen2drv_mbox); // generator 생성 drv = new(gen2drv_mbox, adder_if); // driver 생성 mon = new(mon2scb_mbox, adder_if); // monitor 생성 scb = new(mon2scb_mbox); // scoreboard 생성 endfunction task run(); fork gen.run(10); // 20개 stimulus 생성 drv.run(); // DUT에 계속 적용 mon.run(); // DUT에 계속 적용 scb.run(); // DUT에 계속 적용 join_any #(10 * 10) $finish; endtask endclass module tb_adder (); // DUT와 interface 생성 → environment 실행 environment env; adder_intf adder_if (); // adder_if라는 interface를 생성하여 DUT와 TB를 연결 adder dut ( .clk (adder_if.clk), .a (adder_if.a), .b (adder_if.b), .result(adder_if.result) ); always #5 adder_if.clk = ~adder_if.clk; initial begin adder_if.clk = 1; end initial begin env = new(adder_if); // environment 생성 env.run(); // 시뮬레이션(generator/driver) 실행 end endmodule < 파일 : 동기식 adder > sources (Class) text simulation (Class) text
Final · 2025-09-02
2025-09-01
📌 취업 역량 강화 (면접) 🎤 PT 면접 PT 면접이 있다면 별도 준비 필요 💻 비대면 면접 합격 시그널, 상호 피드백을 받기 어려움 피드백을 받으려면 적극적으로 질문을 해야 함 🙋‍♂️ 질문 대응 모든 질문에는 진정성이 느껴지도록 대답 모르는 내용이 나오면? 솔직하게 “모른다”라고 답변 최대한 아는 선에서 보완 설명 👥 그룹 면접 시 같은 질문을 옆 사람이 먼저 답변했다면 → 차별화된 관점으로 답변 준비 자기소개 스크립트 각인시키는 첫 문장 안녕하십니까, 설계부터 검증, 그리고 임베디드와 AI까지 경험을 확장해온 도전의 아이콘이자 끊임없이 배우며 성장하는 지원자 임재홍입니다. 나를 설명하는 문장 저의 철학은 “작은 성취를 쌓아 큰 성장을 만든다”입니다. 서울기술교육센터에서 Verilog와 SystemVerilog를 활용해 RISC-V CPU와 FFT 설계를 수행하며 RTL 설계와 검증의 기본기를 다졌습니다. 또한 STM32 기반의 전투기 게임을 개발하고, FPGA로 시계·스톱워치·센서 인터페이스를 구현하며 하드웨어와 펌웨어의 연결을 직접 경험했습니다. 나아가 Python과 ONNX 기반으로 피부 질환 진단 AI 시스템을 제작하여 소프트웨어와 AI 기술까지 아우르는 시각을 길렀습니다. 저는 이러한 과정 속에서 문제에 직면하면 팀원과 협업하며 함께 분석해고 해결해나가며 성과를 만들어내는 과정에서 큰 보람을 느꼈습니다. 마무리 문장 제가 귀사에 입사하게 된다면 앞으로도 배우는 자세와 도전 정신을 바탕으로, 대체불가능한 반도체 설계 인재로 성장하겠습니다. 감사합니다. 피드백 전부 외우기 힘들 수도 있으니 내용 줄일 것 혼자 연습할 때 40초 이내로 끊는 분량으로 스크립트 작성
Final · 2025-09-01
2025-08-29
📌 취업 역량 강화 (자소서) 🔔 Google 알리미 특정 키워드(예: “반도체 채용”, “AI 반도체”)를 등록하면 새로운 뉴스/웹문서가 나오면 Gmail로 알림 도착 산업군 또는 관심 기업 관련 알림도 설정 가능 📝 자기소개서 작성 관련 GPT가 쓴 자소서는 인사담당자에게 진정성을 주지 못함 가치관 에피소드 활용 전략: 가치관 + 본인 강점 역지사지로 가치관을 풀어내면 좋음 (직무경험 연결) 단순히 내용만 채우지 말고, 제목까지 고려해야 함 다운로드를 위해 PPT, PDF 형식 필요한 경우 있음 📈 채용 동향 및 인재상 채용 동향: 러닝 어빌리티 시대 인재상 변화 → 공기업 자소서 활용 사례 증가 실무 경험의 필요성 강조 기업 분석: 경영이념 → 핵심가치 → 인재상 → 행동양식 🔎 정보 수집 채널 중소기업현황정보시스템 취업 플랫폼 : 사람인, 잡코리아, 코멘토, 블라인드 → 알림 설정 리멤버 : 방명록 기능 활용 💡 기업 분석 & 입사 동기 Right People 회사 가치관을 보고 → 선호 이슈, 뉴스 확인 → 내 경험·가치와 연결 입사동기·포부를 직무 중심으로 쓰면, 회사가 바뀌어도 수정할 내용이 최소화됨 지식·역량·태도 기준으로 직무 분석 “나는 이런 인재이다” 식 서술은 지양 👔 면접 및 자기소개 전략 관리자·CEO 인사말 참고 면접에서는 기본기 중요 성장 동력 = 호기심 키워드 인사담당자 입장에서 쓰기 객관화 / 수치화 STAR 기법: 결론 → 본론(STAR) → 결론 🧰 작성 가이드 장점 7개, 단점 3개 (단점은 개선 중임을 강조, 예시 불필요) 문제 해결 능력 (STAR 기법) S: 상황은 무엇이었나? T: 역할은 무엇이었나? A: 어떤 행동을 했나? R: 결과는 어땠나? (성공 사례 위주) 🙋‍♂️ 자기 이해 진단 내가 자주 듣는 칭찬은? 내가 가장 열정을 느끼는 활동은? 친구들이 주로 맡기는 역할은? 내가 좋아하는 수업/과목은? 시간이 흐르는 줄 모르고 몰입한 경험은? 바뀌는 순간(터닝포인트)이 있다면? 🏷️ 나의 강점 키워드 역량은 주로 키워드화 → #에너지뿜뿜 #창조적사고 #도전의아이콘 #열정의신입 #친화력요정 나의 강점 키워드 도출 나의 강점 2개 친구가 본 강점 2개 최종 선정 강점 2개 자기소개서 PPT 지원 동기 및 입사 후 포부 하는 일, 역량, 해당 경험 배치하기 산업 특성 및 이슈, 산업 내 회사 방향 지원 직무 및 부서의 역할/필요성과 자신의 적합성 간단하게 강조 향후 업무, 역할 수행 계획 간결하게 지원할 회사에 집중 ○○분야에서 ~할 ~커리어 목표, 업무수행 목표 세부계획 세가지 경력자의 소개서 참고하기 NCS업무 분석 참고하기 현직자 영상보기 ~한 인재가 되겠습니다.(O) / ~한 인재입니다.(X) 성장 과정 성장시켜온 나의 신념, 기준 장시간 실천해온 사례 희망 직무, 필요 성향/조직 융화 관련 장점을 키워온 사례 가족 소개X, 멘토 소개X, 부정적 소개X 25세 이상이면 성인 때 이야기만 쓴다(본인의 의지, 성향만 쓴다) 성격의 장단점 직무와 직접적으로 연관되는 장점(장점 사례, 장점을 가지고 직무에 기여할 수 있는 부분) 단점은 보완하는 노력 함께 작성 장단점은 비율 7:3 ★ 하지 말아야 할 것: 장점이자 단점이 되는 것, 분리(희석 시키지 말자/단점인 듯, 장점인 것), 단점의 노력은 현재진행형이어야 함 특기 사항 직무 경험 작성 시 직무와 관련된 직접적인 경험(실무) → 직무역량(성격X) 자신의 역할, 향상시킨 실무역량, 그 경험을 통해 배운 점 등 가장 직접적으로 겪어본 직무 경험 잘하는 역량 1가지 씩! 같은 경험을 중복하여 기입하지 않도록 주의 자신에게 맡겨진 일이나 과제를 밤을 새울 정도로 열중하여 성공적으로 완수한 경험 열정적 마인드와 행동을 통해 자신의 삶이 변화되고, 긍정적인 영향을 끼친 경험
Final · 2025-08-29
2025-08-28
APB Slave Interface RAM Design < Design Specification > Address 기준으로 broadcast 하는 구조 : BUS 구조 /* APB_Slave 구조 참고 */ if (PWRITE) begin // 쓰기 동작 case (PADDR[3:2]) // 주소에 따른 2'd0: slv_reg0 <= PWDATA; 2'd1: slv_reg1 <= PWDATA; 2'd2: slv_reg2 <= PWDATA; 2'd3: slv_reg3 <= PWDATA; endcase end else begin // 읽기 동작 case (PADDR[3:2]) // 주소에 따른 2'd0: PRDATA <= slv_reg0; 2'd1: PRDATA <= slv_reg1; 2'd2: PRDATA <= slv_reg2; 2'd3: PRDATA <= slv_reg3; endcase end < Simulation > APB는 CPU 는 ready 신호가 들어올 때까지 몇 클럭이든 대기 AHB는 파이프라인구조라서 대기하는 시간이 짧음 RAM 스택포인터 위치 0x1000_0000 ~ 0x1000_0FFF 맞춰서 SP를 RAM 최상단으로 초기화해야 함 < SW 검증 : Store, Load Test> int main() { int a, b, c; a = 1; b = 2; c = a + b; return 0; } < Simulation > GPO Design < Design Specification > GPO 를 만들어서 연결을 원하며, LED도 연결한다. < APB_Peripheral 내부 구조 > < SW 검증 : GPO 동작 > #include <stdint.h> #define APB_BASE 0x10000000 #define GPO_BASE (APB_BASE + 0x1000) #define GPO_CR *(uint32_t *)(GPO_BASE + 0x00) #define GPO_ODR *(uint32_t *)(GPO_BASE + 0x04) int main() { uint32_t data = 0; GPO_CR = 0xff; while(1) { GPO_ODR = data; data = GPO_ODR; data = data ^ 1; } return 0; } < Simulation > < SW 검증 : LED Shift Test > #include <stdint.h> #define APB_BASE 0x10000000 #define GPO_BASE (APB_BASE + 0x1000) #define GPO_CR *(uint32_t *)(GPO_BASE + 0x00) #define GPO_ODR *(uint32_t *)(GPO_BASE + 0x04) void delay(uint32_t t); int main() { uint32_t data = 1; GPO_CR = 0xff; while(1) { GPO_ODR = data; delay(1000); data = (data >> 7) | (data << 1); } return 0; } void delay(uint32_t t) { for (uint32_t i=0; i<t; i++) { for (uint32_t j=0; j<1000; j++); } } GPI Design < SW 검증 : LED Switching Test > #include <stdint.h> #define APB_BASE 0x10000000 #define GPO_BASE (APB_BASE + 0x1000) #define GPO_CR *(uint32_t *)(GPO_BASE + 0x00) #define GPO_ODR *(uint32_t *)(GPO_BASE + 0x04) #define GPI_BASE (APB_BASE + 0x2000) #define GPI_CR *(uint32_t *)(GPI_BASE + 0x00) #define GPI_IDR *(uint32_t *)(GPI_BASE + 0x04) //void delay(uint32_t t); int main() { uint32_t data = 0; GPO_CR = 0xff; GPI_CR = 0xff; while(1) { data = GPI_IDR; GPO_ODR = data; //delay(1000); //data = (data >> 7) | (data << 1); } return 0; } /* void delay(uint32_t t) { for (uint32_t i=0; i<t; i++) { for (uint32_t j=0; j<1000; j++); } } */ GPIO Design < 파일 > sources (Class) APB_Master.sv APB_Slave.sv code.mem ControlUnit.sv CPU_RV32I.sv DataPath.sv defines.sv GPI.sv GPIO.sv GPO.sv MCU.sv RAM.sv ROM.sv simulation (Class) apb_tb.sv RV32I_tb.sv constrs (Class) Basys-3-Master.xdc HW : FND_Peripheral Design < SW 검증 : FND 0~9999 Counter 동작 > #include<stdint.h> #define APB_BASE 0x10000000 #define GPO_BASE (APB_BASE + 0x1000) #define GPO_CR *(uint32_t *)(GPO_BASE + 0x00) #define GPO_ODR *(uint32_t *)(GPO_BASE + 0x04) #define GPI_BASE (APB_BASE + 0x2000) #define GPI_CR *(uint32_t *)(GPI_BASE + 0x00) #define GPI_IDR *(uint32_t *)(GPI_BASE + 0x04) #define GPIO_BASE (APB_BASE + 0x3000) #define GPIO_CR *(uint32_t *)(GPIO_BASE + 0x00) #define GPIO_IDR *(uint32_t *)(GPIO_BASE + 0x04) #define GPIO_ODR *(uint32_t *)(GPIO_BASE + 0x08) #define FND_BASE (APB_BASE + 0x4000) #define FND_CR *(uint32_t *)(FND_BASE + 0x00) #define FND_ODR *(uint32_t *)(FND_BASE + 0x04) void delay(uint32_t t); int main() { enum {LEFT, RIGHT}; uint32_t data = 1; uint32_t fnd_count = 0; // FND 카운터 추가 GPO_CR = 0xff; GPI_CR = 0xff; GPIO_CR |= 0x0f; GPIO_CR &= ~(0x0f<<4); // FND 초기화 FND_CR = 0x3FFF; // 14비트 모두 활성화 FND_ODR = fnd_count; // 초기값 1 설정 uint32_t state = LEFT; while (1) { switch(state) { case LEFT: data = (data >> 7) | (data << 1); if(GPIO_IDR & (1<<5)) state = RIGHT; break; case RIGHT: data = (data << 7) | (data >> 1); if(GPIO_IDR & (1<<6)) state = LEFT; break; } GPO_ODR = data; //data = GPI_IDR; GPIO_ODR = GPIO_IDR >>4; // FND 카운터 업데이트 fnd_count++; if(fnd_count > 9999) fnd_count = 1; // 9999 초과시 1로 리셋 FND_ODR = fnd_count; delay(100); } return 0; } void delay(uint32_t t) { for(uint32_t i=0;i<t;i++){ for(uint32_t j=0;j<1000;j++); } } < 파일 > sources (HW) APB_Master.sv APB_Slave.sv code.mem ControlUnit.sv CPU_RV32I.sv DataPath.sv defines.sv FND.sv fndController.sv GPI.sv GPIO.sv GPO.sv MCU.sv RAM.sv ROM.sv constrs (HW) Basys-3-Master.xdc
Final · 2025-08-28
2025-08-27
AMBA APB 이론 Decoder 를 통해 SELECT 주소가 L H L 가 되면 하위 비트로 어떤 수가 들어가든 8255가 선택되고 나머지는 선택되지 않음 상위 4bit = 주소 address 8255 I/O 선택된 상태에서 가장 작은 수 : 0100_0000_0000_0000 = 0x4000 8255 I/O 선택된 상태에서 가장 작은 수 : 0101_1111_1111_1111 = 0x5FFF => 0x4000 ~ 0x5FFF : 8255 I/O 영역 => 0x2000 ~ 0x3FFF : RAM 영역 => 0x0000 ~ 0x1FFF : ROM 영역 => 할당 되지 않은 부분 : reserved 영역, 사용되지 않음 0x5FFF - 0x4000 + 1 = 0x2000 = 8192 8192 / 8 = 1024Byte = 영역별 1KB 공간이 있음 (int *)(0x2500) = 10 => X, 좌변은 주소를 의미함 *(int *)(0x2500) = 10 => O, 좌변은 주소의 값을 의미함 => RAM 만 동작 => 이후 값이 뒤따라 들어가서 10을 write *(char *)(0x4001) = 0xFF; 결과는 0x4001 주소에 접근 => 8255 내부 레지스터 중 하나에 write (Port B에 해당) =>Port B에 0xFF를 출력 CPU 중심으로 보면 주변 Device는 Memory로 바라본다. (Memory Mapped I/O) APB 버스는 주소·데이터를 모든 Slave에게 broadcast 하지만, Decoder가 주소를 해석해 특정 Slave만 선택한다 Memory Mapping Chip Select < About the APB protocol > 복잡한 interface를 줄이는데 optimized 되어있음 low-cost : logic 갯수가 적기 때문 not pipeline (AHB는 pipeline) synchronous protocol : 동기 protocol every transfer takes at least two cycle to complete : 최소 2 cycle 이상 걸림 “the programmable control registers of peripheral devices” : CPU가 레지스터에 접근해서 write/read 한다 = 해당 peripheral device를 제어한다 < Write transfer with no wait states > PADDR : 16bit Addr1 유지 PWRITE : High 유지 PSEL : High 유지 PENABLE : Low(준비단계) -> High PWDATA : 32bit Data1 유지 PREADY : Low -> High(Prei에서 처리했다는 뜻) => 이후 IDLE cpu 에서는 sel, enable, ready 신호들이 없음 기존 cpu : Addr, we, WData, RData + ready, transfer 추가 Memory Map : 32bit = 4Gbyte AMBA APB Design < Block Diagram > < Simulation > < 파일 > sources (Class) APB_Master.sv APB_Slave.sv code.mem ControlUnit.sv CPU_RV32I.sv DataPath.sv defines.sv MCU.sv RAM.sv ROM.sv simulation (Class) apb_tb.sv HW < Design Specification > APB Slave Interface 구조의 RAM을 만드시오 Test Bench에서 APB 신호를 입력하여 임의의 주소에 Read/Write 시뮬레이션 하시오 < Simulation > < 파일 > sources (HW) APB_Master.sv APB_Slave.sv code.mem ControlUnit.sv CPU_RV32I.sv DataPath.sv defines.sv MCU.sv RAM_Slave.sv RAM.sv ROM.sv simulation (HW) apb_tb.sv
Final · 2025-08-27
2025-08-21
Multi Cycle single cycle 흐름 PC -(주소)-> ROM -(명령어)-> RegFile, ControlUnit(Decoding->SignalOut) -> ALU -> RAM -> Regfile 가장 긴 Path의 경우, 1 클럭동안 ALU 입력신호와 ControlUnit 에서 내보내는 신호를 같이 받아서 RAM 으로 가서 메모리 access 후 RAM 에서 나온 결과가 RegFile 에 들어감. -> 클럭 길이가 너무 길다 조합회로가 5개 있다고 가정하고 각 회로마다 10ns 시간이 걸린다면 클럭을 아무리 줄여도 최도한 50ns 이상 되어야한다. 중간에 FF 을 둔다고 가정하고 이는 1ns 시간이 걸린다면 전체를 통과하는데 걸리는 시간이 56ns + a 필요 Fetch : 명령어를 빼내는 동작 (ROM 입출력 + PC 출력) Decode : opcode 분석 (ImmExtend 출력 + ControlUnit 입출력) Excute : 실행, 연산 (ALU 입출력 + PC 입력부 gate 들과 mux, Jump 판단) MemAccess : RAM 입력 (ALU 출력 + RAM 입력) WriteBack : RAM 출력 (RAM 출력 + RegFile 입력) R-Type : 34 + a ns S-Type : 45 + a ns L-Type : 56 + a ns => Single Cycle 보다 효율이 약간 더 올라감 주의점 : Fetch 구간에서 동작까지 다음 명령어가 나오면 이건 Pipeline 구조, Fetch 구간에서 동작까지 다음 명령어가 나오지 않으면 Multi Cycle 구조 ControlUnit 에 구간별로 FSM 필요 RV32I-V 해체 작업 필요 Fetch 구간 : PC를 좀 빼서 PCEn 신호 필요 Decode 구간 : RegFile 출력, ImmExtend 출력 Reg 추가 Excute 구간 : 메모리 Access 하기 전, PC로 가기 전 Reg 추가 MemAccess 구간 : RAM 출력부분 Reg 추가 WriteBack 구간 DataPath 코딩 RAM 출력 부분은 탑모듈(MCU)에서 CPU의 입력을 통해 DataPath로 들어감 ControlUnit 코딩 opcode를 보고 Type 구별 FSM R-Type : Excute → Fetch (ALU 명령 후 RegFile 입력 대기 후 클럭이 들어오면 넘어감) I-Type : Excute → Fetch B-Type : Excute → Fetch S-Type : Excute → MemAccess → Fetch L-Type : Excute → MemAccess → WriteBack → Fetch 클럭을 통해 상태게 업데이트되게 해야함 (global signal 선언) PPT 각 명령어마다 한 페이지로 정리 C언어를 통한 테스트코드를 만들어서 (sort만?) 내 CPU 잘 돈다는 것 증명 트러블슈팅, 느낀점(잘적자) FSM 타입별로 다 그려줘야됨 Multi 짜면서 FSM 을 통해 한번더 신호에 대한 이해함 1.표지, 제목, 발표자 이름 2.RISC-V 개요 3.개발환경, 언어, Simulation환경 4.명령 Type별 설명 -검증내용(Timing Diagram) 5.Test Program 설명(ex:sorting) 6.트러블슈팅 7.느낀점 -배운점, 변화된점 처음에는 스토어 경로를 부호확장 했으나 표준을 찾아보고 wdata를 시프트해서 처리함 - 둘다 될 경우 처음에는 스토어 경로를 부호확장을 한 번에 했으나 표준을 찾아보고 wdata를 시프트해서 처리함 이로인해 클럭문제를 해결 - 안될 경우
Final · 2025-08-21
2025-08-20
RV32I_All_Type Single_Cycle 완성 RV32I_All_Type Multi_Cycle I-Type path 가장 오래 걸림, 여러 클럭에 나눠서 처리 온라인 C-Compiler : https://godbolt.org/ 온라인 Assembler : https://riscvasm.lucasteske.dev/ RISC-V 명령어 분석기 (Decoder/Encoder) : https://luplab.gitlab.io/rvcodecjs/ 동적 메모리 할당하는 영역이 heap 영역 변수나 함수는 stack 영역에 할당 메모리의 가장 꼭대기는 stack 영역 stack 영역의 시작점은 RAM의 가장 꼭대기. RAM 마지막주소 + 1 C언어에 대한 메모리구조 파악 필요 ra : return address (함수가 끝나면 그 위치로 돌아가야함, 그 위치 저옵) s0 를 RAM에 저장 s0에 sp 시작위치 저장 a5 = 10 s0(꼭대기)를 20 떨어트려서 10(a5 값)을 저장함 a5 = 20 s0(꼭대기)를 24 떨어트려서 20(a5 값)을 저장함 lw : a4에 10을 넣어줌 lw : a5에 20을 넣어줌 add : a5 = a4 + 15 = 30 30 넣어줌 li : a5 = 0 a0 = 0 ra = RAM에 저장된 ra값 s0 = RAM에 저장된 s0값 sp 초기위치 ra 위치로 점프 HW Memory 공간에 Stack 영역의 변화과정과 변수의 Memory 할당 방식 이해 배열, 포인터 동작 방식을 Memory 관점에서 분석하시오 Memory 그림을 그리면서 분석 RegisterFile의 Register 할당 ABI name을 보면서 할당 방식 이해. 분석 어셈블리어 명령 하나하나 Memory와 RegFile 상호작용 내용을 글로 적으면서 분석하시오 ![alt text](../../assets/img/final/250820/250820_hw.png)
Final · 2025-08-20
2025-08-19
RISC-V I-TYPE Review funct3 를 통해 SLTI, SLTIU 구분 해야함 SLTI 경우 부호비트를 생각해서 늘려줘야 함 shift 는 전부 unsigned, 그래서 SLTIU 도 immExtend 에서 같이 처리 /*** immExtend ***/ `OP_TYPE_I: begin case (func3) 3'b001: immExt = {27'b0, instrCode[24:20]}; // SLLI 3'b011: immExt = {20'b0, instrCode[31:20]}; // SRLI, SRAI 3'b101: immExt = {27'b0, instrCode[24:20]}; // SLTIU default:immExt = {{20{instrCode[31]}}, instrCode[31:20]}; endcase end /*** ROM ***/ //rom[x]=32'b imm12 _ rs1 _f3 _ rd _ op // I-Type rom[6] = 32'b000000000001_00001_000_01001_0010011;// addi x9, x1, 1 rom[7] = 32'b000000000100_00010_111_01010_0010011;// andi x10, x2, 4 rom[8] = 32'b000000000001_00010_110_01011_0010011;// ori x11, x2, 1 rom[9] = 32'b000000000011_00001_001_01100_0010011;// slli x12, x1, 1 → 2b00001000 << 3 = 11 * 2^3 = 88 왼쪽 쉬프트: x « n = x × 2ⁿ 오른쪽 쉬프트: x » n = floor(x ÷ 2ⁿ) RISC-V B-TYPE 비교해서 점프하겠다. 결국 명령어의 주소를 바꾸겠다는 뜻. PC의 값을 바꾸면 나오는 명령어가 바뀜 = Branch (C언어: if, for, while, switch 등) (rs1, rs2로 연산하기 위해) ALU 안에 비교기 처리 /*** ControlUnit ***/ `OP_TYPE_B: aluControl = operator; /*** alu ***/ always_comb begin : branch btaken = 1'b0; case (aluControl[2:0]) `BEQ: btaken = (a == b); `BNE: btaken = (a != b); `BLT: btaken = ($signed(a) < $signed(b)); `BGE: btaken = ($signed(a) >= $signed(b)); `BLTU: btaken = (a < b); `BGEU: btaken = (a >= b); endcase end /*** DataPath ***/ logic [3:0] PC_4_AdderResult, PC_Imm_AdderResult, PCSrcMuxOut; logic PCSrcMuxSel; logic btaken; adder U_PC_Imm_Adder ( .a(immExt), .b(PCOutData), .y(PC_Imm_AdderResult) ); adder U_PC_4_Adder ( .a(32'd4), .b(PCOutData), .y(PC_4_AdderResult) ); assign PCSrcMuxSel = btaken & branch; mux_2x1 U_PCSrcMux ( .sel(PCSrcMuxSel), .x0 (PC_4_AdderResult), .x1 (PC_Imm_AdderResult), .y (PCSrcMuxOut) ); ROM[n] : n*4 씩 이동 ROM[5] 참 -> rom[8] 점프 (20->32) /*** ROM ***/ //rom[x]=32'b imm7 _ rs2 _ rs1 _f3 _ imm5_ op // B-Type rom[5] = 32'b0000000_00010_00010_000_01100_1100011; // beq x2, x2, 12 //rom[x]=32'b imm12 _ rs1 _f3 _ rd _ op // L-Type rom[6] = 32'b000000001000_00000_010_01000_0000011; // lw x8, 8(x0) //rom[x]=32'b imm12 _ rs1 _f3 _ rd _ op // I-Type rom[7] = 32'b000000000001_00001_000_01001_0010011; // addi x9, x1, 1 rom[8] = 32'b000000000100_00010_111_01010_0010011; // andi x10, x2, 4 ROM[5] 거짓 -> rom[8] (20->24) /*** ROM ***/ //rom[x]=32'b imm7 _ rs2 _ rs1 _f3 _ imm5_ op // B-Type rom[5] = 32'b0000000_00010_00000_000_01100_1100011; // beq x2, x0, 12 //rom[x]=32'b imm12 _ rs1 _f3 _ rd _ op // L-Type rom[6] = 32'b000000001000_00000_010_01000_0000011; // lw x8, 8(x0) 규칙성 Imm의 공통 bit를 최대한 똑같은 위치에 맞춘다. L, I, S, B, J, JL Type 에서 최대한 같은 위치의 Imm bit 위치를 같게 한다. H/W 최적화에 도움이 된다. B, J Type의 경우 Imm값이 ROM(PC)주소의 offset값이 된다. ROM의 주소는 항상 짝수가 되므로 imm[0]은 항상 ‘0’값이 된다. 그러므로 B, J Type에서 imm[0]이 없이 강제로 ‘0’을 넣어줘도 된다. 그 효과는 offset 범위값을 넓힐 수 있다. 명령어가 입력된 ROM의 주소 특징은 4의 배수이다. imm 12bit 고정. 최대값 주소범위를 넓히고 싶다. RISC-V LU, AU, J, JL-TYPE C언어로 if문 해서 점프, 컴파일러에서 만들어줌
Final · 2025-08-19
2025-08-18
RISC-V (RV32I Instruction Set) ‘R-Type’ RA1 : “Read Address 1” — 읽을 레지스터의 주소(번호). rs1(명령어 [19:15])가 들어감. 5비트. RA2 : “Read Address 2” — 읽을 레지스터의 주소(번호). rs2(명령어 [24:20])가 들어감. 5비트. WA : “Write Address” — 쓸 레지스터의 주소(번호). rd(명령어 [11:7]). 5비트. RD1 : “Read Data 1” — x[rs1]에서 읽혀 나온 데이터. ALU 피연산자 a로 연결. RD2 : “Read Data 2” — x[rs2]에서 읽혀 나온 데이터. ALU 피연산자 b로 연결. WD : “Write Data” — 쓸 데이터. R-type이면 보통 ALU 결과(aluResult). we : “Write Enable” — 클록 상승엣지에 we=1이면 x[WA] ← WD로 기록. Instruction Memory(ROM/Flash) : 명령어를 저장하고 PC가 지정한 주소의 명령어를 읽어준다. PC(Program Counter) : 현재 명령어의 주소를 보관하고 다음 주소(보통 PC+4 또는 분기/점프)를 제시한다. Control Unit : opcode(+funct3/7)를 해독해 ALU·레지스터·메모리·PC 제어 신호(aluControl 등)를 생성한다. 효율적이고 범용적인 명령어를 만들기 위해 교수님과 같이 R-Type 설계 I_Type과 동일한 funtion 부분이 몇 군데 보임 ControlUnit 에서 operator 값과 aluControl 신호가 동일하므로 R-Type 이면 aluControl = operator → 7’b0110011: aluControl = operator; 가독성을 높이기 위해 defines.sv 생성 → `include “defines.sv” S-Type (Store) 설계, RAM 필요 R-Type(산술/논리): 레지스터끼리만 연산해 결과를 다시 레지스터에 씀. 실행 중 “데이터 메모리”를 읽거나 쓰지 않음. 필요한 메모리는 명령을 읽어오는 Instruction Memory(보통 ROM/Flash)뿐. S-Type(Store): 레지스터 값을 데이터 메모리로 저장(쓰기) 해야 함. 실행 중 내용이 바뀌어야 하므로 쓰기 가능한 메모리(RAM)가 필수. S-Type Descript : Memory[주소] = Data ↔ M[rs1+imm] = rs2 (Memory[주소]=RAM, imm=상수) imm exted : 부호비트를 생각해서 처리, imm=opset 값, 해당 주소로부터 올라갈(+) 수도 있고 내려갈(-) 수도 있음, 비트부호 확장 필요, 최상위 비트를 20번 copy signals 늘어남에 따라 묶어줌. → {regFileWe, aluSrcMuxSel, busWe} = signals; // [2:0]signals L-Type I-Type
Final · 2025-08-18
2025-08-14
RISC-V Design RISC-V (리스크 파이브) 2010년부터 미국 UC 버클리에서 개발 중인 무료 오픈 소스 RISC 명령어셋 아키텍처 Base: RV32I Version: 2.0 1. Single-Cycle Architecture 모든 명령어가 1 clock에 동작 가장 시간이 오래 걸리는 명령어를 기준으로 클럭 주기를 설계해야 함 장점: 구조가 매우 단순함 단점: 전체 실행 속도가 느림 2. Multi-Cycle Architecture 명령어 유형(type)에 따라 필요한 clock 수가 다름 명령어에 따라 실행 시간을 단축할 수 있음 장점: Single-Cycle보다 빠름 단점: 구조가 다소 복잡함 구현 목표 ① Single-Cycle로 먼저 구현 및 이해 ② Multi-Cycle로 전환 + ARMA BUS + 주변장치(Peripherals) 연동 3. Pipeline Architecture (현재 구현 X) 장점: Single-Cycle보다 훨씬 빠름 단점: 구조가 매우 복잡함 x0 → zero : 항상 0 값을 가지는 레지스터 x1 → ra (Return Address) : 함수 호출 후 복귀 주소 저장 x2 → sp (Stack Pointer) : 스택의 최상단 주소 저장 x3 → gp (Global Pointer) : 전역 변수 접근용 포인터 … (이후 x31까지 각자 용도 지정) → 어셈블리어에서는 x0, x1 대신 zero, ra, sp, gp 등의 별칭(alias)으로 표기됨 CPU 기본 모듈 (하버드 구조) Register File → CPU 내부 레지스터 집합, 연산 및 데이터 임시 저장 ALU (Arithmetic Logic Unit) → 산술 및 논리 연산 수행 ROM / Flash (Instruction Memory) → 프로그램 명령어 저장 ※ ROM은 한 번 쓰면 지울 수 없으므로, 대부분 Flash 메모리(비휘발성) 사용 RAM (Data Memory) → 프로그램 실행 중 데이터 임시 저장 (휘발성) PC (Program Counter) → 현재 실행 중인 명령어의 주소를 가리키는 레지스터 Instruction, CPU, RAM 까지 Single-Cycle 구현 Peri는 Multi-Cycle 이후 구현 Block Diagram Signal 이해 Register Source 1 (5) : 5bit RS1 Register Source 2 (5) : 5bit RS2 Register Destination (5) : 5bit RD Opcode (7) : 7bit type 구분 Funct7 (7) : 7bit 연산 구분 Funct3 (3) : 3bit 연산 구분 ADD : rd(WAddr) = rs1(RA1) + rs2(RA2) / add : x7(rd), x5(rs1), x6(rs2) = x7 = x5(Data) + x6(Data) < Data Path > < Code : Data Path > `timescale 1ns / 1ps module DataPath ( input logic clk, input logic reset, input logic [31:0] instrCode, input logic regFileWe, input logic [ 1:0] aluControl, output logic [31:0] instrMemAddr ); logic [31:0] aluResult, RFData1, RFData2; logic [31:0] PCSrcData, PCOutData; assign instrMemAddr = PCOutData; RegisterFile U_RegFile ( .clk(clk), .we (regFileWe), .RA1(instrCode[19:15]), .RA2(instrCode[24:20]), .WA (instrCode[11:7]), .WD (aluResult), .RD1(RFData1), .RD2(RFData2) ); alu U_ALU ( .aluControl(aluControl), .a (RFData1), .b (RFData2), .result (aluResult) ); register U_PC ( .clk (clk), .reset(reset), .en (1'b1), .d (PCSrcData), .q (PCOutData) ); adder U_PC_Adder ( .a(32'd4), .b(PCOutData), .y(PCSrcData) ); endmodule module alu ( input logic [ 1:0] aluControl, input logic [31:0] a, input logic [31:0] b, output logic [31:0] result ); always_comb begin result = a + b; case (aluControl) 2'b00: result = a + b; 2'b01: result = a - b; 2'b10: result = a & b; 2'b11: result = a | b; endcase end endmodule module RegisterFile ( input logic clk, input logic we, input logic [ 4:0] RA1, input logic [ 4:0] RA2, input logic [ 4:0] WA, input logic [31:0] WD, output logic [31:0] RD1, output logic [31:0] RD2 ); logic [31:0] mem[0:2**5-1]; always_ff @(posedge clk) begin if (we) mem[WA] <= WD; end assign RD1 = (RA1 != 0) ? mem[RA1] : 32'b0; assign RD2 = (RA2 != 0) ? mem[RA2] : 32'b0; endmodule module register ( input logic clk, input logic reset, input logic en, input logic [31:0] d, output logic [31:0] q ); always_ff @(posedge clk, posedge reset) begin if (reset) begin q <= 0; end else begin if (en) q <= d; end end endmodule module adder ( input logic [31:0] a, input logic [31:0] b, output logic [31:0] y ); assign y = a + b; endmodule < Schematic : DataPath > < Code : Control Unit > `timescale 1ns / 1ps module ControlUnit ( input logic [31:0] instrCode, output logic regFileWe, output logic [ 1:0] aluControl ); // logic 은 선언하면서 연결이 안되기 때문에 wire 사용 (logic 사용시 assign 필요) wire [6:0] opcode = instrCode[6:0]; wire [3:0] operator = {instrCode[30], instrCode[14:12]}; always_comb begin regFileWe = 1'b0; case (opcode) 7'b0110011: regFileWe = 1'b1; endcase end always_comb begin aluControl = 2'bx; case (opcode) 7'b0110011: begin // R-Type aluControl = 2'bx; case (operator) 4'b0000: aluControl = 2'b00; // add 4'b1000: aluControl = 2'b01; // sub 4'b0111: aluControl = 2'b10; // and 4'b0110: aluControl = 2'b11; // or endcase end endcase end endmodule < Code : CPU_RV32I > `timescale 1ns / 1ps module CPU_RV32I ( input logic clk, input logic reset, input logic [31:0] instrCode, output logic [31:0] instrMemAddr ); logic regFileWe; logic [1:0] aluControl; ControlUnit U_ControlUnit (.*); DataPath U_DataPath (.*); endmodule < Schematic : CPU_RV32I > < Code : ROM > `timescale 1ns / 1ps module ROM ( input logic [31:0] addr, output logic [31:0] data ); logic [31:0] rom[0:61]; initial begin //rom[x]=32'b func7 _ rs2 _ rs1 _f3 _ rd _ op rom[0] = 32'b0000000_00001_00010_000_00100_0110011; // add x4, x2, x1 rom[1] = 32'b0100000_00001_00010_000_00101_0110011; // sub x5, x2, x1 rom[2] = 32'b0000000_00000_00011_111_00110_0110011; // and x6, x3, x0 rom[3] = 32'b0000000_00000_00011_110_00111_0110011; // or x7, x3, x0 end // 하위 2bit 를 없애면 4(2^2)의 배수로 표현이 됨, 4byte 단위로 이동 가능 assign data = rom[addr[31:2]]; endmodule < Code : MCU > `timescale 1ns / 1ps module MCU ( input logic clk, input logic reset ); logic [31:0] instrCode; logic [31:0] instrMemAddr; ROM U_ROM ( .addr(instrMemAddr), .data(instrCode) ); CPU_RV32I U_CPU_RV32I (.*); endmodule < Schematic : MCU > < Simulation > < 파일 > sources (Class) MCU.sv ROM.sv CPU_RV32I.sv ControlUnit.sv DataPath.sv sim (Class) RV32I_tb.sv HW < Design Specification > RISC-V RV32I R-Type 명령어 설계 < Code : DataPath (alu) > //... module alu ( input logic [ 3:0] aluControl, input logic [31:0] a, input logic [31:0] b, output logic [31:0] result ); always_comb begin result = 32'b0; case (aluControl) 4'b0000: result = a + b; 4'b0001: result = a - b; 4'b0010: result = a << b; 4'b0011: result = a >> b; 4'b0100: result = a >>> b; 4'b0101: result = ($signed(a) < $signed(b)) ? 1 : 0; 4'b0110: result = (a < b) ? 1 : 0; 4'b0111: result = a ^ b; 4'b1000: result = a | b; 4'b1001: result = a & b; endcase end endmodule //... < Code : ControlUnit > `timescale 1ns / 1ps module ControlUnit ( input logic [31:0] instrCode, output logic regFileWe, output logic [ 3:0] aluControl ); // logic 은 선언하면서 연결이 안되기 때문에 wire 사용 (logic 사용시 assign 필요) wire [6:0] opcode = instrCode[6:0]; wire [3:0] operator = {instrCode[30], instrCode[14:12]}; always_comb begin regFileWe = 1'b0; case (opcode) 7'b0110011: regFileWe = 1'b1; endcase end always_comb begin aluControl = 4'bx; case (opcode) 7'b0110011: begin // R-Type aluControl = 4'bx; case (operator) 4'b0000: aluControl = 4'b0000; // ADD 4'b1000: aluControl = 4'b0001; // SUB 4'b0001: aluControl = 4'b0010; // SLL 4'b0101: aluControl = 4'b0011; // SRL 4'b1101: aluControl = 4'b0100; // SRA 4'b0010: aluControl = 4'b0101; // SLT 4'b0011: aluControl = 4'b0110; // SLTU 4'b0100: aluControl = 4'b0111; // XOR 4'b0110: aluControl = 4'b1000; // OR 4'b0111: aluControl = 4'b1001; // AND endcase end endcase end endmodule < Code : ROM > `timescale 1ns / 1ps module ROM ( input logic [31:0] addr, output logic [31:0] data ); logic [31:0] rom[0:61]; initial begin //rom[x]=32'b func7 _ rs2 _ rs1 _f3 _ rd _ op rom[0] = 32'b0000000_00010_00001_000_00011_0110011; // add x3, x1, x2 rom[1] = 32'b0100000_00010_00001_000_00011_0110011; // sub x3, x1, x2 rom[2] = 32'b0000000_00010_00001_001_00011_0110011; // sll x3, x1, x2 rom[3] = 32'b0000000_00010_00001_101_00011_0110011; // srl x3, x1, x2 rom[4] = 32'b0100000_00010_00001_101_00011_0110011; // sra x3, x1, x2 rom[5] = 32'b0000000_00010_00001_010_00011_0110011; // slt x3, x1, x2 rom[6] = 32'b0000000_00010_00001_011_00011_0110011; // sltu x3, x1, x2 rom[7] = 32'b0000000_00010_00001_100_00011_0110011; // xor x3, x1, x2 rom[8] = 32'b0000000_00010_00001_110_00011_0110011; // or x3, x1, x2 rom[9] = 32'b0000000_00010_00001_111_00011_0110011; // and x3, x1, x2 end // 하위 2bit 를 없애면 4(2^2)의 배수로 표현이 됨, 4byte 단위로 이동 가능 assign data = rom[addr[31:2]]; endmodule < Simulation > < 파일 > sources (HW) MCU ROM CPU_RV32I ControlUnit DataPath sim (HW) RV32I_tb
Final · 2025-08-14
2025-08-13
📌 직무분석 방법 본인의 직무선택 기준과 선택 직무의 구체적 역할 및 필요 역량 확인 지원 직무 수행에 필요한 본인이 준비한 역량 파악 직무 수행에 있어 가장 부족한 역량 확인 부족한 역량 보완을 위한 노력 계획 및 입사 후 포부 작성 KSA 분석 해당 직무에 필요한 지식(K), 기술(S), 태도(A) 기술 위주의 팀플 경험 기재 구조 예시 : 하는 일 → 필요한 KSA → 자신이 보유한 KSA → 근거 사례 → 미보유 KSA → 보유 계획 작성 유의사항 겸손 X / 강점 역량 O 사례를 통한 입증 팀 단위의 직무 관련 경험 강조 (팀원과의 불화 없음을 간접적으로 전달) 📌 구체적인 직무분석 방법 1.고용24 + NCS 직업정보, 평가기준, 직무기술서 확인 2.기업 홈페이지 직무소개 페이지, 회사 공식 정보 3.동영상 채널 현직자 인터뷰, 업계 근황 4.취업포털 사이트 자소설, 사람인(현직자 인터뷰, 7~10년차 경력자 역량 참고), 잡코리아, 잡플래닛 5.직무 관련 커뮤니티 블라인드, 코멘토, 잇다 6.기타 산업기사 자격증이 있다면 실제 기사와 매칭 후 견해 반영 포트폴리오·면접 중요성 상승 📌 직무분석 구조 예시 기업 기본정보 비전, 미션, 전략 비전 수립 이유, 실천 사례 회사개요, 창업이념, 경영화두, CEO 인사말, 신년사, 기업 SNS, 사보 → “그 미션을 함께 수행하기 위해 지원함” 인재상·핵심가치 기업의 인재상 정의 및 재해석 해당 인재상이 필요한 이유 이해 사업현황 수익 구조, 아이템, 매출·영업이익 추진과제 산업 경쟁요소 기준 강점·약점 분석 장기 발전 가능성, 최신 이슈, 지원 정보 신년사에서 키워드 활용 Note: 자소서는 1·2번까지만, 면접은 4개 전부 준비 📌 기업 분석 필수 자료 기업 홈페이지 회사소개, 연혁, 경영이념, 인재상, 비전·미션, 제품·서비스, 브랜드, 사내소식 최근 보도자료 신규사업, 중점사업, 업계 이슈, 신년사 사업목표 DART(사업보고서) 사업규모, 전략, 재무현황 사업소개, 분기보고서, 재무제표, 매출·순이익·증가율 파악 추가 참고 구글 기업사업보고서, IR홍보자료 중소기업: 기술로드맵, 현황 정보시스템, 나이스 기업정보, 한국기업평가 📌 산업분석 주요 산업과 이슈의 맥락 파악 공기업 참고 사이트: ALIO, 디베이팅 데이, 잡플래닛 (자기 기준 설정), DBR 📌 입사지원서 작성 포인트 직무 경험과 KSA 분석 반영 회사 맞춤형 스토리 애매한 이력서 → 서류 탈락 위험 포트폴리오: 그림 위주, 간결하게 작성 전 점검사항 필수분석 여부 강점/경험 정리 직무적합성(제3자 관점 검토) 지나친 겸손 X / 적절한 어필 O 단점 불필요 노출 📌 이력서 팁(KDT) 주소: 도로명까지만 학력: 최근 졸업 2개만 자격사항: 중요도 순 기재 📌 자소서 작성 흐름 직무 파악 필요한 역량 분석 해당 역량 정리 경험 사례 정리 항목별 배치 KSA 우선순위 고려 작성 요령 인사담당자 관점 객관화·수치화 두괄식 → 결론(강점) → 본론(STAR) → 결론 📌 자소서 기본 구성 성장과정: 직무에 맞는 성향 성격소개: 강점 + 보완 노력 직무경험: 역할, 역량 향상, 배운 점 지원동기·포부: 산업 특성·이슈, 회사 방향, 직무 필요성, 적합성, 향후 계획
Final · 2025-08-13
2025-08-12
Dedicated Processor Sum Counter Design < C언어 > i = 0; sum = 0; while (i <= 10) { sum = sum + i i = i + 1; outport = sum; } halt; < Design Specification > i 저장 → Register 1개 sum 저장할 → Register 1개 출력을 저장할 → Register 1게 while 문 → Comparator 덧셈 연산 → Adder < Data Path > < ASM > < Code : DataPath > `timescale 1ns / 1ps module DataPath ( input logic clk, input logic reset, input logic SumSrcMuxSel, input logic ISrcMuxSel, input logic SumEn, input logic IEn, input logic AdderSrcMuxSel, input logic OutPortEn, output logic ILe10, output logic [7:0] OutPort ); logic [7:0] SumSrcMuxOut, ISrcMuxOut; logic [7:0] SumRegOut, IRegOut; logic [7:0] AdderResult, AdderSrcMuxOut; Mux_2x1 U_SumSrcMux ( .sel(SumSrcMuxSel), .x0 (0), .x1 (AdderResult), .y (SumSrcMuxOut) ); Mux_2x1 U_ISrcMux ( .sel(ISrcMuxSel), .x0 (0), .x1 (AdderResult), .y (ISrcMuxOut) ); Register U_SumReg ( .clk (clk), .reset(reset), .en (SumEn), .d (SumSrcMuxOut), .q (SumRegOut) ); Register U_IReg ( .clk (clk), .reset(reset), .en (IEn), .d (ISrcMuxOut), .q (IRegOut) ); Comparator U_ILe10 ( .a (IRegOut), .b (10), .lt(ILe10) ); Mux_2x1 U_AdderSrcMux ( .sel(AdderSrcMuxSel), .x0 (SumRegOut), .x1 (1), .y (AdderSrcMuxOut) ); Adder U_Adder ( .a (AdderSrcMuxOut), .b (IRegOut), .sum(AdderResult) ); Register U_OutPort ( .clk (clk), .reset(reset), .en (OutPortEn), .d (SumRegOut), .q (OutPort) ); endmodule module Register ( input logic clk, input logic reset, input logic en, input logic [7:0] d, output logic [7:0] q ); always_ff @(posedge clk, posedge reset) begin if (reset) begin q <= 0; end else begin if (en) begin q <= d; end end end endmodule module Mux_2x1 ( input logic sel, input logic [7:0] x0, input logic [7:0] x1, output logic [7:0] y ); always_comb begin y = 8'b0; case (sel) 1'b0: y = x0; 1'b1: y = x1; endcase end endmodule module Adder ( input logic [7:0] a, input logic [7:0] b, output logic [7:0] sum ); assign sum = a + b; endmodule module Comparator ( input logic [7:0] a, input logic [7:0] b, output logic lt ); assign lt = a < b; endmodule module OutBuf ( input logic en, input logic [7:0] x, output logic [7:0] y ); assign y = en ? x : 8'bx; endmodule < Schematic > < Code : ControlUnit > `timescale 1ns / 1ps module ControlUnit ( input logic clk, input logic reset, input logic ILe10, output logic SumSrcMuxSel, output logic ISrcMuxSel, output logic SumEn, output logic IEn, output logic AdderSrcMuxSel, output logic OutPortEn ); typedef enum { S0, S1, S2, S3, S4, S5 } state_e; state_e state, next_state; always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= S0; end else begin state <= next_state; end end always_comb begin next_state = state; SumSrcMuxSel = 0; ISrcMuxSel = 0; SumEn = 0; IEn = 0; AdderSrcMuxSel = 0; OutPortEn = 0; case (state) S0: begin // i = 0, sum = 0 SumSrcMuxSel = 0; ISrcMuxSel = 0; SumEn = 1; IEn = 1; AdderSrcMuxSel = 0; // X OutPortEn = 0; next_state = S1; end S1: begin // iLe10 SumSrcMuxSel = 0; ISrcMuxSel = 0; SumEn = 0; IEn = 0; AdderSrcMuxSel = 0; OutPortEn = 0; if (ILe10) next_state = S2; else next_state = S5; end S2: begin // sum = sum + i SumSrcMuxSel = 1; ISrcMuxSel = 1; SumEn = 1; IEn = 0; AdderSrcMuxSel = 0; OutPortEn = 0; next_state = S3; end S3: begin // i = i + 1 SumSrcMuxSel = 1; ISrcMuxSel = 1; SumEn = 0; IEn = 1; AdderSrcMuxSel = 1; OutPortEn = 0; next_state = S4; end S4: begin // OutPort = sum SumSrcMuxSel = 1; ISrcMuxSel = 1; SumEn = 0; IEn = 0; AdderSrcMuxSel = 0; OutPortEn = 1; next_state = S1; end S5: begin // halt SumSrcMuxSel = 1; ISrcMuxSel = 1; SumEn = 0; IEn = 0; AdderSrcMuxSel = 0; OutPortEn = 0; next_state = S5; end endcase end endmodule < Code : DedicatedProcessor > `timescale 1ns / 1ps module DedicatedProcessor ( input logic clk, input logic reset, output logic [7:0] OutPort ); logic SumSrcMuxSel; logic ISrcMuxSel; logic SumEn; logic IEn; logic AdderSrcMuxSel; logic OutPortEn; logic ILe10; DataPath U_DataPath (.*); ControlUnit U_ControlUnit (.*); endmodule < Comment > IReg와 SumReg 두 개의 레지스터로 각각 i 값과 누적합(sum)을 저장한다. OutPort 레지스터는 최종 출력값을 클럭 경계에서 안정적으로 내보낸다. 각 연산에 필요한 피연산자 선택은 MUX를 통해 이루어지며, 하나의 Adder를 공유한다. Comparator(ILe10)는 i ≤ 10 조건을 하드웨어 신호로 변환해 Control Unit이 루프 종료를 판단하도록 한다. < 고찰 > 하나의 Adder로 두 연산을 번갈아 처리하므로 하드웨어 자원 절약 MUX와 Enable 신호로 동작 타이밍과 데이터 경로를 완전히 제어 가능 < Simulation > < Code : top > `timescale 1ns / 1ps module top ( input logic clk, input logic reset, output logic [3:0] fndCom, output logic [7:0] fndFont ); logic clk_10hz; logic [7:0] OutPort; clk_div_10hz U_ClkDiv ( .clk (clk), .reset (reset), .clk_10hz(clk_10hz) ); DedicatedProcessor U_DedicatedProcessor ( .clk (clk_10hz), .reset (reset), .OutPort(OutPort) ); fndController U_FndController ( .clk (clk), .reset (reset), .number ({6'b0, OutPort}), .fndCom (fndCom), .fndFont(fndFont) ); endmodule module clk_div_10hz ( input logic clk, input logic reset, output logic clk_10hz ); //logic [23:0] div_counter; logic [$clog2(10_000_000)-1:0] div_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; clk_10hz <= 1'b0; end else begin if (div_counter == 10_000_000 - 1) begin div_counter <= 0; clk_10hz <= 1'b1; end else begin div_counter <= div_counter + 1; clk_10hz <= 1'b0; end end end endmodule < Schematic > < 파일 > sources (Class) top.sv DedicatedProcessor.sv DataPath.sv ControlUnit.sv fndController.sv simulation (Class) DedicatedProcessor_tb.sv constrs (Class) Basys-3-Master.xdc Register File Design < Design Specification > 데이터 출력: 2개의 Read Port(RD1, RD2)를 통해 ALU로 데이터 전달 주소 지정: 각 Read Port는 별도의 Read Address 입력을 가짐 예: RD1 주소 입력에 0을 주면, 레지스터 0번 데이터 출력 RD2 주소 입력에 2를 주면, 레지스터 2번 데이터 출력 데이터 쓰기: Write Address 입력에 저장할 레지스터 번호 지정 write_en 신호를 1로 하고 클럭 엣지에 맞춰 데이터 저장 예: Write Address = 3, write_en = 1 → 레지스터 3번에 데이터 저장 출력 특성: 별도의 read_enable 없이, 주소가 유효하면 항상 해당 데이터 출력 주소 변경 시 즉시 해당 레지스터 값 출력 < C언어 > R1 = 0; // i R2 = 0; // sum R3 = 1; while (R1 <= 10) { R2 = R2 + R1 R1 = R1 + R3; outport = R2; } halt; < Data Path > < Code : DataPath > `timescale 1ns / 1ps module DataPath ( input logic clk, input logic reset, input logic RFSrcMuxSel, input logic [2:0] RAddr1, input logic [2:0] RAddr2, input logic [2:0] WAddr, input logic we, input logic OutPortEn, output logic R1Le10, output logic [7:0] OutPort ); logic [7:0] AddrResult, RFSrcMuxOut; logic [7:0] RData1, RData2; Mux_2x1 U_RFSrcMux ( .sel(RFSrcMuxSel), .x0 (AddrResult), .x1 (8'b1), .y (RFSrcMuxOut) ); RegFile U_RegFile ( .clk (clk), .RAddr1(RAddr1), .RAddr2(RAddr2), .WAddr (WAddr), .we (we), .Wdata (RFSrcMuxOut), .RData1(RData1), .RData2(RData2) ); Comparator U_R1Le10 ( .a (RData1), .b (8'd10), .lte(R1Le10) ); Adder U_Adder ( .a (RData1), .b (RData2), .sum(AddrResult) ); Register U_Register ( .clk (clk), .reset(reset), .en (OutPortEn), .d (RData1), .q (OutPort) ); endmodule module RegFile ( input logic clk, input logic [2:0] RAddr1, input logic [2:0] RAddr2, input logic [2:0] WAddr, input logic we, input logic [7:0] Wdata, output logic [7:0] RData1, output logic [7:0] RData2 ); logic [7:0] mem[0:2**3-1]; // [0:2**(Number of addresses)-1] always_ff @(posedge clk) begin if (we) begin mem[WAddr] <= Wdata; end end assign RData1 = (RAddr1 == 0) ? 8'b0 : mem[RAddr1]; assign RData2 = (RAddr2 == 0) ? 8'b0 : mem[RAddr2]; endmodule module Register ( input logic clk, input logic reset, input logic en, input logic [7:0] d, output logic [7:0] q ); always_ff @(posedge clk, posedge reset) begin if (reset) begin q <= 0; end else begin if (en) begin q <= d; end end end endmodule module Mux_2x1 ( input logic sel, input logic [7:0] x0, input logic [7:0] x1, output logic [7:0] y ); always_comb begin y = 8'b0; case (sel) 1'b0: y = x0; 1'b1: y = x1; endcase end endmodule module Adder ( input logic [7:0] a, input logic [7:0] b, output logic [7:0] sum ); assign sum = a + b; endmodule module Comparator ( input logic [7:0] a, input logic [7:0] b, output logic lte ); assign lte = a <= b; endmodule < Schematic > Homework_1 < Design Specification > Register File 의 Data Path 이어서 ControlUnit, DedicatedProcessor 설계 동작: RegisterFile 을 이용하여 0 ~ 10 누적 합을 fnd에 출력 < ASM > < Code : ControlUnit > `timescale 1ns / 1ps module ControlUnit ( input logic clk, input logic reset, input logic R1Le10, output logic RFSrcMuxSel, output logic [2:0] RAddr1, output logic [2:0] RAddr2, output logic [2:0] WAddr, output logic we, output logic OutPortEn ); typedef enum { S0, S1, S2, S3, S4, S5, S6, S7 } state_e; state_e state, next_state; always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= S0; end else begin state <= next_state; end end always_comb begin next_state = state; RFSrcMuxSel = 0; RAddr1 = 0; RAddr2 = 0; WAddr = 0; we = 0; OutPortEn = 0; case (state) S0: begin RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd1; we = 1; OutPortEn = 0; next_state = S1; end S1: begin RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd2; we = 1; OutPortEn = 0; next_state = S2; end S2: begin RFSrcMuxSel = 1; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd3; we = 1; OutPortEn = 0; next_state = S3; end S3: begin RFSrcMuxSel = 0; RAddr1 = 4'd1; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 0; if (R1Le10) next_state = S4; else next_state = S7; end S4: begin RFSrcMuxSel = 0; RAddr1 = 4'd1; RAddr2 = 4'd2; WAddr = 4'd2; we = 1; OutPortEn = 0; next_state = S5; end S5: begin RFSrcMuxSel = 0; RAddr1 = 4'd1; RAddr2 = 4'd3; WAddr = 4'd1; we = 1; OutPortEn = 0; next_state = S6; end S6: begin RFSrcMuxSel = 0; RAddr1 = 4'd2; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 1; next_state = S3; end S7: begin RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 0; next_state = S7; end endcase end endmodule < Code : DedicatedProcessor > `timescale 1ns / 1ps module DedicatedProcessor ( input logic clk, input logic reset, output logic [7:0] OutPort ); logic RFSrcMuxSel; logic [2:0] RAddr1; logic [2:0] RAddr2; logic [2:0] WAddr; logic we; logic OutPortEn; logic R1Le10; DataPath U_DataPath (.*); ControlUnit U_ControlUnit (.*); endmodule < Commnet > RegFile에 i, sum, (필요 시) 상수 레지스터를 배치하고, RAddr1/2로 두 피연산자를 선택, WAddr로 연산 결과의 목적지를 지정한다. RFSrcMux는 연산 결과(AddrResult) 또는 즉치값 1 중 하나를 Wdata로 선택해 초기화/증가를 모두 하나의 Adder로 처리할 수 있게 한다. OutPort는 RData1을 샘플/홀드하여 외부로 안정적으로 출력한다(Enable로 출력 타이밍 제어). < 고찰 > 유연성: 주소만 바꿔 i, sum, 상수 등 다양한 조합을 같은 하드웨어로 처리 자원 공유: Adder 1개로 증가와 누적을 모두 수행 → 면적 절약 가독성/확장성: 상수 0은 주소 0로, 상수 1은 한 번 기록 후 재사용하는 패턴으로 컨트롤이 단순 < Video > < 파일 > sources (Homework) top.sv ControlUnit.sv DataPath.sv DedicatedProcessor.sv fndController.sv constrs (Homework) Basys-3-Master.xdc Homework_2 < Design Specification > ALU를 만들어 DedicatedProcessor 설계 R1 = 1, R2 = 0, R3 = 0, R4 = 0 R2 = R1 + R1 R3 = R2 + R1 R4 = R3 - R1 R1 = R1 | R2 R4 < R2; // Yes: R4 = R3 - R1; // No: R4 = R4 & R3; R4 = R4 & R3 R4 = R2 + R3 R2 < R4 // Yes: R2 = R1 + R1; // No: hlat hlat < Data Path > < ASM > < Code : ControlUnit > `timescale 1ns / 1ps module ControlUnit ( input logic clk, input logic reset, input logic lte, output logic RFSrcMuxSel, output logic [2:0] RAddr1, output logic [2:0] RAddr2, output logic [2:0] WAddr, output logic we, output logic OutPortEn, output logic [1:0] ALUop ); typedef enum { S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13 } state_e; state_e state, next_state; always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= S0; end else begin state <= next_state; end end always_comb begin next_state = state; RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 0; ALUop = 4'd0; case (state) S0: begin // R1 = 1 RFSrcMuxSel = 1; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd1; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S1; end S1: begin // R2 = 0 RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd2; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S2; end S2: begin // R3 = 0 RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd3; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S3; end S3: begin // R4 = 0 RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd4; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S4; end S4: begin // R2 = R1 + R1 RFSrcMuxSel = 0; RAddr1 = 4'd1; RAddr2 = 4'd1; WAddr = 4'd2; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S5; end S5: begin // R3 = R2 + R1 RFSrcMuxSel = 0; RAddr1 = 4'd2; RAddr2 = 4'd1; WAddr = 4'd3; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S6; end S6: begin // R4 = R3 = R1 RFSrcMuxSel = 0; RAddr1 = 4'd3; RAddr2 = 4'd1; WAddr = 4'd4; we = 1; OutPortEn = 0; ALUop = 4'd1; next_state = S7; end S7: begin // R1 = R1 | R2 RFSrcMuxSel = 0; RAddr1 = 4'd1; RAddr2 = 4'd2; WAddr = 4'd1; we = 1; OutPortEn = 0; ALUop = 4'd3; next_state = S8; end S8: begin // R4 < R2 RFSrcMuxSel = 0; RAddr1 = 4'd4; RAddr2 = 4'd2; WAddr = 4'd0; we = 0; OutPortEn = 0; ALUop = 4'd0; if (lte) next_state = S5; else next_state = S9; end S9: begin // R4 = R4 & R3 RFSrcMuxSel = 0; RAddr1 = 4'd4; RAddr2 = 4'd3; WAddr = 4'd4; we = 1; OutPortEn = 0; ALUop = 4'd2; next_state = S10; end S10: begin // R4 = R2 + R3 RFSrcMuxSel = 0; RAddr1 = 4'd2; RAddr2 = 4'd3; WAddr = 4'd4; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S11; end S11: begin // OutProt = R4 RFSrcMuxSel = 0; RAddr1 = 4'd4; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 1; ALUop = 4'd0; next_state = S12; end S12: begin // R2 < R4 RFSrcMuxSel = 0; RAddr1 = 4'd2; RAddr2 = 4'd4; WAddr = 4'd0; we = 0; OutPortEn = 0; ALUop = 4'd0; if (lte) next_state = S4; else next_state = S13; end S13: begin // half RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 0; ALUop = 4'd0; next_state = S13; end endcase end endmodule < Code : Data Path > //... module ALU ( input logic [1:0] sel, input logic [7:0] a, input logic [7:0] b, output logic [7:0] alu_result ); always_comb begin alu_result = a + b; case (sel) 2'd0: alu_result = a + b; 2'd1: alu_result = a - b; 2'd2: alu_result = a & b; 2'd3: alu_result = a | b; endcase end endmodule //... < Schematic > < Comment > 반복별 레지스터 값 1회: R1=3, R2=2, R3=3, R4=5 → Yes 2회: R1=7, R2=6, R3=9, R4=15 → Yes 3회: R1=15, R2=14, R3=21, R4=35 → Yes 4회: R1=31, R2=30, R3=45, R4=75 → Yes 5회: R1=63, R2=62, R3=93, R4=155 → Yes 6회: R1=127, R2=126, R3=189, R4=59 → No ⇒ halt 첫 번째 반복 시작 값: (R1, R2, R3, R4) = (1, 0, 0, 0) 계산 순서: R2 = R1 + R1 (1 + 1 = 2) ➞ (1, 2, 0, 0) R3 = R2 + R1 (2 + 1 = 3) ➞ (1, 2, 3, 0) R4 = R3 - R1 (3 - 1 = 2) ➞ (1, 2, 3, 2) R1 = R1 | R2 (1 | 2 = 3) ➞ (3, 2, 3, 2) R4 = R4 & R3 (2 & 3 = 2) ➞ (3, 2, 3, 2) R4 = R2 + R3 (2 + 3 = 5) ➞ (3, 2, 3, 5) 조건 확인: R4 > R2 (5 > 2) ➞ Yes, 계속 진행 두 번째 반복 시작 값: (R1, R2, R3, R4) = (3, 2, 3, 5) 계산 순서: R2 = R1 + R1 (3 + 3 = 6) ➞ (3, 6, 3, 5) R3 = R2 + R1 (6 + 3 = 9) ➞ (3, 6, 9, 5) R4 = R3 - R1 (9 - 3 = 6) ➞ (3, 6, 9, 6) R1 = R1 | R2 (3 | 6 = 7) ➞ (7, 6, 9, 6) R4 = R4 & R3 (6 & 9 = 0) ➞ (7, 6, 9, 0) R4 = R2 + R3 (6 + 9 = 15) ➞ (7, 6, 9, 15) 조건 확인: R4 > R2 (15 > 6) ➞ Yes, 계속 진행 세 번째 반복 시작 값: (R1, R2, R3, R4) = (7, 6, 9, 15) 계산 순서: R2 = R1 + R1 (7 + 7 = 14) ➞ (7, 14, 9, 15) R3 = R2 + R1 (14 + 7 = 21) ➞ (7, 14, 21, 15) R4 = R3 - R1 (21 - 7 = 14) ➞ (7, 14, 21, 14) R1 = R1 | R2 (7 | 14 = 15) ➞ (15, 14, 21, 14) R4 = R4 & R3 (14 & 21 = 4) ➞ (15, 14, 21, 4) R4 = R2 + R3 (14 + 21 = 35) ➞ (15, 14, 21, 35) 조건 확인: R4 > R2 (35 > 14) ➞ Yes, 계속 진행 네 번째 반복 시작 값: (R1, R2, R3, R4) = (15, 14, 21, 35) 계산 순서: R2 = R1 + R1 (15 + 15 = 30) ➞ (15, 30, 21, 35) R3 = R2 + R1 (30 + 15 = 45) ➞ (15, 30, 45, 35) R4 = R3 - R1 (45 - 15 = 30) ➞ (15, 30, 45, 30) R1 = R1 | R2 (15 | 30 = 31) ➞ (31, 30, 45, 30) R4 = R4 & R3 (30 & 45 = 12) ➞ (31, 30, 45, 12) R4 = R2 + R3 (30 + 45 = 75) ➞ (31, 30, 45, 75) 조건 확인: R4 > R2 (75 > 30) ➞ Yes, 계속 진행 다섯 번째 반복 시작 값: (R1, R2, R3, R4) = (31, 30, 45, 75) 계산 순서: R2 = R1 + R1 (31 + 31 = 62) ➞ (31, 62, 45, 75) R3 = R2 + R1 (62 + 31 = 93) ➞ (31, 62, 93, 75) R4 = R3 - R1 (93 - 31 = 62) ➞ (31, 62, 93, 62) R1 = R1 | R2 (31 | 62 = 63) ➞ (63, 62, 93, 62) R4 = R4 & R3 (62 & 93 = 28) ➞ (63, 62, 93, 28) R4 = R2 + R3 (62 + 93 = 155) ➞ (63, 62, 93, 155) 조건 확인: R4 > R2 (155 > 62) ➞ Yes, 계속 진행 여섯 번째 반복 (마지막) 시작 값: (R1, R2, R3, R4) = (63, 62, 93, 155) 계산 순서 R2 = R1 + R1 (63 + 63 = 126) ➞ (63, 126, 93, 155) R3 = R2 + R1 (126 + 63 = 189) ➞ (63, 126, 189, 155) R4 = R3 - R1 (189 - 63 = 126) ➞ (63, 126, 189, 126) R1 = R1 | R2 (63 | 126 = 127) ➞ (127, 126, 189, 126) R4 = R4 & R3 (126 & 189 = 120) ➞ (127, 126, 189, 120) R4 = R2 + R3 (126 + 189 = 315) ➞ (127, 126, 189, 59) 조건 확인: R4 > R2 (59 > 126) ➞ No, 중단 (Halt) 8bit Wrapping (오버플로우): 8비트 레지스터는 255까지만 표현 가능하므로, 315는 256을 뺀 나머지 값인 59가 된다. < 파일 > sources (Homework) ControlUnit.sv DataPath.sv DedicatedProcessor.sv simulation (Homework) DedicatedProcessor_tb.sv
Final · 2025-08-12
2025-08-11
Uart + UpDownCounter Design < Block Design > < Code : uart > `timescale 1ns / 1ps module uart ( // global signal input logic clk, input logic reset, // transmitter signal input logic start, input logic [7:0] tx_data, output logic tx_busy, output logic tx_done, output logic tx, // receiver signal output logic [7:0] rx_data, output logic rx_done, input logic rx ); logic br_tick; baudrate_gen U_BRAUD_GEN ( .clk (clk), .reset (reset), .br_tick(br_tick) ); transmitter U_Transmitter ( .clk (clk), .reset (reset), .br_tick(br_tick), .start (start), .tx_data(tx_data), .tx_busy(tx_busy), .tx_done(tx_done), .tx (tx) ); receiver U_Receiver ( .clk (clk), .reset (reset), .br_tick(br_tick), .rx_data(rx_data), .rx_done(rx_done), .rx (rx) ); endmodule module baudrate_gen ( input logic clk, input logic reset, output logic br_tick ); logic [$clog2(100_000_000 / 9600 / 16)-1:0] br_counter; //logic [3:0] br_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin br_counter <= 0; br_tick <= 1'b0; end else begin if (br_counter == 100_000_000 / 9600 / 16 - 1) begin //if (br_counter == 10 - 1) begin br_counter <= 0; br_tick <= 1'b1; end else begin br_counter <= br_counter + 1; br_tick <= 1'b0; end end end endmodule module transmitter ( input logic clk, input logic reset, input logic br_tick, input logic start, input logic [7:0] tx_data, output logic tx_busy, output logic tx_done, output logic tx ); typedef enum { IDLE, START, DATA, STOP } tx_state_e; tx_state_e tx_state, tx_next_state; logic [7:0] temp_data_reg, temp_data_next; logic tx_reg, tx_next; logic [3:0] tick_cnt_reg, tick_cnt_next; logic [2:0] bit_cnt_reg, bit_cnt_next; logic tx_done_reg, tx_done_next; logic tx_busy_reg, tx_busy_next; assign tx = tx_reg; assign tx_busy = tx_busy_reg; assign tx_done = tx_done_reg; always_ff @(posedge clk, posedge reset) begin if (reset) begin tx_state <= IDLE; temp_data_reg <= 0; tx_reg <= 1'b1; tick_cnt_reg <= 0; bit_cnt_reg <= 0; tx_done_reg <= 0; tx_busy_reg <= 0; end else begin tx_state <= tx_next_state; temp_data_reg <= temp_data_next; tx_reg <= tx_next; tick_cnt_reg <= tick_cnt_next; bit_cnt_reg <= bit_cnt_next; tx_done_reg <= tx_done_next; tx_busy_reg <= tx_busy_next; end end always_comb begin tx_next_state = tx_state; temp_data_next = temp_data_reg; tx_next = tx_reg; tick_cnt_next = tick_cnt_reg; bit_cnt_next = bit_cnt_reg; tx_done_next = tx_done_reg; tx_busy_next = tx_busy_reg; case (tx_state) IDLE: begin tx_next = 1'b1; tx_done_next = 0; tx_busy_next = 0; if (start) begin tx_next_state = START; temp_data_next = tx_data; tick_cnt_next = 0; bit_cnt_next = 0; tx_busy_next = 1; end end START: begin tx_next = 1'b0; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = DATA; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end DATA: begin tx_next = temp_data_reg[0]; if (br_tick) begin if (tick_cnt_reg == 15) begin tick_cnt_next = 0; if (bit_cnt_reg == 7) begin tx_next_state = STOP; bit_cnt_next = 0; end else begin temp_data_next = {1'b0, temp_data_reg[7:1]}; bit_cnt_next = bit_cnt_reg + 1; end end else begin tick_cnt_next = tick_cnt_reg + 1; end end end STOP: begin tx_next = 1'b1; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = IDLE; tx_done_next = 1; tx_busy_next = 0; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end endcase end endmodule module receiver ( input logic clk, input logic reset, input logic br_tick, output logic [7:0] rx_data, output logic rx_done, input logic rx ); typedef enum { IDLE, START, DATA, STOP } rx_state_e; rx_state_e rx_state, rx_next_state; logic [4:0] tick_cnt_reg, tick_cnt_next; logic [2:0] bit_cnt_reg, bit_cnt_next; logic [7:0] rx_data_reg, rx_data_next; logic rx_done_next, rx_done_reg; assign rx_data = rx_data_reg; assign rx_done = rx_done_reg; always_ff @(posedge clk, posedge reset) begin if (reset) begin rx_state <= IDLE; tick_cnt_reg <= 0; bit_cnt_reg <= 0; rx_data_reg <= 0; rx_done_reg <= 0; end else begin rx_state <= rx_next_state; tick_cnt_reg <= tick_cnt_next; bit_cnt_reg <= bit_cnt_next; rx_data_reg <= rx_data_next; rx_done_reg <= rx_done_next; end end always_comb begin rx_next_state = rx_state; rx_done_next = rx_done; tick_cnt_next = tick_cnt_reg; bit_cnt_next = bit_cnt_reg; rx_data_next = rx_data_reg; case (rx_state) IDLE: begin rx_done_next = 0; if (rx == 1'b0) begin rx_next_state = START; tick_cnt_next = 0; bit_cnt_next = 0; rx_data_next = 0; end end START: begin if (br_tick) begin if (tick_cnt_reg == 7) begin tick_cnt_next = 0; rx_next_state = DATA; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end DATA: begin if (br_tick) begin if (tick_cnt_reg == 15) begin tick_cnt_next = 0; rx_data_next = {rx, rx_data_reg[7:1]}; if (bit_cnt_reg == 7) begin bit_cnt_next = 0; rx_next_state = STOP; end else begin bit_cnt_next = bit_cnt_reg + 1; end end else begin tick_cnt_next = tick_cnt_reg + 1; end end end STOP: begin if (br_tick) begin if (tick_cnt_reg == 23) begin tick_cnt_next = 0; rx_done_next = 1; rx_next_state = IDLE; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end endcase end endmodule < Simulation : uart > < Code : UpDownCounter > `timescale 1ns / 1ps module UpDownCounter ( input logic clk, input logic reset, input logic btn_mode, input logic btn_run_stop, input logic btn_clear, input logic [ 7:0] rx_data, input logic rx_done, output logic [ 1:0] led_mode, output logic [ 1:0] led_run_stop, output logic [13:0] count ); logic tick_10hz; logic mode, run_stop, clear; clk_div_10hz U_CLK_DIV_10hz ( .clk (clk), .reset (reset), .run_stop (run_stop), .clear (clear), .tick_10hz(tick_10hz) ); up_down_counter U_UP_DOWN_COUNTER ( .clk (clk), .reset(reset), .tick (tick_10hz), .mode (mode), .clear(clear), .count(count) ); control_unit U_CU ( .clk (clk), .reset (reset), .btn_mode (btn_mode), .btn_run_stop(btn_run_stop), .btn_clear (btn_clear), .rx_data (rx_data), .rx_done (rx_done), .mode (mode), .run_stop (run_stop), .clear (clear), .led_mode (led_mode), .led_run_stop(led_run_stop) ); endmodule // ... module control_unit ( input logic clk, input logic reset, input logic btn_mode, input logic btn_run_stop, input logic btn_clear, input logic [7:0] rx_data, input logic rx_done, output logic mode, output logic run_stop, output logic clear, output logic [1:0] led_mode, output logic [1:0] led_run_stop ); /************************** MODE FSM **************************/ typedef enum { UP, DOWN } state_mode_e; state_mode_e state_mode, next_state_mode; // transition logic always_ff @(posedge clk, posedge reset) begin if (reset) begin state_mode <= UP; end else begin state_mode <= next_state_mode; end end // output logic always_comb begin next_state_mode = state_mode; mode = 0; led_mode = 2'b00; case (state_mode) UP: begin led_mode = 2'b01; mode = 0; if (btn_mode) begin next_state_mode = DOWN; end if (rx_done) begin if (rx_data == 8'h4d || rx_data == 8'h6d) begin // M, m next_state_mode = DOWN; end end end DOWN: begin led_mode = 2'b10; mode = 1; if (btn_mode) begin next_state_mode = UP; end if (rx_done) begin if (rx_data == 8'h4d || rx_data == 8'h6d) begin // M, m next_state_mode = UP; end end end endcase end /********************* RUN STOP CLEAR FSM *********************/ typedef enum { STOP, RUN, CLEAR } state_counter_e; state_counter_e state_counter, next_state_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin state_counter <= STOP; end else begin state_counter <= next_state_counter; end end always_comb begin next_state_counter = state_counter; run_stop = 0; clear = 0; led_run_stop = 2'b00; case (state_counter) STOP: begin led_run_stop = 2'b01; if (btn_run_stop) next_state_counter = RUN; else if (btn_clear) next_state_counter = CLEAR; if (rx_done) begin if (rx_data == 8'h52 || rx_data == 8'h72) begin // R, r next_state_counter = RUN; end end if (rx_done) begin if (rx_data == 8'h43 || rx_data == 8'h63) begin // C, c next_state_counter = CLEAR; end end end RUN: begin run_stop = 1; led_run_stop = 2'b10; if (btn_run_stop) next_state_counter = STOP; if (rx_done) begin if (rx_data == 8'h53 || rx_data == 8'h73) begin // S, s next_state_counter = STOP; end end end CLEAR: begin clear = 1; next_state_counter = STOP; end endcase end endmodule < Schematic > < 파일 > sources (Class) top_UpDownCounter.sv uart.sv button_detector.sv UpDownCounter.sv tfndController.svext simulation (Class) uart_tb.sv constrs (Class) Basys-3-Master.xdc CPU CISC(Complex Instruction Set Computer) micro processor에게 명령을 내리는데 필요한 모든 명령어 셋을 갖추고 있는 processor이다. 따라서 복잡하고 기능이 많은 명령어로 구성되어있다. 과거에는 컴퓨터 메모리 용량이 크지 않아서 sw 프로그램의 용량을 줄이기 위해 하나의 명령어로 여러 작업을 수행하도록 했기 때문에 CISC를 많이 사용하였다. 장점: 복합적이고 기능이 많기 때문에 하위 호환성?이 좋다. 따라서 호환성이 절대적으로 필요한 PC 환경에서는 CISC를 사용하는 것이 좋다. 단점: 하지만 트랜지스터 집적에 있어서 효율성이 떨어지기 때문에 성능 향상을 방해하는 요인이 될 수 있으며, 전력 소모가 크고, 가격이 비싸다는 등의 단점이 있다. 용도: 다양한 명령어를 포함하고 있어 일반적으로 우리가 사용하는 범용 컴퓨터(general purpose computer)의 CPU로 많이 사용된다. RISC(Reduced Instruction Set Computer) CISC 내부에 갖추어진 모든 명령어들 중 불과 20%에 해당하는 명령어들만이 전체 80% 이상의 일을 처리한다. 따라서 CISC와 같이 필요한 모든 명령어 셋을 갖고 있는 것은 비효율적일 수 있다. 이를 극복하기 위해 등장한 것이 RISC이다. 장점: RISC는 적은 수의 명령어들(사용 빈도가 높은 20%의 명령어들)로 구성된 processor이다. 따라서 CISC보다 더 빠른 속도?로 동작할 수 있으며, 단순하고, 전력소모가 적고, 가격도 저렴하다. (Tr 갯수 ↓) 단점: 하지만 하드웨어가 간단한 대신 소프트웨어(Compiler)가 크고 복잡해졌으며, 하위 호환성이 부족하다는 단점이 있다. 용도: RISC 구조는 파이프라인 중첩이 가능해서 같은 수의 명령어에 대해 적은 clock으로 처리가 가능하며 발열과 전력 소모도 줄일 수 있다. 따라서 임베디드 프로세서에서는 RISC 구조를 많이 사용한다. (MIPS, ARM) 앞으로의 학습 및 구현 계획 RISC-V Instruction Set 이해 RV32I (Base Integer ISA) 구현 1.Single-Cycle Processor (모든 명령어를 1 클럭 내에 실행) 2.Multi-Cycle Processor (명령어 종류에 따라 실행 클럭 수가 다름) 3.Pipeline 구조 CPU (선택 사항 / 미구현 예정) DedicatedProcessor_Counter Design < Design Specification > 0~9 까지 카운트하는 Processor를 설계 A = 0 (Data) < C 언어 > A = 0; while (A < 10) { output = A; A = A + 1; } halt; < Data Path > < ASM > < Code : DedicatedProcessor_Counter > `timescale 1ns / 1ps module DedicatedProcessor_Counter ( input logic clk, input logic reset, output logic [7:0] OutBuffer ); logic ASrcMuxSel; logic AEn; logic ALt10; logic OutBufEn; logic [$clog2(10_000_000)-1:0] div_counter; logic clk_10hz; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; end else begin if (div_counter == 10_000_000 - 1) begin div_counter <= 0; clk_10hz <= 1'b1; end else begin div_counter <= div_counter + 1; clk_10hz <= 1'b0; end end end ControlUnit U_ControlUnit ( .clk(clk_10hz), // bitstream .* ); DataPath U_DataPath ( .clk(clk_10hz), // bitstream .* ); endmodule module Register ( input logic clk, input logic reset, input logic en, input logic [7:0] d, output logic [7:0] q ); always_ff @(posedge clk, posedge reset) begin if (reset) begin q <= 0; end else begin if (en) begin q <= d; end end end endmodule module Mux_2x1 ( input logic sel, input logic [7:0] x0, input logic [7:0] x1, output logic [7:0] y ); always_comb begin y = 8'b0; case (sel) 1'b0: y = x0; 1'b1: y = x1; endcase end endmodule module Adder ( input logic [7:0] a, input logic [7:0] b, output logic [7:0] sum ); assign sum = a + b; endmodule module Comparator ( input logic [7:0] a, input logic [7:0] b, output logic lt ); assign lt = a < b; endmodule module OutBuf ( input logic en, input logic [7:0] x, output logic [7:0] y ); assign y = en ? x : 8'bx; endmodule module ControlUnit ( input logic clk, input logic reset, input logic ALt10, output logic ASrcMuxSel, output logic AEn, output logic OutBufEn ); typedef enum { S0, S1, S2, S3, S4 } state_e; state_e state, next_state; always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= S0; end else begin state <= next_state; end end always_comb begin ASrcMuxSel = 0; AEn = 0; OutBufEn = 0; next_state = state; case (state) S0: begin ASrcMuxSel = 0; AEn = 1; OutBufEn = 0; next_state = S1; end S1: begin ASrcMuxSel = 1; AEn = 0; OutBufEn = 0; if (ALt10) next_state = S2; else next_state = S4; end S2: begin ASrcMuxSel = 1; AEn = 0; OutBufEn = 1; next_state = S3; end S3: begin ASrcMuxSel = 1; AEn = 1; OutBufEn = 0; next_state = S1; end S4: begin ASrcMuxSel = 1; AEn = 0; OutBufEn = 0; next_state = S4; end endcase end endmodule module DataPath ( input logic clk, input logic reset, input logic ASrcMuxSel, input logic AEn, input logic OutBufEn, output logic ALt10, output logic [7:0] OutBuffer ); logic [7:0] AdderResult, ASrcMuxOut, ARegOut; Mux_2x1 U_ASrcMux ( .sel(ASrcMuxSel), .x0 (8'b0), .x1 (AdderResult), .y (ASrcMuxOut) ); Register U_A_Reg ( .clk (clk), .reset(reset), .en (AEn), .d (ASrcMuxOut), .q (ARegOut) ); Comparator U_ALt10 ( .a (ARegOut), .b (8'd10), .lt(ALt10) ); Adder U_Adder ( .a (ARegOut), .b (8'd1), .sum(AdderResult) ); // OutBuf U_OutBuf ( // .en(OutBufEn), // .x (ARegOut), // .y (OutBuffer) // ); Register U_OutReg ( .clk (clk), .reset(reset), .en (OutBufEn), .d (ARegOut), .q (OutBuffer) ); endmodule < Comment > DataPath Comparator 출력(ALt10)은 C의 while (A < 10)을 하드웨어로 치환한 제어 분기 입력으로 필수다. 레지스터별 Enable은 A 업데이트와 출력 샘플링의 타이밍을 독립 제어해 정확한 순서·정지·초기화를 보장한다. 동일 엣지에서 OutReg와 AReg를 함께 샘플링함으로써 C의 “output=A; A=A+1;”를 클럭 하나로 정확히 구현한다. < Schematic > < Simulation > < 파일 > sources (Class) DedicatedProcessor_Counter.sv simulation (Class) DedicatedProcessor_Counter_tb.sv constrs (Class) Basys-3-Master.xdc Homework < Design Specification > 0+1+2+3+…+9+10 = 55 와 같이 누적으로 덧셈 결과 출력이 되도록 구현 FND에 누적 값을 출력 < C 언어 > a = 0; b = 0; while (a <= 10) { b = b + a; // 누적 a = a + 1; // 증가 } output = b; // 55 < Data Path > < ASM > < Code : top > `timescale 1ns / 1ps module top ( input logic clk, input logic reset, output logic [3:0] fndCom, output logic [7:0] fndFont ); logic [7:0] data; DedicatedProcessor U_DedicatedProcessor ( .clk(clk), .reset(reset), .OutBuffer(data) ); fndController U_fndController ( .clk(clk), .reset(reset), .number(data), .fndCom(fndCom), .fndFont(fndFont) ); endmodule < Code : DedicatedProcessor (DataPath) > //... module DataPath ( input logic clk, input logic reset, input logic ASrcMuxSel, input logic AEn, input logic OutBufEn, output logic ALt10, output logic [7:0] OutBuffer ); logic [7:0] AdderResult, ASrcMuxOut, ARegOut; logic [7:0] SumResult, BSrcMuxOut, BRegOut; Mux_2x1 U_ASrcMux ( .sel(ASrcMuxSel), .x0 (8'b0), .x1 (AdderResult), .y (ASrcMuxOut) ); Register U_A_Reg ( .clk (clk), .reset(reset), .en (AEn), .d (ASrcMuxOut), .q (ARegOut) ); Comparator U_ALt10 ( .a (ARegOut), .b (8'd11), // 8'd11 .lt(ALt10) ); Adder U_Adder ( .a (ARegOut), .b (8'd1), .sum(AdderResult) ); // OutBuf U_OutBuf ( // .en(OutBufEn), // .x (ARegOut), // .y (OutBuffer) // ); // Register U_OutReg ( // .clk (clk), // .reset(reset), // .en (OutBufEn), // .d (ARegOut), // .q (OutBuffer) // ); /*************** B ***************/ Mux_2x1 U_BSrcMux ( .sel(ASrcMuxSel), .x0 (8'b0), .x1 (SumResult), .y (BSrcMuxOut) ); Register U_B_Reg ( .clk (clk), .reset(reset), .en (AEn), .d (BSrcMuxOut), .q (BRegOut) ); Adder U_Sum ( .a (AdderResult), .b (BRegOut), .sum(SumResult) ); Register U_OutReg ( .clk (clk), .reset(reset), .en (OutBufEn), .d (BRegOut), .q (OutBuffer) ); endmodule //... < Comment > DataPath 누적값(B)에 현재 항(A 또는 A+1)을 더하는 덧셈기와 누적값을 저장하는 레지스터(B Reg)를 추가 A와 B는 동일한 Enable(AEn)과 초기화 경로(ASrcMuxSel=0)를 공유하여 루프 갱신 시 동시 업데이트가 가능 출력 레지스터를 두어 글리치 방지와 타이밍 여유를 확보 < simulation > < Video > < 고찰 > DataPath에 누적기 경로를 추가함으로써, 단순 카운트가 아닌 누적 연산까지 지원하는 구조를 구현할 수 있었다. 각 레지스터의 Enable과 조건 제어를 통해 출력 안정성과 연산 정확성을 확보하였다. < 파일 > sources (Homework) top.sv DedicatedProcessor.sv fndController.sv simulation (Homework) DedicatedProcessor_tb.sv constrs (Homework) Basys-3-Master.xdc
Final · 2025-08-11
2025-08-08
Run_Stop_Clear_Counter Design < Code : UpDownCounter > `timescale 1ns / 1ps module UpDownCounter ( input logic clk, input logic reset, input logic btn_mode, input logic btn_run_stop, input logic btn_clear, output logic [ 1:0] led_mode, output logic [ 1:0] led_run_stop, output logic [13:0] count ); logic tick_10hz; logic mode, run_stop, clear; clk_div_10hz U_Clk_Div_10hz ( .clk (clk), .reset (reset), .run_stop (run_stop), .clear (clear), .tick_10hz(tick_10hz) ); up_down_counter U_Up_Down_Counter ( .clk (clk), .reset(reset), .tick (tick_10hz), .mode (mode), .clear(clear), .count(count) ); control_unit U_Control_Unit ( .clk (clk), .reset (reset), .btn_mode (btn_mode), .btn_run_stop(btn_run_stop), .btn_clear (btn_clear), .mode (mode), .run_stop (run_stop), .clear (clear), .led_mode (led_mode), .led_run_stop(led_run_stop) ); endmodule module clk_div_10hz ( input logic clk, input logic reset, input logic run_stop, input logic clear, output logic tick_10hz ); //logic [23:0] div_counter; logic [$clog2(10_000_000)-1:0] div_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; tick_10hz <= 1'b0; end else begin if (run_stop) begin if (div_counter == 10_000_000 - 1) begin div_counter <= 0; tick_10hz <= 1'b1; end else begin div_counter <= div_counter + 1; tick_10hz <= 1'b0; end end if (clear) begin div_counter <= 0; tick_10hz <= 1'b0; end end end endmodule module up_down_counter ( input logic clk, input logic reset, input logic tick, input logic mode, input logic clear, output logic [13:0] count ); always_ff @(posedge clk, posedge reset) begin if (reset) begin count <= 0; end else begin if (clear) begin count <= 0; end if (mode == 1'b0) begin // up counter if (tick) begin if (count == 9999) begin count <= 0; end else begin count <= count + 1; end end end else begin // down counter if (tick) begin if (count == 0) begin count <= 9999; end else begin count <= count - 1; end end end end end endmodule module control_unit ( input logic clk, input logic reset, input logic btn_mode, input logic btn_run_stop, input logic btn_clear, output logic mode, output logic run_stop, output logic clear, output logic [1:0] led_mode, output logic [1:0] led_run_stop ); /******************** MODE FSM ********************/ typedef enum { UP, DOWN } state_mode_e; state_mode_e state_mode, next_state_mode; // state memory always_ff @(posedge clk, posedge reset) begin if (reset) begin state_mode <= UP; end else begin state_mode <= next_state_mode; end end // transition logic always_comb begin next_state_mode = state_mode; mode = 0; led_mode = 2'b00; case (state_mode) UP: begin led_mode = 2'b01; if (btn_mode) begin next_state_mode = DOWN; end end DOWN: begin mode = 1; led_mode = 2'b10; if (btn_mode) begin next_state_mode = UP; end end endcase end /******************** RUN STOP CLEAR FSM ********************/ typedef enum { STOP, RUN, CLEAR } state_counter_e; state_counter_e state_counter, next_state_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin state_counter <= STOP; end else begin state_counter <= next_state_counter; end end always_comb begin next_state_counter = state_counter; run_stop = 0; clear = 0; led_run_stop = 2'b00; case (state_counter) STOP: begin led_run_stop = 2'b01; if (btn_run_stop) next_state_counter = RUN; else if (btn_clear) next_state_counter = CLEAR; end RUN: begin run_stop = 1; led_run_stop = 2'b10; if (btn_run_stop) next_state_counter = STOP; end CLEAR: begin clear = 1; next_state_counter = STOP; end endcase end endmodule < Comment > clk_div_10hz run_stop과 clear 신호를 받아 상태에 따라 카운터 동작을 제어한다. up_down_counter clear 신호를 받아 카운터 값을 즉시 초기화한다. → 예기치 않은 상태에서도 원하는 시점에 카운터를 안정적으로 리셋할 수 있다. control_unit 하나의 control_unit에서 상태 구분용 제어 신호를 받아 여러 개의 FSM(mode, run/stop/clear)을 동시에 처리한다. 각 FSM에서 led_mode와 led_run_stop 출력을 직접 생성하도록 설계하여 가독성과 직관성이 향상된다. < 파일 > sources (Class) top_UpDownCounter.sv button_detector.sv UpDownCounter.sv fndController.sv constrs (Class) Basys-3-Master.xdc Serial 통신 프로토콜 1. UART 비동기(Asynchronous) 통신 방식 Baud rate(bps, bit per second) 설정 값에 따라 송수신 속도 결정 송·수신 양측의 속도 설정이 다르면 통신 불가 동기 신호가 없어 에러율이 상대적으로 높음 송수신 속도에 제한이 있음 1:1 통신만 가능 (멀티포인트 불가) 송·수신 측에서 내부 클럭을 생성하여 타이밍 유지 2. I²C 동기(Synchronous) 통신 방식 SCL(클럭)과 SDA(데이터) 2선으로 동작 슬레이브 주소(Address)를 지정해 통신 → SPI보다 속도가 느림 N:N 통신 가능 (하나의 버스에 여러 마스터·슬레이브 연결 가능) Chip Select 신호선 불필요 (주소로 구분) 송신 또는 수신 중 한 방향만 가능 (Half-duplex) 3. SPI 동기(Synchronous) 통신 방식 SCLK(클럭), MOSI, MISO, CS(Chip Select) 신호 사용 클럭에 맞춰 매우 빠른 데이터 전송 가능 → 세 방식 중 가장 빠름 1:N 통신 (마스터 1개, 다수 슬레이브 가능) 슬레이브 선택을 위해 Chip Select 신호선 사용 송수신 동시 가능 (Full-duplex) UART / I²C / SPI 비교 구분 UART I²C SPI 통신 방식 비동기 동기 동기 데이터선 Tx, Rx SDA, SCL MOSI, MISO, SCLK, CS 속도 낮음 중간 빠름 통신 구조 1:1 N:N 1:N Chip Select X X O Duplex Full Half Full 장점 간단, 배선 적음 배선 적음, 다중 지원 빠름, 동시 송수신 단점 느림, 멀티 불가 SPI보다 느림 배선 많음, CS 관리 필요 Uart (Transmitter) Design < Block Design > < FSM (Transmitter) > < ASM (Transmitter) > < Code : Uart (Transmitter) > `timescale 1ns / 1ps module uart ( input logic clk, input logic reset, input logic start, input logic [7:0] tx_data, output logic tx, output logic tx_busy, output logic tx_done ); logic br_tick; baudrate_gen U_Baudrate_Gen ( .clk (clk), .reset (reset), .br_tick(br_tick) ); transmitter U_Transmitter ( .clk (clk), .reset (reset), .br_tick(br_tick), .start (start), .tx_data(tx_data), .tx_busy(tx_busy), .tx_done(tx_done), .tx (tx) ); endmodule module baudrate_gen ( input logic clk, input logic reset, output logic br_tick ); //logic [$clog2(100_000_000/9600/16)-1:0] br_counter; logic [3:0] br_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin br_counter <= 0; br_tick <= 1'b0; end else begin //if (br_counter == 100_000_000 / 9600 / 16 - 1) begin // 9600hz 9600bps if (br_counter == 10 - 1) begin br_counter <= 0; br_tick <= 1'b1; end else begin br_counter <= br_counter + 1; br_tick <= 1'b0; end end end endmodule module transmitter ( input logic clk, input logic reset, input logic br_tick, input logic start, input logic [7:0] tx_data, output logic tx_busy, output logic tx_done, output logic tx ); typedef enum { IDLE, START, DATA, STOP } tx_state_e; tx_state_e tx_state, tx_next_state; logic [7:0] temp_data_next, temp_data_reg; logic tx_reg, tx_next; logic [3:0] tick_cnt_reg, tick_cnt_next; logic [2:0] bit_cnt_reg, bit_cnt_next; logic tx_done_reg, tx_done_next; logic tx_busy_reg, tx_busy_next; assign tx = tx_reg; assign tx_busy = tx_busy_reg; assign tx_done = tx_done_reg; always_ff @(posedge clk, posedge reset) begin if (reset) begin tx_state <= IDLE; temp_data_reg <= 0; tx_reg <= 1'b1; tick_cnt_reg <= 0; bit_cnt_reg <= 0; tx_done_reg <= 0; tx_busy_reg <= 0; end else begin tx_state <= tx_next_state; temp_data_reg <= temp_data_next; tx_reg <= tx_next; tick_cnt_reg <= tick_cnt_next; bit_cnt_reg <= bit_cnt_next; tx_done_reg <= tx_done_next; tx_busy_reg <= tx_busy_next; end end always_comb begin tx_next_state = tx_state; temp_data_next = temp_data_reg; tx_next = tx_reg; tick_cnt_next = tick_cnt_reg; bit_cnt_next = bit_cnt_reg; tx_done_next = tx_done_reg; tx_busy_next = tx_busy_reg; case (tx_state) IDLE: begin tx_next = 1'b1; tx_done_next = 0; tx_busy_next = 0; if (start) begin tx_next_state = START; temp_data_next = tx_data; tick_cnt_next = 0; bit_cnt_next = 0; tx_busy_next = 1; end end START: begin tx_next = 1'b0; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = DATA; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end DATA: begin tx_next = temp_data_reg[0]; if (br_tick) begin if (tick_cnt_reg == 15) begin tick_cnt_next = 0; if (bit_cnt_reg == 7) begin tx_next_state = STOP; bit_cnt_next = 0; end else begin temp_data_next = {1'b0, temp_data_reg[7:1]}; bit_cnt_next = bit_cnt_reg + 1; end end else begin tick_cnt_next = tick_cnt_reg + 1; end end end STOP: begin tx_next = 1'b1; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = IDLE; tx_done_next = 1; tx_busy_next = 0; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end endcase end endmodule < Comment > baudrate_gen 시스템 클럭(100 MHz)에서 UART 통신 속도 9600bps, 16배 오버샘플링(표준 UART 수신 방식) 조건에 맞춰 br_tick을 생성하는 모듈이다. 카운터 최대값을 100_000_000 / 9600 / 16 - 1로 설정하여, 해당 주기마다 br_tick을 1클럭 동안 High로 만들어 transmitter와 receiver가 동일한 baudrate 클럭에 동기화되도록 한다. transmitter UART 송신기를 구현한 모듈로, start 신호 입력 시 데이터(tx_data)를 UART 프레임 구조(1 start bit + 8 data bits + 1 stop bit)로 직렬 전송한다. FSM(IDLE → START → DATA → STOP)으로 동작하며, 각 비트 전송은 baudrate 오버샘플링(16배) 기준 br_tick 신호에 맞춰 진행된다. 데이터 구동 시 LSB부터 순차적으로 전송하며, 모든 비트 전송이 완료되면 tx_done을 1로 설정하고 tx_busy를 0으로 복귀시켜 다음 전송을 준비한다. < 파일 > sources (Class) uart.sv sim (Class) uart_tb.sv Homework < Design Specification > receiver 설계 → uart 구현 uart + up down counter → PC 제어 (ComPortMaster) “r” : run 상태 ”s” : stop 상태 “c” : clear 상태 “m” : mode변경 < Block Diagram > < FSM (receiver) > < ASM (receiver) > < Code : uart > `timescale 1ns / 1ps module uart ( input logic clk, input logic reset, input logic rx, output logic tx, output logic [7:0] uart_data ); logic br_tick; logic rx_done; logic [7:0] rx_data; assign uart_data = rx_done ? rx_data : 8'b0; baudrate_gen U_Baudrate_Gen ( .clk (clk), .reset (reset), .br_tick(br_tick) ); receiver U_Receiver ( .clk (clk), .reset (reset), .br_tick(br_tick), .rx (rx), .rx_data(rx_data), .rx_done(rx_done) ); transmitter U_Transmitter ( .clk (clk), .reset (reset), .br_tick(br_tick), .start (rx_done), .tx_data(rx_data), .tx_busy(), .tx_done(), .tx (tx) ); endmodule module baudrate_gen ( input logic clk, input logic reset, output logic br_tick ); logic [$clog2(100_000_000/9600/16)-1:0] br_counter; // logic [3:0] br_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin br_counter <= 0; br_tick <= 1'b0; end else begin if (br_counter == 100_000_000 / 9600 / 16 - 1) begin // 9600hz 9600bps // if (br_counter == 10 - 1) begin br_counter <= 0; br_tick <= 1'b1; end else begin br_counter <= br_counter + 1; br_tick <= 1'b0; end end end endmodule module receiver ( input logic clk, input logic reset, input logic br_tick, input logic rx, output logic [7:0] rx_data, output logic rx_done ); typedef enum { IDLE, START, DATA, STOP } rx_state_e; rx_state_e rx_state, rx_next_state; logic [7:0] rx_data_reg, rx_data_next; logic [4:0] tick_cnt_reg, tick_cnt_next; logic [2:0] bit_cnt_reg, bit_cnt_next; logic rx_done_reg, rx_done_next; assign rx_done = rx_done_reg; assign rx_data = rx_data_reg; always_ff @(posedge clk, posedge reset) begin if (reset) begin rx_state <= IDLE; rx_data_reg <= 0; tick_cnt_reg <= 0; bit_cnt_reg <= 0; rx_done_reg <= 0; end else begin rx_state <= rx_next_state; rx_data_reg <= rx_data_next; tick_cnt_reg <= tick_cnt_next; bit_cnt_reg <= bit_cnt_next; rx_done_reg <= rx_done_next; end end always_comb begin rx_next_state = rx_state; rx_data_next = rx_data_reg; tick_cnt_next = tick_cnt_reg; bit_cnt_next = bit_cnt_reg; rx_done_next = rx_done_reg; case (rx_state) IDLE: begin rx_done_next = 0; if (rx == 0) begin rx_next_state = START; rx_data_next = 0; tick_cnt_next = 0; bit_cnt_next = 0; end end START: begin if (br_tick) begin if (tick_cnt_reg == 7) begin rx_next_state = DATA; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end DATA: begin if (br_tick) begin if (tick_cnt_reg == 15) begin tick_cnt_next = 0; rx_data_next = {rx, rx_data_reg[7:1]}; if (bit_cnt_reg == 7) begin rx_next_state = STOP; bit_cnt_next = 0; end else begin bit_cnt_next = bit_cnt_reg + 1; end end else begin tick_cnt_next = tick_cnt_reg + 1; end end end STOP: begin if (br_tick) begin if (tick_cnt_reg == 23) begin rx_next_state = IDLE; rx_done_next = 1; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end endcase end endmodule module transmitter ( input logic clk, input logic reset, input logic br_tick, input logic start, input logic [7:0] tx_data, output logic tx_busy, output logic tx_done, output logic tx ); typedef enum { IDLE, START, DATA, STOP } tx_state_e; tx_state_e tx_state, tx_next_state; logic [7:0] temp_data_next, temp_data_reg; logic tx_reg, tx_next; logic [3:0] tick_cnt_reg, tick_cnt_next; logic [2:0] bit_cnt_reg, bit_cnt_next; logic tx_done_reg, tx_done_next; logic tx_busy_reg, tx_busy_next; assign tx = tx_reg; assign tx_busy = tx_busy_reg; assign tx_done = tx_done_reg; always_ff @(posedge clk, posedge reset) begin if (reset) begin tx_state <= IDLE; temp_data_reg <= 0; tx_reg <= 1'b1; tick_cnt_reg <= 0; bit_cnt_reg <= 0; tx_done_reg <= 0; tx_busy_reg <= 0; end else begin tx_state <= tx_next_state; temp_data_reg <= temp_data_next; tx_reg <= tx_next; tick_cnt_reg <= tick_cnt_next; bit_cnt_reg <= bit_cnt_next; tx_done_reg <= tx_done_next; tx_busy_reg <= tx_busy_next; end end always_comb begin tx_next_state = tx_state; temp_data_next = temp_data_reg; tx_next = tx_reg; tick_cnt_next = tick_cnt_reg; bit_cnt_next = bit_cnt_reg; tx_done_next = tx_done_reg; tx_busy_next = tx_busy_reg; case (tx_state) IDLE: begin tx_next = 1'b1; tx_done_next = 0; tx_busy_next = 0; if (start) begin tx_next_state = START; temp_data_next = tx_data; tick_cnt_next = 0; bit_cnt_next = 0; tx_busy_next = 1; end end START: begin tx_next = 1'b0; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = DATA; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end DATA: begin tx_next = temp_data_reg[0]; if (br_tick) begin if (tick_cnt_reg == 15) begin tick_cnt_next = 0; if (bit_cnt_reg == 7) begin tx_next_state = STOP; bit_cnt_next = 0; end else begin temp_data_next = {1'b0, temp_data_reg[7:1]}; bit_cnt_next = bit_cnt_reg + 1; end end else begin tick_cnt_next = tick_cnt_reg + 1; end end end STOP: begin tx_next = 1'b1; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = IDLE; tx_done_next = 1; tx_busy_next = 0; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end endcase end endmodule < Comment > uart Baudrate Generator: 시스템 클럭(예: 100 MHz)에서 UART 속도(9600 bps, 16배 오버샘플링)에 맞춘 br_tick 생성. 송·수신 모듈 모두 이 신호로 타이밍 동기화. Receiver: rx 입력을 샘플링해 8비트 데이터(rx_data) 복원, 수신 완료 시 rx_done=1 출력. Transmitter: rx_done 신호를 start로 받아, 수신한 데이터를 그대로 직렬 송신(tx). uart_data: rx_done 시점에만 유효 데이터를 출력, 그 외에는 0 유지. 전체적으로 수신한 데이터를 즉시 재전송(Echo)하는 구조이며, 모든 시퀀스는 br_tick 기반으로 송·수신 동기를 유지한다. receiver UART 수신기. rx의 start-bit(낙하) 감지 후 16배 오버샘플링 기준 br_tick에 맞춰 비트 중앙에서 샘플링한다. < Code : top_Uart_UpDownCounter > `timescale 1ns / 1ps module top_Uart_UpDownCounter ( input logic clk, input logic reset, input logic [2:0] btn, input logic rx, output logic tx, output logic [1:0] led_mode, output logic [1:0] led_run_stop, output logic [3:0] fndCom, output logic [7:0] fndFont ); logic [7:0] uart_data; uart U_Uart ( .clk (clk), .reset (reset), .rx (rx), .tx (tx), .uart_data(uart_data) ); top_UpDownCounter U_Top_UpDownCounter ( .clk (clk), .reset (reset), .btn (btn), .uart_data (uart_data), .led_mode (led_mode), .led_run_stop(led_run_stop), .fndCom (fndCom), .fndFont (fndFont) ); endmodule < Code : UpDownCounter (control_unit) > // ... module control_unit ( input logic clk, input logic reset, input logic btn_mode, input logic btn_run_stop, input logic btn_clear, input logic [7:0] uart_data, output logic mode, output logic run_stop, output logic clear, output logic [1:0] led_mode, output logic [1:0] led_run_stop ); /******************** MODE FSM ********************/ typedef enum { UP, DOWN } state_mode_e; state_mode_e state_mode, next_state_mode; // state memory always_ff @(posedge clk, posedge reset) begin if (reset) begin state_mode <= UP; end else begin state_mode <= next_state_mode; end end // transition logic always_comb begin next_state_mode = state_mode; mode = 0; led_mode = 2'b00; case (state_mode) UP: begin led_mode = 2'b01; if (btn_mode || (uart_data == "m")) begin next_state_mode = DOWN; end end DOWN: begin mode = 1; led_mode = 2'b10; if (btn_mode || (uart_data == "m")) begin next_state_mode = UP; end end endcase end /******************** RUN STOP CLEAR FSM ********************/ typedef enum { STOP, RUN, CLEAR } state_counter_e; state_counter_e state_counter, next_state_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin state_counter <= STOP; end else begin state_counter <= next_state_counter; end end always_comb begin next_state_counter = state_counter; run_stop = 0; clear = 0; led_run_stop = 2'b00; case (state_counter) STOP: begin led_run_stop = 2'b01; if (btn_run_stop || (uart_data == "r")) next_state_counter = RUN; else if (btn_clear || (uart_data == "c")) next_state_counter = CLEAR; end RUN: begin run_stop = 1; led_run_stop = 2'b10; if (btn_run_stop || (uart_data == "s")) next_state_counter = STOP; end CLEAR: begin clear = 1; next_state_counter = STOP; end endcase end endmodule < Schematic > < Video > < 고찰 > control_unit에서 UART 데이터를 입력받아 상태 변경 사항을 업데이트하도록 설계 → 확장성 확보 < 파일 > sources (Homework) top_Uart_UpDownCounter.sv uart.sv top_UpDownCounter.sv button_detector.sv UpDownCounter.sv fndController.sv constrs (Homework) Basys-3-Master.xdc
Final · 2025-08-08
2025-08-07
디지털 회로 기본 및 타이밍 특성 D-flip flop , Latch 차이 메모리 기능의 유무 → 둘 다 메모리 기능이 있지만, 동작 방식에 차이가 있음 Latch: 입력 신호가 활성화된 동안 값을 계속 반영함 (레벨 민감) D Flip-Flop: 클록 상승/하강 에지에서만 값을 반영 (엣지 트리거) 조합회로 (Combinational Circuit) 현재 입력에 의해서만 출력이 결정됨 과거 입력이나 상태와는 무관 예시: AND, OR, MUX, Decoder 등 순차회로 (Sequential Circuit) 클록 신호에 따라 동작 (동기식 설계) 출력은 현재 입력 + 이전 상태에 의존 예시: D Flip-Flop, 레지스터, FSM 등 SR Latch S=0, R=0 → Q=유지, Q′=유지 → 정상 상태 (Hold) S=0, R=1 → Q=0, Q′=1 → Reset 동작 S=1, R=0 → Q=1, Q′=0 → Set 동작 S=1, R=1 → Q=0, Q′=0 → 금지 상태 (Invalid) D Latch D=0, S=0, R=1 → Reset D=1, S=1, R=0 → Set Gated D Latch Gate=0, D=x, Q=유지, Q’=유지 → Hold 상태 Gate=1, D=0, Q=0, Q’=1 → Reset 동작 Gate=1, D=1, Q=1, Q’=0 → Set 동작 D-Filp Flop D Flip-Flop은 Master-Slave 구조의 두 개의 D-Latch로 구성 Master: 클록이 0일 때 입력 값을 저장 Slave: 클록이 1일 때 Master의 값을 출력에 전달 따라서 클록의 상승/하강 엣지에만 출력이 바뀜 (엣지 트리거) Metastability 클록 엣지 시점에 입력(D)이 변할 경우, 출력(Q)이 일정 시간 동안 정의되지 않은 상태에 머무를 수 있음 Setup Time: 클록 엣지 이전 일정 시간 동안 D 입력이 안정적으로 유지되어야 함 Hold Time: 클록 엣지 이후 일정 시간 동안도 D 입력이 유지되어야 함 Metastability 방지 방법 – 동기화 회로 (Synchronizer) 외부 신호(비동기 입력 등)는 클록 도메인에 따라 metastable 위험이 있음 D Flip-Flop을 2개 이상 직렬로 연결 첫 번째 F/F는 신호를 잠시 받아들이고 두 번째 F/F는 클록에 동기화된 안정된 출력을 생성 Glitch (순간 출력 오류) 조합 회로에서 입력이 동시에 변할 때, 내부 게이트의 전파 지연 차이로 인해 일시적인 잘못된 출력이 발생할 수 있음 클록 엣지 직전까지 출력이 안정되지 않으면 시스템 오동작 가능성 존재 Propagation Delay (전파 지연) 입력 변화 이후 출력이 안정될 때까지의 시간 지연 조합 회로가 복잡하거나 깊이가 깊을수록 지연 시간이 길어짐 예: FFT filter 설계 시 곱셈 연산은 시간이 오래 걸리므로, 중간에 레지스터를 삽입하여 처리 Pipeline 처리 연산 중간에 레지스터를 추가하여 연산 단계를 여러 클록 사이클로 분할 조합 논리의 길이를 줄여 glitch를 방지할 수 있음 복잡한 연산을 분할 처리해 클록 타이밍 여유 확보 가능 한 클럭 내에 연산이 끝나도록 회로를 구성하면 안정적인 시스템 설계 가능 Button_Detector Design < Block Diagram > < Code : button_detector > `timescale 1ns / 1ps module button_detector ( input logic clk, input logic reset, input logic i_btn, output logic rising_edge, output logic falling_edge, output logic both_edge ); logic clk_1khz; logic debounce; logic [ 7:0] shift_reg; logic [$clog2(100_000)-1:0] div_counter; // create 1kHz pulse (for button sampling) always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; clk_1khz <= 1'b0; end else begin if (div_counter == 100_000 - 1) begin div_counter <= 0; clk_1khz <= 1'b1; end else begin div_counter <= div_counter + 1; clk_1khz <= 1'b0; end end end shift_register U_SHIFT_REG ( .clk (clk_1khz), .reset (reset), .i_data(i_btn), .o_data(shift_reg) ); assign debounce = &shift_reg; // assign o_btn = debounce; logic [1:0] edge_reg; // edge detector (rising/falling/both) always_ff @(posedge clk, posedge reset) begin if (reset) begin edge_reg <= 0; end else begin edge_reg[0] <= debounce; edge_reg[1] <= edge_reg[0]; end end assign rising_edge = edge_reg[0] & ~edge_reg[1]; assign falling_edge = ~edge_reg[0] & edge_reg[1]; assign both_edge = rising_edge | falling_edge; endmodule module shift_register ( input logic clk, input logic reset, input logic i_data, output logic [7:0] o_data ); always_ff @(posedge clk, posedge reset) begin if (reset) begin o_data <= 0; end else begin o_data <= {i_data, o_data[7:1]}; // right shift //o_data <= {o_data[6:0], i_data};// left shift end end endmodule < Comment > shift_register 시프트 레지스터의 기본 형태를 구현한 예시로, 구조와 동작 원리를 익혀두면 좋다. Right shift : 새로운 입력(i_data)이 MSB 위치로 들어가고, 기존 데이터는 오른쪽(LSB 방향)으로 한 비트씩 이동한다. Left shift : 새로운 입력(i_data)이 LSB 위치로 들어가고, 기존 데이터는 왼쪽(MSB 방향)으로 한 비트씩 이동한다. edge detector edge_reg를 통해 현재 debounce와 직전 상태를 저장. rising_edge : 0→1 변화를 검출. falling_edge : 1→0 변화를 검출. both_edge : 상승 또는 하강 변화를 모두 검출. < Code : UpDownCounter > `timescale 1ns / 1ps module UpDownCounter ( input logic clk, input logic reset, input logic button, output logic [13:0] count ); logic tick_10hz; logic mode; clk_div_10hz U_CLK_DIV_10hz ( .clk (clk), .reset (reset), .tick_10hz(tick_10hz) ); up_down_counter U_UP_DOWN_COUNTER ( .clk (clk), .reset(reset), .tick (tick_10hz), .mode (mode), .count(count) ); control_unit U_CU ( .clk(clk), .reset(reset), .button(button), .mode(mode) ); endmodule module up_down_counter ( input logic clk, input logic reset, input logic tick, input logic mode, output logic [13:0] count ); always_ff @(posedge clk, posedge reset) begin if (reset) begin count <= 0; end else begin if (mode == 1'b0) begin // up counter if (tick) begin if (count == 9999) begin count <= 0; end else begin count <= count + 1; end end end else begin // down counter if (tick) begin if (count == 0) begin count <= 9999; end else begin count <= count - 1; end end end end end endmodule module clk_div_10hz ( input logic clk, input logic reset, output logic tick_10hz ); //logic [23:0] div_counter; logic [$clog2(10_000_000)-1:0] div_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; tick_10hz <= 1'b0; end else begin if (div_counter == 10_000_000 - 1) begin div_counter <= 0; tick_10hz <= 1'b1; end else begin div_counter <= div_counter + 1; tick_10hz <= 1'b0; end end end endmodule module control_unit ( input logic clk, input logic reset, input logic button, output logic mode ); typedef enum { UP, DOWN } state_e; state_e state, next_state; // transition logic always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= UP; end else begin state <= next_state; end end // output logic always_comb begin next_state = state; case (state) UP: begin mode = 0; if (button) begin next_state = DOWN; end end DOWN: begin mode = 1; if (button) begin next_state = UP; end end endcase end endmodule < Comment > control_unit 버튼 입력에 따라 UP, DOWN 상태를 전환하는 FSM을 구현 typedef enum을 사용하여 상태 이름(UP, DOWN)을 열거형으로 선언 < Schematic > < 파일 > sources (Class) top_UpDownCounter.sv button_detector.sv UpDownCounter.sv fndController.sv constrs (Class) Basys-3-Master.xdc Homework < Design Specification > button 3개 사용 : run_stop 버튼, clear 버튼, mode 버튼 mode = 0 : up counting / mode = 1 : down counting up counter : led[0] on down counter : led[1] on stop : led[2] on run : led[3] on < FSM > < Code : UpDownCounter > //... module up_down_counter ( input logic clk, input logic reset, input logic tick, input logic mode, input logic clear, output logic toggle_state, output logic [13:0] count ); always_ff @(posedge clk or posedge reset) begin if (reset) begin toggle_state <= 0; end else begin if (mode) begin toggle_state <= ~toggle_state; end end end always_ff @(posedge clk, posedge reset) begin if (reset | clear) begin count <= 0; end else begin if (toggle_state == 1'b0) begin // up counter if (tick) begin if (count == 9999) begin count <= 0; end else begin count <= count + 1; end end end else begin // down counter if (tick) begin if (count == 0) begin count <= 9999; end else begin count <= count - 1; end end end end end endmodule module cu ( input logic clk, input logic reset, input logic btn_L, input logic btn_R, output logic runstop, output logic clear ); typedef enum { STOP, RUN, CLEAR } state_e; state_e state, next_state; always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= STOP; end else begin state <= next_state; end end always_comb begin next_state = state; runstop = 0; clear = 0; case (state) STOP: begin runstop = 0; clear = 0; if (btn_L) begin next_state = CLEAR; end else if (btn_R) begin next_state = RUN; end end CLEAR: begin clear = 1; if (btn_L) begin next_state = STOP; end end RUN: begin runstop = 1; if (btn_R) begin next_state = STOP; end end endcase end endmodule module state_led ( input logic runstop, input logic clear, input logic mode, output logic [3:0] led ); // (condition) ? true : false assign led[1:0] = mode ? 2'b10 : 2'b01; assign led[3:2] = runstop ? 2'b10 : 2'b01; endmodule < Schematic > < Video > < 고찰 > led 변수명을 led_mode, led_runstop처럼 의미를 명확히 알 수 있도록 개선해야 함 기능별로 분리하여 코드의 확장성을 확보할 필요가 있음 하나의 control_unit에서 상태를 구분하는 제어 신호들을 받아, 여러 개의 FSM을 동시에 처리하는 구조를 고려함. (mode FSM은 기존대로 유지) < 파일 > sources (Homework) top_UpDownCounter.sv button_debounce.sv UpDownCounter.sv fndController.sv constrs (Homework) Basys-3-Master.xdc
Final · 2025-08-07
2025-08-06
Review : Counter Design < Design Specification > up/down counter 설계 mode 0 : up counter mode 1 : down counter 0.1초 간격으로 counting 동작 FND에 숫자값 출력 (0000~9999) 전원이 인가되면 mode에 맞게 counting 동작 < Block Design > < Code : UpDownCounter > `timescale 1ns / 1ps module UpDownCounter ( input logic clk, input logic reset, input logic sw_mode, output logic [13:0] count ); logic tick_10hz; clk_div_10hz U_CLK_DIV_10hz ( .clk (clk), .reset (reset), .tick_10hz(tick_10hz) ); up_down_counter U_UP_DOWN_COUNTER ( .clk (clk), .reset(reset), .tick (tick_10hz), .mode (sw_mode), .count(count) ); endmodule module clk_div_10hz ( input logic clk, input logic reset, output logic tick_10hz ); //logic [23:0] div_counter; logic [$clog2(10_000_000)-1:0] div_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; tick_10hz <= 1'b0; end else begin if (div_counter == 10_000_000 - 1) begin div_counter <= 0; tick_10hz <= 1'b1; end else begin div_counter <= div_counter + 1; tick_10hz <= 1'b0; end end end endmodule module up_down_counter ( input logic clk, input logic reset, input logic tick, input logic mode, output logic [13:0] count ); always_ff @(posedge clk, posedge reset) begin if (reset) begin count <= 0; end else begin if (mode == 1'b0) begin // up counter if (tick) begin if (count == 9999) begin count <= 0; end else begin count <= count + 1; end end end else begin // down counter if (tick) begin if (count == 0) begin count <= 9999; end else begin count <= count - 1; end end end end end endmodule < Comment > clk_div_10hz system clock = 100_000_000Hz = 100MHz (1초에 1억 싸이클) clk_div_10hz → 10_000_000 싸이클마다 tick_10hz를 1로 출력 (0.1초 주기) 즉, tick_10hz는 10Hz로 동작 (1초에 10번 펄스 발생) up_down_counter 초기에 up_counter와 down_counter를 각각 따로 설계하고 top 모듈에서 sw를 통해 출력만 선택(MUX)하려 했으나, 이 경우 mode 전환 시 현재 카운터 값이 아닌 선택된 다른 카운터의 이전 값이 갑자기 출력될 우려가 있었다. → 결과적으로 출력 값이 불연속적으로 변할 수 있음 따라서 하나의 순차회로(counter)에서 mode를 입력으로 받아, 동일한 레지스터(count)에 대해 up/down 제어를 하는 방식이 연속적인 동작을 보장하고 설계 목표에도 더 적합하다고 판단했다. < Code : FndController > `timescale 1ns / 1ps module FndController ( input logic clk, input logic reset, input logic [13:0] number, output logic [ 3:0] fndCom, output logic [ 7:0] fndFont ); logic tick_1khz; logic [1:0] count; logic [3:0] digit_1, digit_10, digit_100, digit_1000, digit; clk_div_1khz U_CLK_DIV_1KHZ ( .clk (clk), .reset (reset), .tick_1khz(tick_1khz) ); counter_2bit U_COUNTER_2BIT ( .clk (clk), .reset(reset), .tick (tick_1khz), .count(count) ); decoder_2x4 U_DECODER_2X4 ( .x(count), .y(fndCom) ); digitSplitter U_DIGITSPLITTER ( .number (number), .digit_1 (digit_1), .digit_10 (digit_10), .digit_100 (digit_100), .digit_1000(digit_1000) ); mux_4x1 U_MUX_4X1 ( .sel(count), .x0 (digit_1), .x1 (digit_10), .x2 (digit_100), .x3 (digit_1000), .y (digit) ); BCDtoFND_Decoder U_BCDTOFND_DECODER ( .bcd(digit), .fnd(fndFont) ); endmodule module clk_div_1khz ( input logic clk, input logic reset, output logic tick_1khz ); logic [$clog2(100_000):0] div_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; tick_1khz <= 0; end else begin if (div_counter == 100_000 - 1) begin div_counter <= 0; tick_1khz <= 1; end else begin div_counter <= div_counter + 1; tick_1khz <= 0; end end end endmodule module counter_2bit ( input logic clk, input logic reset, input logic tick, output logic [1:0] count ); always_ff @(posedge clk, posedge reset) begin if (reset) begin count <= 0; end else begin if (tick) begin count <= count + 1; end end end endmodule module decoder_2x4 ( input logic [1:0] x, output logic [3:0] y ); always_comb begin case (x) 2'b00: y = 4'b1110; 2'b01: y = 4'b1101; 2'b10: y = 4'b1011; 2'b11: y = 4'b0111; endcase end endmodule module digitSplitter ( input logic [13:0] number, output logic [ 3:0] digit_1, output logic [ 3:0] digit_10, output logic [ 3:0] digit_100, output logic [ 3:0] digit_1000 ); assign digit_1 = number % 10; assign digit_10 = number / 10 % 10; assign digit_100 = number / 100 % 10; assign digit_1000 = number / 1000 % 10; endmodule module mux_4x1 ( input logic [1:0] sel, input logic [3:0] x0, input logic [3:0] x1, input logic [3:0] x2, input logic [3:0] x3, output logic [3:0] y ); always_comb begin y = 4'b0000; case (sel) 2'b00: y = x0; 2'b01: y = x1; 2'b10: y = x2; 2'b11: y = x3; endcase end endmodule module BCDtoFND_Decoder ( input logic [3:0] bcd, output logic [7:0] fnd ); always_comb begin case (bcd) 4'h0: fnd = 8'hc0; 4'h1: fnd = 8'hf9; 4'h2: fnd = 8'ha4; 4'h3: fnd = 8'hb0; 4'h4: fnd = 8'h99; 4'h5: fnd = 8'h92; 4'h6: fnd = 8'h82; 4'h7: fnd = 8'hf8; 4'h8: fnd = 8'h80; 4'h9: fnd = 8'h90; 4'ha: fnd = 8'h88; 4'hb: fnd = 8'h83; 4'hc: fnd = 8'hc6; 4'hd: fnd = 8'ha1; 4'he: fnd = 8'h86; 4'hf: fnd = 8'h8e; default: fnd = 8'hff; endcase end endmodule < Comment > clk_div_1khz 1ms 마다 tick_1khz를 생성 counter_2bit tick 받을 때마다 count 0→1→2→3 순환 decoder_2x4 count에 따라 FND의 자릿수 선택 (fndCom 출력) digitSplitter 14비트 입력 숫자를 천/백/십/일의 4자리로 분할 mux_4x1 count 자리에 해당하는 자릿수 값을 선택 BCDtoFND_Decoder 자릿수 값을 FND 디코딩 (fndFont 출력) < Code : top_UpDownCounter > `timescale 1ns / 1ps module top_UpDownCounter ( input logic clk, input logic reset, input logic sw_mode, output logic [3:0] fndCom, output logic [7:0] fndFont ); logic [13:0] count; UpDownCounter U_UPDOWNCOUNTER ( .clk (clk), .reset (reset), .sw_mode(sw_mode), .count (count) ); FndController U_FNDCONTROLLER ( .clk (clk), .reset (reset), .number (count), .fndCom (fndCom), .fndFont(fndFont) ); endmodule < Schematic > < 파일 > sources (Class) top_UpDownCounter.sv UpDownCounter.sv FndController.sv constrs (Class) Basys-3-Master.xdc Homework < Design Specification > mode 버튼을 눌렀다 뗐을 때 up_counter → down_counter mode 버튼을 눌렀다 뗐을 때 down_counter → up_counter mode 버튼 1개로 counter 동작 toggle < 구상 > 기존 스위치 입력을 버튼 입력으로 대체하고자 했으며, 버튼 특성상 노이즈가 발생하므로 디바운싱 처리가 필요하다고 판단했다. 특히, 버튼을 눌렀다 떼는 순간(falling edge)에만 동작이 발생해야 하므로, 엣지 검출 기반 동작 설계가 이번 구현의 핵심이 되었다. < Code : btn_debounce > `timescale 1ns / 1ps module btn_debounce ( input logic clk, input logic rst, input logic i_btn, output logic o_btn ); parameter F_COUNT = 10_000; logic [$clog2(F_COUNT)-1:0] r_counter; logic r_clk; logic [7:0] q_reg, q_next; logic w_debounce; // 10,000Hz clock divider (0.1ms) always_ff @(posedge clk, posedge rst) begin if (rst) begin r_counter <= 0; r_clk <= 0; end else begin if (r_counter == (F_COUNT - 1)) begin r_counter <= 0; r_clk <= 1'b1; end else begin r_counter <= r_counter + 1; r_clk <= 1'b0; end end end // shift register always_comb begin q_next = {i_btn, q_reg[7:1]}; end always_ff @(posedge r_clk, posedge rst) begin if (rst) begin q_reg <= 0; end else begin q_reg <= q_next; end end // 8 input and gate assign w_debounce = &q_reg; logic r_edge_q; // edge detector always_ff @(posedge clk, posedge rst) begin if (rst) begin r_edge_q <= 0; end else begin r_edge_q <= w_debounce; end end // rising edge // assign o_btn = (~r_edge_q) & w_debounce; // falling edge assign o_btn = r_edge_q & ~w_debounce; endmodule < Comment > 10,000Hz clock divider 0.1ms 마다 tick_1khz를 생성 shift register 0.1ms마다 버튼 입력 i_btn을 가장 상위 비트에 넣고, 기존 값은 한 칸씩 오른쪽으로 밀어 저장 → 최근 0.8ms 간의 입력 이력을 저장 8 input and gate 8비트 shift register의 모든 비트가 1일 때만 w_debounce = 1 → 버튼이 0.8ms 이상 안정적으로 눌렸는지를 판별 edge detector w_debounce의 상태를 한 클럭 지연시킨 r_edge_q와 비교 → 현재 상태와 이전 상태의 차이를 기반으로 버튼 변화 시점을 감지 falling edge r_edge_q = 1, w_debounce = 0인 경우에만 o_btn = 1 → 버튼이 떼어지는 순간(falling edge)만 한 클럭 동안 출력 < Code : UpDownCounter (up_down_counter) > // ... logic toggle_state; always_ff @(posedge clk or posedge reset) begin if (reset) begin toggle_state <= 0; end else begin if (mode) begin toggle_state <= ~toggle_state; end end end //... // counter 변환 조건 변경 : mode → toggle_state < Schematic > < Video > < 고찰 > 단순히 일정 시간 동안 버튼이 눌렸는지를 판단하는 방식이 아닌, 현재 상태와 이전 상태의 차이를 기반으로 버튼이 눌리는 순간과 떼어지는 순간을 감지하는 엣지 검출(edge detection) 방식이 새로웠다. 또한, shift register를 활용해 버튼 입력의 이력을 저장함으로써 노이즈에 강한 안정적인 디바운싱 로직을 구현할 수 있다는 점이 인상 깊었다. < 파일 > sources (Homework) top_UpDownCounter.sv button_debounce.sv UpDownCounter.sv fndController.sv constrs (Homework) Basys-3-Master.xdc
Final · 2025-08-06

Touch background to close