카테고리 보관물: 하드웨어 이론

STM32-H755ZI-Q 개발 보드에서 이더넷으로 DHCP 연결 수립후 IP 받아오는 설정

STM32-H755ZI-Q 개발 보드는 RJ45 커넥터와 LAN8742 PHY를 내장으로 지원합니다.

주요 사양은

• 데이터 레이트: 10/100Mbps
• 표준안: IEEE 802.3/802.3u (10BASE-T, 100BASE-TX)
• 인터페이스: RMII
• 전압: 1.6V ~ 3.3V (LVCMOS I/O) 1.2V 레귤레이터 통합
• 50MHz 클럭 소스

구요. 라우터가 왠만하면 요즘 나오는 제품은 지원을 합니다. (물론 10BASE-T와 100BASE-TX는 아주 오래전 규격인데, MP3나 WAV 스트리밍도 되는 사양일 것입니다.)

우선 연결도는 아래와 같구요

STM32 보드 === lwIP (DHCP client) === 라우터 (DHCP server)

우리가 해야 하는 것은 ETH를 켜는 것과, lwIP 옵션 지정입니다.

STM32CubeMX에서 하면 간편한데, 너무 길어지니 대략적인 요약문부터 올립니다.

(1) STM32CubeMX > Connectivity > ETH 켬
(2) STM32CubeMX > Middleware and Software Pack > LWIP 켬
(3) ethernetif.c 수정보완

이 세가지 큰 흐름을 기반으로 세부를 설정해주면 됩니다.

우선 STM32CubeMX 설정 화면은 생략하고 이로부터 생성된 소스코드를 어떻게 고쳐야 하는지 보이겠습니다.

Project Root > CM7 > LWIP > App > lwip.c :

/* USER CODE BEGIN Header */
/**
 ******************************************************************************
  * File Name          : LWIP.c
  * Description        : This file provides initialization code for LWIP
  *                      middleWare.
  ******************************************************************************
  * @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 "lwip.h"
#include "lwip/init.h"
#include "lwip/netif.h"
#if defined ( __CC_ARM )  /* MDK ARM Compiler */
#include "lwip/sio.h"
#endif /* MDK ARM Compiler */
#include "ethernetif.h"

/* USER CODE BEGIN 0 */

/* USER CODE END 0 */
/* Private function prototypes -----------------------------------------------*/
static void ethernet_link_status_updated(struct netif *netif);
static void Ethernet_Link_Periodic_Handle(struct netif *netif);
/* ETH Variables initialization ----------------------------------------------*/
void Error_Handler(void);

/* DHCP Variables initialization ---------------------------------------------*/
uint32_t DHCPfineTimer = 0;
uint32_t DHCPcoarseTimer = 0;
/* USER CODE BEGIN 1 */

/* USER CODE END 1 */
uint32_t EthernetLinkTimer;

/* Variables Initialization */
struct netif gnetif;
ip4_addr_t ipaddr;
ip4_addr_t netmask;
ip4_addr_t gw;

/* USER CODE BEGIN 2 */

/* USER CODE END 2 */

/**
  * LwIP initialization function
  */
void MX_LWIP_Init(void)
{
  /* Initialize the LwIP stack without RTOS */
  lwip_init();

  /* IP addresses initialization with DHCP (IPv4) */
  ipaddr.addr = 0;
  netmask.addr = 0;
  gw.addr = 0;

  /* add the network interface (IPv4/IPv6) without RTOS */
  netif_add(&gnetif, &ipaddr, &netmask, &gw, NULL, &ethernetif_init, &ethernet_input);

  /* Registers the default network interface */
  netif_set_default(&gnetif);

  /* We must always bring the network interface up connection or not... */
  netif_set_up(&gnetif);

  /* Set the link callback function, this function is called on change of link status*/
  netif_set_link_callback(&gnetif, ethernet_link_status_updated);

  /* Start DHCP negotiation for a network interface (IPv4) */
  //dhcp_start(&gnetif);

/* USER CODE BEGIN 3 */

/* USER CODE END 3 */
}

#ifdef USE_OBSOLETE_USER_CODE_SECTION_4
/* Kept to help code migration. (See new 4_1, 4_2... sections) */
/* Avoid to use this user section which will become obsolete. */
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
#endif

/**
  * @brief  Ethernet Link periodic check
  * @param  netif
  * @retval None
  */
static void Ethernet_Link_Periodic_Handle(struct netif *netif)
{
/* USER CODE BEGIN 4_4_1 */
/* USER CODE END 4_4_1 */

  /* Ethernet Link every 100ms */
  if (HAL_GetTick() - EthernetLinkTimer >= 100)
  {
    EthernetLinkTimer = HAL_GetTick();
    ethernet_link_check_state(netif);
  }
/* USER CODE BEGIN 4_4 */
/* USER CODE END 4_4 */
}

/**
 * ----------------------------------------------------------------------
 * Function given to help user to continue LwIP Initialization
 * Up to user to complete or change this function ...
 * Up to user to call this function in main.c in while (1) of main(void)
 *-----------------------------------------------------------------------
 * Read a received packet from the Ethernet buffers
 * Send it to the lwIP stack for handling
 * Handle timeouts if LWIP_TIMERS is set and without RTOS
 * Handle the llink status if LWIP_NETIF_LINK_CALLBACK is set and without RTOS
 */
void MX_LWIP_Process(void)
{
/* USER CODE BEGIN 4_1 */
/* USER CODE END 4_1 */
  ethernetif_input(&gnetif);

/* USER CODE BEGIN 4_2 */
/* USER CODE END 4_2 */
  /* Handle timeouts */
  sys_check_timeouts();

  Ethernet_Link_Periodic_Handle(&gnetif);

/* USER CODE BEGIN 4_3 */
/* USER CODE END 4_3 */
}

/**
  * @brief  Notify the User about the network interface config status
  * @param  netif: the network interface
  * @retval None
  */
static void ethernet_link_status_updated(struct netif *netif)
{
  if (netif_is_up(netif))
  {
/* USER CODE BEGIN 5 */
/* USER CODE END 5 */
  }
  else /* netif is down */
  {
/* USER CODE BEGIN 6 */
/* USER CODE END 6 */
  }
}

#if defined ( __CC_ARM )  /* MDK ARM Compiler */
/**
 * Opens a serial device for communication.
 *
 * @param devnum device number
 * @return handle to serial device if successful, NULL otherwise
 */
sio_fd_t sio_open(u8_t devnum)
{
  sio_fd_t sd;

/* USER CODE BEGIN 7 */
  sd = 0; // dummy code
/* USER CODE END 7 */

  return sd;
}

/**
 * Sends a single character to the serial device.
 *
 * @param c character to send
 * @param fd serial device handle
 *
 * @note This function will block until the character can be sent.
 */
void sio_send(u8_t c, sio_fd_t fd)
{
/* USER CODE BEGIN 8 */
/* USER CODE END 8 */
}

/**
 * Reads from the serial device.
 *
 * @param fd serial device handle
 * @param data pointer to data buffer for receiving
 * @param len maximum length (in bytes) of data to receive
 * @return number of bytes actually received - may be 0 if aborted by sio_read_abort
 *
 * @note This function will block until data can be received. The blocking
 * can be cancelled by calling sio_read_abort().
 */
u32_t sio_read(sio_fd_t fd, u8_t *data, u32_t len)
{
  u32_t recved_bytes;

/* USER CODE BEGIN 9 */
  recved_bytes = 0; // dummy code
/* USER CODE END 9 */
  return recved_bytes;
}

/**
 * Tries to read from the serial device. Same as sio_read but returns
 * immediately if no data is available and never blocks.
 *
 * @param fd serial device handle
 * @param data pointer to data buffer for receiving
 * @param len maximum length (in bytes) of data to receive
 * @return number of bytes actually received
 */
u32_t sio_tryread(sio_fd_t fd, u8_t *data, u32_t len)
{
  u32_t recved_bytes;

/* USER CODE BEGIN 10 */
  recved_bytes = 0; // dummy code
/* USER CODE END 10 */
  return recved_bytes;
}
#endif /* MDK ARM Compiler */

Project Root > CM7 > LWIP > Target > ethernetif.c :

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * File Name          : ethernetif.c
  * Description        : This file provides code for the configuration
  *                      of the ethernetif.c MiddleWare.
  ******************************************************************************
  * @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"
#include "lwip/opt.h"
#include "lwip/mem.h"
#include "lwip/memp.h"
#include "lwip/timeouts.h"
#include "netif/ethernet.h"
#include "netif/etharp.h"
#include "lwip/ethip6.h"
#include "ethernetif.h"
#include "lan8742.h"
#include <string.h>

/* Within 'USER CODE' section, code will be kept by default at each generation */
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/* Private define ------------------------------------------------------------*/

/* Network interface name */
#define IFNAME0 's'
#define IFNAME1 't'

/* ETH Setting  */
#define ETH_DMA_TRANSMIT_TIMEOUT               ( 20U )
#define ETH_TX_BUFFER_MAX             ((ETH_TX_DESC_CNT) * 2U)
/* ETH_RX_BUFFER_SIZE parameter is defined in lwipopts.h */

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/* Private variables ---------------------------------------------------------*/
/*
@Note: This interface is implemented to operate in zero-copy mode only:
        - Rx Buffers will be allocated from LwIP stack Rx memory pool,
          then passed to ETH HAL driver.
        - Tx Buffers will be allocated from LwIP stack memory heap,
          then passed to ETH HAL driver.

@Notes:
  1.a. ETH DMA Rx descriptors must be contiguous, the default count is 4,
       to customize it please redefine ETH_RX_DESC_CNT in ETH GUI (Rx Descriptor Length)
       so that updated value will be generated in stm32xxxx_hal_conf.h
  1.b. ETH DMA Tx descriptors must be contiguous, the default count is 4,
       to customize it please redefine ETH_TX_DESC_CNT in ETH GUI (Tx Descriptor Length)
       so that updated value will be generated in stm32xxxx_hal_conf.h

  2.a. Rx Buffers number must be between ETH_RX_DESC_CNT and 2*ETH_RX_DESC_CNT
  2.b. Rx Buffers must have the same size: ETH_RX_BUFFER_SIZE, this value must
       passed to ETH DMA in the init field (heth.Init.RxBuffLen)
  2.c  The RX Ruffers addresses and sizes must be properly defined to be aligned
       to L1-CACHE line size (32 bytes).
*/

/* Data Type Definitions */
typedef enum
{
  RX_ALLOC_OK       = 0x00,
  RX_ALLOC_ERROR    = 0x01
} RxAllocStatusTypeDef;

typedef struct
{
  struct pbuf_custom pbuf_custom;
  uint8_t buff[(ETH_RX_BUFFER_SIZE + 31) & ~31] __ALIGNED(32);
} RxBuff_t;

/* Memory Pool Declaration */
#define ETH_RX_BUFFER_CNT             12U
__attribute__((section(".Rx_PoolSection"))) LWIP_MEMPOOL_DECLARE(RX_POOL, ETH_RX_BUFFER_CNT, sizeof(RxBuff_t), "Zero-copy RX PBUF pool");

/* Variable Definitions */
static uint8_t RxAllocStatus;
#if defined ( __ICCARM__ ) /*!< IAR Compiler */

#pragma location=0x30000000
ETH_DMADescTypeDef  DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */
#pragma location=0x30000080
ETH_DMADescTypeDef  DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */

#elif defined ( __CC_ARM )  /* MDK ARM Compiler */

__attribute__((at(0x30000000))) ETH_DMADescTypeDef  DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */
__attribute__((at(0x30000080))) ETH_DMADescTypeDef  DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */

#elif defined ( __GNUC__ ) /* GNU Compiler */

ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT] __attribute__((section(".RxDecripSection"))); /* Ethernet Rx DMA Descriptors */
ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT] __attribute__((section(".TxDecripSection")));   /* Ethernet Tx DMA Descriptors */

#endif

#if defined ( __ICCARM__ ) /*!< IAR Compiler */
#pragma location = 0x30000100
extern u8_t memp_memory_RX_POOL_base[];

#elif defined ( __CC_ARM ) /* MDK ARM Compiler */
__attribute__((section(".Rx_PoolSection"))) extern u8_t memp_memory_RX_POOL_base[];

#elif defined ( __GNUC__ ) /* GNU */
__attribute__((section(".Rx_PoolSection"))) extern u8_t memp_memory_RX_POOL_base[];
#endif

/* USER CODE BEGIN 2 */

/* USER CODE END 2 */

/* Global Ethernet handle */
ETH_HandleTypeDef heth;

ETH_TxPacketConfig TxConfig;

/* Private function prototypes -----------------------------------------------*/
int32_t ETH_PHY_IO_Init(void);
int32_t ETH_PHY_IO_DeInit (void);
int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t *pRegVal);
int32_t ETH_PHY_IO_WriteReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t RegVal);
int32_t ETH_PHY_IO_GetTick(void);

lan8742_Object_t LAN8742;
lan8742_IOCtx_t  LAN8742_IOCtx = {ETH_PHY_IO_Init,
                                  ETH_PHY_IO_DeInit,
                                  ETH_PHY_IO_WriteReg,
                                  ETH_PHY_IO_ReadReg,
                                  ETH_PHY_IO_GetTick};

/* USER CODE BEGIN 3 */

/* USER CODE END 3 */

/* Private functions ---------------------------------------------------------*/
void pbuf_free_custom(struct pbuf *p);

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/*******************************************************************************
                       LL Driver Interface ( LwIP stack --> ETH)
*******************************************************************************/
/**
 * @brief In this function, the hardware should be initialized.
 * Called from ethernetif_init().
 *
 * @param netif the already initialized lwip network interface structure
 * for this ethernetif
 */
static void low_level_init(struct netif *netif)
{
  HAL_StatusTypeDef hal_eth_init_status = HAL_OK;

  /* [중요 수정 1] MAC 주소 변수를 static으로 선언하여 메모리에서 사라지지 않게 함 */
  static uint8_t MACAddr[6];

  /* [중요 수정 2] 하드웨어 초기화 전에 반드시 메모리 풀(RX_POOL)을 먼저 초기화해야 합니다. */
  /* 이 줄이 HAL_ETH_Init보다 밑에 있으면 수신 기능이 고장 납니다. */
  LWIP_MEMPOOL_INIT(RX_POOL);

  /* 디스크립터 메모리 초기화 (안전장치) */
  memset(DMARxDscrTab, 0, sizeof(ETH_DMADescTypeDef) * ETH_RX_DESC_CNT);
  memset(DMATxDscrTab, 0, sizeof(ETH_DMADescTypeDef) * ETH_TX_DESC_CNT);

  heth.Instance = ETH;
  MACAddr[0] = 0x00;
  MACAddr[1] = 0x80;
  MACAddr[2] = 0xE1;
  MACAddr[3] = 0x00;
  MACAddr[4] = 0x00;
  MACAddr[5] = 0x00;
  heth.Init.MACAddr = &MACAddr[0];
  heth.Init.MediaInterface = HAL_ETH_RMII_MODE;
  heth.Init.TxDesc = DMATxDscrTab;
  heth.Init.RxDesc = DMARxDscrTab;

  /* [중요 수정 3] 버퍼 크기를 1536 대신 실제 정의된 매크로로 맞춤 */
  heth.Init.RxBuffLen = ETH_RX_BUFFER_SIZE;

  /* USER CODE BEGIN MACADDRESS */
  HAL_Delay(100);
  /* USER CODE END MACADDRESS */

  hal_eth_init_status = HAL_ETH_Init(&heth);

  /* [중요 수정 4] 하드웨어 체크섬 끄기 (소프트웨어 체크섬 사용) */
  memset(&TxConfig, 0 , sizeof(ETH_TxPacketConfig));
  TxConfig.Attributes = ETH_TX_PACKETS_FEATURES_CRCPAD;
  TxConfig.ChecksumCtrl = ETH_CHECKSUM_DISABLE; // LwIP가 계산하도록 설정
  TxConfig.CRCPadCtrl = ETH_CRC_PAD_INSERT;

  /* End ETH HAL Init */

  /* LWIP_MEMPOOL_INIT(RX_POOL); <--- 원래 여기 있던 코드를 위로 올렸습니다. */

#if LWIP_ARP || LWIP_ETHERNET
  /* set MAC hardware address length */
  netif->hwaddr_len = ETH_HWADDR_LEN;

  /* set MAC hardware address */
  netif->hwaddr[0] =  heth.Init.MACAddr[0];
  netif->hwaddr[1] =  heth.Init.MACAddr[1];
  netif->hwaddr[2] =  heth.Init.MACAddr[2];
  netif->hwaddr[3] =  heth.Init.MACAddr[3];
  netif->hwaddr[4] =  heth.Init.MACAddr[4];
  netif->hwaddr[5] =  heth.Init.MACAddr[5];

  /* maximum transfer unit */
  netif->mtu = ETH_MAX_PAYLOAD;

  /* Accept broadcast address and ARP traffic */
#if LWIP_ARP
    netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;
#else
    netif->flags |= NETIF_FLAG_BROADCAST;
#endif /* LWIP_ARP */

/* USER CODE BEGIN PHY_PRE_CONFIG */
/* USER CODE END PHY_PRE_CONFIG */

  /* Set PHY IO functions */
  LAN8742_RegisterBusIO(&LAN8742, &LAN8742_IOCtx);

  /* Initialize the LAN8742 ETH PHY */
  if(LAN8742_Init(&LAN8742) != LAN8742_STATUS_OK)
  {
    netif_set_link_down(netif);
    netif_set_down(netif);
    return;
  }

  if (hal_eth_init_status == HAL_OK)
  {
    /* Get link state */
    ethernet_link_check_state(netif);
  }
  else
  {
    Error_Handler();
  }
#endif /* LWIP_ARP || LWIP_ETHERNET */
}

/**
 * @brief This function should do the actual transmission of the packet. The packet is
 * contained in the pbuf that is passed to the function. This pbuf
 * might be chained.
 *
 * @param netif the lwip network interface structure for this ethernetif
 * @param p the MAC packet to send (e.g. IP packet including MAC addresses and type)
 * @return ERR_OK if the packet could be sent
 *         an err_t value if the packet couldn't be sent
 *
 * @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to
 *       strange results. You might consider waiting for space in the DMA queue
 *       to become available since the stack doesn't retry to send a packet
 *       dropped because of memory failure (except for the TCP timers).
 */

/* ethernetif.c 파일 내부 */

static err_t low_level_output(struct netif *netif, struct pbuf *p)
{
  uint32_t i = 0U;
  struct pbuf *q = NULL;
  err_t errval = ERR_OK;
  ETH_BufferTypeDef Txbuffer[ETH_TX_DESC_CNT] = {0};

  memset(Txbuffer, 0 , ETH_TX_DESC_CNT*sizeof(ETH_BufferTypeDef));

  for(q = p; q != NULL; q = q->next)
  {
    if(i >= ETH_TX_DESC_CNT)
      return ERR_IF;

    Txbuffer[i].buffer = q->payload;
    Txbuffer[i].len = q->len;

    /* ========================================================== */
    /* [핵심 수정] TX 패킷을 DMA가 가져가기 전에 캐시를 RAM으로 밀어넣습니다. */
    /* 이 코드가 없으면 공유기는 깨진 패킷을 받고 무시합니다. */
    /* ========================================================== */
    SCB_CleanDCache_by_Addr((uint32_t *)q->payload, q->len);
    /* ========================================================== */

    if(i>0)
    {
      Txbuffer[i-1].next = &Txbuffer[i];
    }

    if(q->next == NULL)
    {
      Txbuffer[i].next = NULL;
    }

    i++;
  }

  TxConfig.Length = p->tot_len;
  TxConfig.TxBuffer = Txbuffer;
  TxConfig.pData = p;

  /* 디버깅용 로그 */
  // printf("TX Packet: len=%d\r\n", p->tot_len);

  HAL_ETH_Transmit(&heth, &TxConfig, ETH_DMA_TRANSMIT_TIMEOUT);

  return errval;
}

/**
 * @brief Should allocate a pbuf and transfer the bytes of the incoming
 * packet from the interface into the pbuf.
 *
 * @param netif the lwip network interface structure for this ethernetif
 * @return a pbuf filled with the received packet (including MAC header)
 *         NULL on memory error
   */
static struct pbuf * low_level_input(struct netif *netif)
{
  struct pbuf *p = NULL;

  if(RxAllocStatus == RX_ALLOC_OK)
  {
    HAL_ETH_ReadData(&heth, (void **)&p);
  }

  return p;
}

/**
 * @brief This function should be called when a packet is ready to be read
 * from the interface. It uses the function low_level_input() that
 * should handle the actual reception of bytes from the network
 * interface. Then the type of the received packet is determined and
 * the appropriate input function is called.
 *
 * @param netif the lwip network interface structure for this ethernetif
 */
void ethernetif_input(struct netif *netif)
{
  struct pbuf *p = NULL;

  do
  {
    p = low_level_input( netif );
    if (p != NULL)
    {
      if (netif->input( p, netif) != ERR_OK )
      {
        pbuf_free(p);
      }
    }
  } while(p!=NULL);
}

#if !LWIP_ARP
/**
 * This function has to be completed by user in case of ARP OFF.
 *
 * @param netif the lwip network interface structure for this ethernetif
 * @return ERR_OK if ...
 */
static err_t low_level_output_arp_off(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr)
{
  err_t errval;
  errval = ERR_OK;

/* USER CODE BEGIN 5 */

/* USER CODE END 5 */

  return errval;

}
#endif /* LWIP_ARP */

/**
 * @brief Should be called at the beginning of the program to set up the
 * network interface. It calls the function low_level_init() to do the
 * actual setup of the hardware.
 *
 * This function should be passed as a parameter to netif_add().
 *
 * @param netif the lwip network interface structure for this ethernetif
 * @return ERR_OK if the loopif is initialized
 *         ERR_MEM if private data couldn't be allocated
 *         any other err_t on error
 */
err_t ethernetif_init(struct netif *netif)
{
  LWIP_ASSERT("netif != NULL", (netif != NULL));

#if LWIP_NETIF_HOSTNAME
  /* Initialize interface hostname */
  netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */

  /*
   * Initialize the snmp variables and counters inside the struct netif.
   * The last argument should be replaced with your link speed, in units
   * of bits per second.
   */
  // MIB2_INIT_NETIF(netif, snmp_ifType_ethernet_csmacd, LINK_SPEED_OF_YOUR_NETIF_IN_BPS);

  netif->name[0] = IFNAME0;
  netif->name[1] = IFNAME1;
  /* We directly use etharp_output() here to save a function call.
   * You can instead declare your own function an call etharp_output()
   * from it if you have to do some checks before sending (e.g. if link
   * is available...) */

#if LWIP_IPV4
#if LWIP_ARP || LWIP_ETHERNET
#if LWIP_ARP
  netif->output = etharp_output;
#else
  /* The user should write its own code in low_level_output_arp_off function */
  netif->output = low_level_output_arp_off;
#endif /* LWIP_ARP */
#endif /* LWIP_ARP || LWIP_ETHERNET */
#endif /* LWIP_IPV4 */

#if LWIP_IPV6
  netif->output_ip6 = ethip6_output;
#endif /* LWIP_IPV6 */

  netif->linkoutput = low_level_output;

  /* initialize the hardware */
  low_level_init(netif);

  return ERR_OK;
}

/**
  * @brief  Custom Rx pbuf free callback
  * @param  pbuf: pbuf to be freed
  * @retval None
  */
void pbuf_free_custom(struct pbuf *p)
{
  struct pbuf_custom* custom_pbuf = (struct pbuf_custom*)p;
  LWIP_MEMPOOL_FREE(RX_POOL, custom_pbuf);

  /* If the Rx Buffer Pool was exhausted, signal the ethernetif_input task to
   * call HAL_ETH_GetRxDataBuffer to rebuild the Rx descriptors. */

  if (RxAllocStatus == RX_ALLOC_ERROR)
  {
    RxAllocStatus = RX_ALLOC_OK;
  }
}

/* USER CODE BEGIN 6 */

/**
* @brief  Returns the current time in milliseconds
*         when LWIP_TIMERS == 1 and NO_SYS == 1
* @param  None
* @retval Current Time value
*/
u32_t sys_now(void)
{
  return HAL_GetTick();
}

/* USER CODE END 6 */

/**
  * @brief  Initializes the ETH MSP.
  * @param  ethHandle: ETH handle
  * @retval None
  */

void HAL_ETH_MspInit(ETH_HandleTypeDef* ethHandle)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(ethHandle->Instance==ETH)
  {
  /* USER CODE BEGIN ETH_MspInit 0 */

  /* USER CODE END ETH_MspInit 0 */
    /* Enable Peripheral clock */
    __HAL_RCC_ETH1MAC_CLK_ENABLE();
    __HAL_RCC_ETH1TX_CLK_ENABLE();
    __HAL_RCC_ETH1RX_CLK_ENABLE();

    __HAL_RCC_GPIOC_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    __HAL_RCC_GPIOG_CLK_ENABLE();
    /**ETH GPIO Configuration
    PC1     ------> ETH_MDC
    PA1     ------> ETH_REF_CLK
    PA2     ------> ETH_MDIO
    PA7     ------> ETH_CRS_DV
    PC4     ------> ETH_RXD0
    PC5     ------> ETH_RXD1
    PB13     ------> ETH_TXD1
    PG11     ------> ETH_TX_EN
    PG13     ------> ETH_TXD0
    */
    GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_4|GPIO_PIN_5;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_7;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_13;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_13;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
    HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);

    /* Peripheral interrupt init */
    HAL_NVIC_SetPriority(ETH_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(ETH_IRQn);
  /* USER CODE BEGIN ETH_MspInit 1 */

  /* USER CODE END ETH_MspInit 1 */
  }
}

void HAL_ETH_MspDeInit(ETH_HandleTypeDef* ethHandle)
{
  if(ethHandle->Instance==ETH)
  {
  /* USER CODE BEGIN ETH_MspDeInit 0 */

  /* USER CODE END ETH_MspDeInit 0 */
    /* Disable Peripheral clock */
    __HAL_RCC_ETH1MAC_CLK_DISABLE();
    __HAL_RCC_ETH1TX_CLK_DISABLE();
    __HAL_RCC_ETH1RX_CLK_DISABLE();

    /**ETH GPIO Configuration
    PC1     ------> ETH_MDC
    PA1     ------> ETH_REF_CLK
    PA2     ------> ETH_MDIO
    PA7     ------> ETH_CRS_DV
    PC4     ------> ETH_RXD0
    PC5     ------> ETH_RXD1
    PB13     ------> ETH_TXD1
    PG11     ------> ETH_TX_EN
    PG13     ------> ETH_TXD0
    */
    HAL_GPIO_DeInit(GPIOC, GPIO_PIN_1|GPIO_PIN_4|GPIO_PIN_5);

    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_7);

    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_13);

    HAL_GPIO_DeInit(GPIOG, GPIO_PIN_11|GPIO_PIN_13);

    /* Peripheral interrupt Deinit*/
    HAL_NVIC_DisableIRQ(ETH_IRQn);

  /* USER CODE BEGIN ETH_MspDeInit 1 */

  /* USER CODE END ETH_MspDeInit 1 */
  }
}

/*******************************************************************************
                       PHI IO Functions
*******************************************************************************/
/**
  * @brief  Initializes the MDIO interface GPIO and clocks.
  * @param  None
  * @retval 0 if OK, -1 if ERROR
  */
int32_t ETH_PHY_IO_Init(void)
{
  /* We assume that MDIO GPIO configuration is already done
     in the ETH_MspInit() else it should be done here
  */

  /* Configure the MDIO Clock */
  HAL_ETH_SetMDIOClockRange(&heth);

  return 0;
}

/**
  * @brief  De-Initializes the MDIO interface .
  * @param  None
  * @retval 0 if OK, -1 if ERROR
  */
int32_t ETH_PHY_IO_DeInit (void)
{
  return 0;
}

/**
  * @brief  Read a PHY register through the MDIO interface.
  * @param  DevAddr: PHY port address
  * @param  RegAddr: PHY register address
  * @param  pRegVal: pointer to hold the register value
  * @retval 0 if OK -1 if Error
  */
int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t *pRegVal)
{
  if(HAL_ETH_ReadPHYRegister(&heth, DevAddr, RegAddr, pRegVal) != HAL_OK)
  {
    return -1;
  }

  return 0;
}

/**
  * @brief  Write a value to a PHY register through the MDIO interface.
  * @param  DevAddr: PHY port address
  * @param  RegAddr: PHY register address
  * @param  RegVal: Value to be written
  * @retval 0 if OK -1 if Error
  */
int32_t ETH_PHY_IO_WriteReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t RegVal)
{
  if(HAL_ETH_WritePHYRegister(&heth, DevAddr, RegAddr, RegVal) != HAL_OK)
  {
    return -1;
  }

  return 0;
}

/**
  * @brief  Get the time in millisecons used for internal PHY driver process.
  * @retval Time value
  */
int32_t ETH_PHY_IO_GetTick(void)
{
  return HAL_GetTick();
}

/**
  * @brief  Check the ETH link state then update ETH driver and netif link accordingly.
  * @retval None
  */
void ethernet_link_check_state(struct netif *netif)
{
  ETH_MACConfigTypeDef MACConf = {0};
  int32_t PHYLinkState = 0;
  uint32_t linkchanged = 0U, speed = 0U, duplex = 0U;

  PHYLinkState = LAN8742_GetLinkState(&LAN8742);

  if(netif_is_link_up(netif) && (PHYLinkState <= LAN8742_STATUS_LINK_DOWN))
  {
    HAL_ETH_Stop_IT(&heth);
    netif_set_down(netif);
    netif_set_link_down(netif);
  }
  else if(!netif_is_link_up(netif) && (PHYLinkState > LAN8742_STATUS_LINK_DOWN))
  {
    switch (PHYLinkState)
    {
    case LAN8742_STATUS_100MBITS_FULLDUPLEX:
      duplex = ETH_FULLDUPLEX_MODE;
      speed = ETH_SPEED_100M;
      linkchanged = 1;
      break;
    case LAN8742_STATUS_100MBITS_HALFDUPLEX:
      duplex = ETH_HALFDUPLEX_MODE;
      speed = ETH_SPEED_100M;
      linkchanged = 1;
      break;
    case LAN8742_STATUS_10MBITS_FULLDUPLEX:
      duplex = ETH_FULLDUPLEX_MODE;
      speed = ETH_SPEED_10M;
      linkchanged = 1;
      break;
    case LAN8742_STATUS_10MBITS_HALFDUPLEX:
      duplex = ETH_HALFDUPLEX_MODE;
      speed = ETH_SPEED_10M;
      linkchanged = 1;
      break;
    default:
      break;
    }

    if(linkchanged)
    {
      /* Get MAC Config MAC */
      HAL_ETH_GetMACConfig(&heth, &MACConf);
      MACConf.DuplexMode = duplex;
      MACConf.Speed = speed;
      HAL_ETH_SetMACConfig(&heth, &MACConf);
      HAL_ETH_Start_IT(&heth);
      netif_set_up(netif);
      netif_set_link_up(netif);
    }
  }

}

void HAL_ETH_RxAllocateCallback(uint8_t **buff)
{
/* USER CODE BEGIN HAL ETH RxAllocateCallback */
  struct pbuf_custom *p = LWIP_MEMPOOL_ALLOC(RX_POOL);
  if (p)
  {
    /* Get the buff from the struct pbuf address. */
    *buff = (uint8_t *)p + offsetof(RxBuff_t, buff);
    p->custom_free_function = pbuf_free_custom;
    /* Initialize the struct pbuf.
    * This must be performed whenever a buffer's allocated because it may be
    * changed by lwIP or the app, e.g., pbuf_free decrements ref. */
    pbuf_alloced_custom(PBUF_RAW, 0, PBUF_REF, p, *buff, ETH_RX_BUFFER_SIZE);
  }
  else
  {
    RxAllocStatus = RX_ALLOC_ERROR;
    *buff = NULL;
  }
/* USER CODE END HAL ETH RxAllocateCallback */
}

void HAL_ETH_RxLinkCallback(void **pStart, void **pEnd, uint8_t *buff, uint16_t Length)
{
/* USER CODE BEGIN HAL ETH RxLinkCallback */

  struct pbuf **ppStart = (struct pbuf **)pStart;
  struct pbuf **ppEnd = (struct pbuf **)pEnd;
  struct pbuf *p = NULL;

  /* Get the struct pbuf from the buff address. */
  p = (struct pbuf *)(buff - offsetof(RxBuff_t, buff));
  p->next = NULL;
  p->tot_len = 0;
  p->len = Length;

  /* Chain the buffer. */
  if (!*ppStart)
  {
    /* The first buffer of the packet. */
    *ppStart = p;
  }
  else
  {
    /* Chain the buffer to the end of the packet. */
    (*ppEnd)->next = p;
  }
  *ppEnd  = p;

  /* Update the total length of all the buffers of the chain. Each pbuf in the chain should have its tot_len
   * set to its own length, plus the length of all the following pbufs in the chain. */
  for (p = *ppStart; p != NULL; p = p->next)
  {
    p->tot_len += Length;
  }

  /* Invalidate data cache because Rx DMA's writing to physical memory makes it stale. */
  SCB_InvalidateDCache_by_Addr((uint32_t *)buff, Length);

/* USER CODE END HAL ETH RxLinkCallback */
}

void HAL_ETH_TxFreeCallback(uint32_t * buff)
{
/* USER CODE BEGIN HAL ETH TxFreeCallback */

  pbuf_free((struct pbuf *)buff);

/* USER CODE END HAL ETH TxFreeCallback */
}

/* USER CODE BEGIN 8 */

/* USER CODE END 8 */

Project Root > CM7 > LWIP > Target > lwipopts.h :


/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * File Name          : Target/lwipopts.h
  * Description        : This file overrides LwIP stack default configuration
  *                      done in opt.h file.
  ******************************************************************************
  * @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 */

/* Define to prevent recursive inclusion --------------------------------------*/
#ifndef __LWIPOPTS__H__
#define __LWIPOPTS__H__

#include "main.h"

/*-----------------------------------------------------------------------------*/
/* Current version of LwIP supported by CubeMx: 2.1.2 -*/
/*-----------------------------------------------------------------------------*/

/* Within 'USER CODE' section, code will be kept by default at each generation */
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

#ifdef __cplusplus
 extern "C" {
#endif

/* STM32CubeMX Specific Parameters (not defined in opt.h) ---------------------*/
/* Parameters set in STM32CubeMX LwIP Configuration GUI -*/
/*----- WITH_RTOS disabled (Since FREERTOS is not set) -----*/
#define WITH_RTOS 0
/*----- CHECKSUM_BY_HARDWARE enabled -----*/
#define CHECKSUM_BY_HARDWARE 0
/*-----------------------------------------------------------------------------*/

#define MEM_SIZE 16384
#define MEMP_NUM_PBUF 16
#define MEMP_NUM_UDP_PCB 4
/* LwIP Stack Parameters (modified compared to initialization value in opt.h) -*/
/* Parameters set in STM32CubeMX LwIP Configuration GUI -*/
/*----- Value in opt.h for LWIP_DHCP: 0 -----*/
#define LWIP_DHCP 1
/*----- Default value in ETH configuration GUI in CubeMx: 1524 -----*/
#define ETH_RX_BUFFER_SIZE 1536
/*----- Value in opt.h for NO_SYS: 0 -----*/
#define NO_SYS 1
/*----- Value in opt.h for SYS_LIGHTWEIGHT_PROT: 1 -----*/
#define SYS_LIGHTWEIGHT_PROT 0
/*----- Value in opt.h for MEM_ALIGNMENT: 1 -----*/
#define MEM_ALIGNMENT 4
/*----- Default Value for H7 devices: 0x30004000 -----*/
#define LWIP_RAM_HEAP_POINTER 0x30020000
/*----- Value in opt.h for MEMP_NUM_SYS_TIMEOUT: (LWIP_TCP + IP_REASSEMBLY + LWIP_ARP + (2*LWIP_DHCP) + LWIP_AUTOIP + LWIP_IGMP + LWIP_DNS + (PPP_SUPPORT*6*MEMP_NUM_PPP_PCB) + (LWIP_IPV6 ? (1 + LWIP_IPV6_REASS + LWIP_IPV6_MLD) : 0)) -*/
#define MEMP_NUM_SYS_TIMEOUT 5
/*----- Value supported for H7 devices: 1 -----*/
#define LWIP_SUPPORT_CUSTOM_PBUF 1
/*----- Value in opt.h for LWIP_ETHERNET: LWIP_ARP || PPPOE_SUPPORT -*/
#define LWIP_ETHERNET 1
/*----- Value in opt.h for LWIP_DNS_SECURE: (LWIP_DNS_SECURE_RAND_XID | LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING | LWIP_DNS_SECURE_RAND_SRC_PORT) -*/
#define LWIP_DNS_SECURE 7
/*----- Value in opt.h for TCP_SND_QUEUELEN: (4*TCP_SND_BUF + (TCP_MSS - 1))/TCP_MSS -----*/
#define TCP_SND_QUEUELEN 9
/*----- Value in opt.h for TCP_SNDLOWAT: LWIP_MIN(LWIP_MAX(((TCP_SND_BUF)/2), (2 * TCP_MSS) + 1), (TCP_SND_BUF) - 1) -*/
#define TCP_SNDLOWAT 1071
/*----- Value in opt.h for TCP_SNDQUEUELOWAT: LWIP_MAX(TCP_SND_QUEUELEN)/2, 5) -*/
#define TCP_SNDQUEUELOWAT 5
/*----- Value in opt.h for TCP_WND_UPDATE_THRESHOLD: LWIP_MIN(TCP_WND/4, TCP_MSS*4) -----*/
#define TCP_WND_UPDATE_THRESHOLD 536
/*----- Value in opt.h for LWIP_NETIF_LINK_CALLBACK: 0 -----*/
#define LWIP_NETIF_LINK_CALLBACK 1
/*----- Value in opt.h for LWIP_NETCONN: 1 -----*/
#define LWIP_NETCONN 0
/*----- Value in opt.h for LWIP_SOCKET: 1 -----*/
#define LWIP_SOCKET 0
/*----- Value in opt.h for RECV_BUFSIZE_DEFAULT: INT_MAX -----*/
#define RECV_BUFSIZE_DEFAULT 2000000000
/*----- Value in opt.h for LWIP_STATS: 1 -----*/
#define LWIP_STATS 0
/*----- Value in opt.h for CHECKSUM_GEN_IP: 1 -----*/
#define CHECKSUM_GEN_IP 1
/*----- Value in opt.h for CHECKSUM_GEN_UDP: 1 -----*/
#define CHECKSUM_GEN_UDP 1
/*----- Value in opt.h for CHECKSUM_GEN_TCP: 1 -----*/
#define CHECKSUM_GEN_TCP 1
/*----- Value in opt.h for CHECKSUM_GEN_ICMP6: 1 -----*/
#define CHECKSUM_GEN_ICMP6 1
/*----- Value in opt.h for CHECKSUM_CHECK_IP: 1 -----*/
#define CHECKSUM_CHECK_IP 1
/*----- Value in opt.h for CHECKSUM_CHECK_UDP: 1 -----*/
#define CHECKSUM_CHECK_UDP 1
/*----- Value in opt.h for CHECKSUM_CHECK_TCP: 1 -----*/
#define CHECKSUM_CHECK_TCP 1
/*----- Value in opt.h for CHECKSUM_CHECK_ICMP6: 1 -----*/
#define CHECKSUM_CHECK_ICMP6 1
/*-----------------------------------------------------------------------------*/
/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

#ifdef __cplusplus
}
#endif
#endif /*__LWIPOPTS__H__ */

중요한 설정은

• LWIP_MEMPOOL_INIT(RX_POOL); 의 호출 위치 변경
• 하드웨어 체크섬 해제후 소프트웨어적으로 바꿈

이구요.

이후에

• 링커스크립트로 D2 도메인을 등록
• ethernetif.c에서 RX, TX 수신버퍼가 된대로 등록한 도메인에 할당

을 할 것입니다. ethernetif.c는 위와 같이 하면 되고 STM32H755ZITX_FLASH.ld에 아래처럼 교체합니다.

/*
******************************************************************************
**
**  File        : LinkerScript.ld
**
**  Author      : STM32CubeIDE
**
**  Abstract    : Linker script for STM32H7 series
**                      1024Kbytes FLASH
**                      800Kbytes RAM
**
**                Set heap size, stack size and stack location according
**                to application requirements.
**
**                Set memory bank area and size if external memory is used.
**
**  Target      : STMicroelectronics STM32
**
**  Distribution: The file is distributed as is without any warranty
**                of any kind.
**
*****************************************************************************
** @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.
**
*****************************************************************************
*/

/* Entry Point */
ENTRY(Reset_Handler)

/* Highest address of the user mode stack */
_estack = ORIGIN(RAM_D1) + LENGTH(RAM_D1); /* end of "RAM_D1" Ram type memory */

_Min_Heap_Size = 0x4000; /* required amount of heap  */
_Min_Stack_Size = 0x4000; /* required amount of stack */

/* Memories definition */
MEMORY
{
RAM_D1 (xrw)      : ORIGIN = 0x24000000, LENGTH =  512K
FLASH   (rx)      : ORIGIN = 0x08000000, LENGTH = 1024K    /* Memory is divided. Actual start is 0x08000000 and actual length is 2048K */
DTCMRAM (xrw)     : ORIGIN = 0x20000000, LENGTH = 128K
SRAM1_AND_2 (xrw) : ORIGIN = 0x30000000, LENGTH = 256K
SRAM3 (xrw)       : ORIGIN = 0x30040000, LENGTH = 32K
RAM_D3 (xrw)      : ORIGIN = 0x38000000, LENGTH = 64K
ITCMRAM (xrw)     : ORIGIN = 0x00000000, LENGTH = 64K
}

/* Sections */
SECTIONS
{
/* The startup code into "FLASH" Rom type memory */
.isr_vector :
{
. = ALIGN(4);
KEEP(*(.isr_vector)) /* Startup code */
. = ALIGN(4);
} >FLASH

/* The program code and other data into "FLASH" Rom type memory */
.text :
{
. = ALIGN(4);
*(.text)           /* .text sections (code) */
*(.text*)          /* .text* sections (code) */
*(.glue_7)         /* glue arm to thumb code */
*(.glue_7t)        /* glue thumb to arm code */
*(.eh_frame)

KEEP (*(.init))
KEEP (*(.fini))

. = ALIGN(4);
_etext = .;        /* define a global symbols at end of code */
} >FLASH

/* Constant data into "FLASH" Rom type memory */
.rodata :
{
. = ALIGN(4);
*(.rodata)         /* .rodata sections (constants, strings, etc.) */
*(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
. = ALIGN(4);
} >FLASH

.ARM.extab (READONLY) : /* The READONLY keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */
{
. = ALIGN(4);
*(.ARM.extab* .gnu.linkonce.armextab.*)
. = ALIGN(4);
} >FLASH
.ARM (READONLY) : /* The READONLY keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */
{
. = ALIGN(4);
__exidx_start = .;
*(.ARM.exidx*)
__exidx_end = .;
. = ALIGN(4);
} >FLASH

.preinit_array (READONLY) : /* The READONLY keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */
{
. = ALIGN(4);
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array*))
PROVIDE_HIDDEN (__preinit_array_end = .);
. = ALIGN(4);
} >FLASH

.init_array (READONLY) : /* The READONLY keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */
{
. = ALIGN(4);
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array*))
PROVIDE_HIDDEN (__init_array_end = .);
. = ALIGN(4);
} >FLASH

.fini_array (READONLY) : /* The READONLY keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */
{
. = ALIGN(4);
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT(.fini_array.*)))
KEEP (*(.fini_array*))
PROVIDE_HIDDEN (__fini_array_end = .);
. = ALIGN(4);
} >FLASH

/* Used by the startup to initialize data */
_sidata = LOADADDR(.data);

/* Initialized data sections into "RAM" Ram type memory */
.data :
{
. = ALIGN(4);
_sdata = .;        /* create a global symbol at data start */
*(.data)           /* .data sections */
*(.data*)          /* .data* sections */
*(.RamFunc)        /* .RamFunc sections */
*(.RamFunc*)       /* .RamFunc* sections */

. = ALIGN(4);
_edata = .;        /* define a global symbol at data end */
} >RAM_D1 AT> FLASH

/* Uninitialized data section into "RAM" Ram type memory */
. = ALIGN(4);
.bss :
{
/* This is used by the startup in order to initialize the .bss section */
_sbss = .;         /* define a global symbol at bss start */
__bss_start__ = _sbss;
*(.bss)
*(.bss*)
*(COMMON)

. = ALIGN(4);
_ebss = .;         /* define a global symbol at bss end */
__bss_end__ = _ebss;
} >RAM_D1

/* User_heap_stack section, used to check that there is enough "RAM" Ram  type memory left */
._user_heap_stack :
{
. = ALIGN(8);
PROVIDE ( end = . );
PROVIDE ( _end = . );
. = . + _Min_Heap_Size;
. = . + _Min_Stack_Size;
. = ALIGN(8);
} >RAM_D1

.lwip_sec : 
{
. = ALIGN(32);
*(.RxDecripSection)
. = ALIGN(32);
*(.TxDecripSection)
. = ALIGN(32);
*(.Rx_PoolSection)
} >SRAM1_AND_2
/* Remove information from the compiler libraries */
/DISCARD/ :
{
libc.a ( * )
libm.a ( * )
libgcc.a ( * )
}

.ARM.attributes 0 : { *(.ARM.attributes) }
}

이렇게 하면 위에 ethernetif.c의 초반부에 선언된 RX, TX 변수가 SRAM1_AND_2에 배정되어 이더넷 장치가 참조가 가능하게 됩니다.

#define ETH_RX_BUFFER_CNT             12U
__attribute__((section(".Rx_PoolSection"))) LWIP_MEMPOOL_DECLARE(RX_POOL, ETH_RX_BUFFER_CNT, sizeof(RxBuff_t), "Zero-copy RX PBUF pool");

이 부분과

#elif defined ( __GNUC__ ) /* GNU Compiler */

ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT] __attribute__((section(".RxDecripSection"))); /* Ethernet Rx DMA Descriptors */
ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT] __attribute__((section(".TxDecripSection")));   /* Ethernet Tx DMA Descriptors */

#endif

#if defined ( __ICCARM__ ) /*!< IAR Compiler */
#pragma location = 0x30000100
extern u8_t memp_memory_RX_POOL_base[];

#elif defined ( __CC_ARM ) /* MDK ARM Compiler */
__attribute__((section(".Rx_PoolSection"))) extern u8_t memp_memory_RX_POOL_base[];

#elif defined ( __GNUC__ ) /* GNU */
__attribute__((section(".Rx_PoolSection"))) extern u8_t memp_memory_RX_POOL_base[];
#endif

이부분이 확실하게 각각의 구간에 선언되게 해놔야 합니다.

이렇게 해두고나서 main.c에

#include "main.h"
#include "lwip.h"
#include "usart.h"
#include "gpio.h"

#include "lwip.h"
#include "lwip/dhcp.h"
#include "lwip/netif.h"
#include <stdio.h>
#include <string.h>


extern struct netif gnetif;
char ip_string[16] = {0};
uint8_t dhcp_state = 0;
uint8_t link_state = 0;

void Display_IP_Address(void)
{
  uint32_t ip_addr = gnetif.ip_addr.addr;

  /* Convert IP to string */
  sprintf(ip_string, "%d.%d.%d.%d",
          (int)(ip_addr & 0xFF),
          (int)((ip_addr >> 8) & 0xFF),
          (int)((ip_addr >> 16) & 0xFF),
          (int)((ip_addr >> 24) & 0xFF));

  /* Print to UART */
  printf("IP Address: %s\r\n", ip_string);
  printf("Netmask: %d.%d.%d.%d\r\n",
         (int)(gnetif.netmask.addr & 0xFF),
         (int)((gnetif.netmask.addr >> 8) & 0xFF),
         (int)((gnetif.netmask.addr >> 16) & 0xFF),
         (int)((gnetif.netmask.addr >> 24) & 0xFF));
  printf("Gateway: %d.%d.%d.%d\r\n",
         (int)(gnetif.gw.addr & 0xFF),
         (int)((gnetif.gw.addr >> 8) & 0xFF),
         (int)((gnetif.gw.addr >> 16) & 0xFF),
         (int)((gnetif.gw.addr >> 24) & 0xFF));
}

void network_run() {

  HAL_Delay(5000);
  printf("\r\n\r\n");
  printf("=== Ethernet Test ===\r\n");

  /* * 참고: 케이블이 이미 꽂혀있는 상태로 부팅되면
   * 루프 진입 직후 netif_is_link_up이 true가 되어
   * 즉시 DHCP가 시작됩니다.
   */

  while (1) {
    /* LwIP 주기적 처리 (패킷 수신, 타이머 처리 등) */
    MX_LWIP_Process();

    /* 1. 링크 상태 모니터링 및 DHCP 제어 */
    if (netif_is_link_up(&gnetif) && link_state == 0)
    {
      /* 링크가 방금 연결됨 (0 -> 1) */
      link_state = 1;
      printf("Ethernet Link UP - Starting DHCP...\r\n");

      /* 여기서 DHCP 시작! */
      dhcp_start(&gnetif);
    }
    else if (!netif_is_link_up(&gnetif) && link_state == 1)
    {
      /* 링크가 끊어짐 (1 -> 0) */
      link_state = 0;
      dhcp_state = 0; // IP 출력 플래그 초기화
      printf("Ethernet Link DOWN - Stopping DHCP.\r\n");

      /* DHCP 중지 (선택 사항이지만 권장) */
      dhcp_stop(&gnetif);

      /* IP 주소를 0.0.0.0으로 리셋 (재연결 시 갱신 확인용) */
      ip_addr_set_zero(&gnetif.ip_addr);
      ip_addr_set_zero(&gnetif.netmask);
      ip_addr_set_zero(&gnetif.gw);
    }

    /* 2. IP 할당 완료 체크 */
    /* dhcp_state 변수는 'IP가 출력되었는지'를 확인하는 용도로 사용 */
    if (gnetif.ip_addr.addr != 0 && dhcp_state == 0)
    {
      dhcp_state = 1; // 한 번만 출력하기 위한 플래그
      printf("DHCP Bound Success!\r\n");
      Display_IP_Address();
    }

    /* 너무 긴 지연은 LwIP 처리를 늦출 수 있으므로 줄이거나 제거하는 것이 좋습니다 */
    /* HAL_Delay(100); -> 10ms 정도로 줄이거나 제거 권장 */
    HAL_Delay(10);
  }
}

처럼 선언한 함수를 main()에서 장치 초기화 다음 라인에

network_run();

처럼 호출합니다.

위파일대로 되어 있다면 잘 작동할 것입니다.

이더넷 케이블을 꼽고 (CAT5 추천) 있으면 Link Up 이 되었다고 나오고, 이내 DHCP Bound Success!가 뜨고 DHCP로 IP를 받아옵니다. 케이블을 떼어내면 Link DOWN!이 뜨고 다시 연결하면 DHCP Bound Success! 가 뜹니다. 이것이 순식간에 일어납니다.

물론 50MHz의 빠른 속도가 필요하니 설정이 필요한데요. ETH 핀들의 Maximum 속도를 Very High로 두는 것입니다. 대체로 위 코드에 포함되어있습니다.

혹시 오타가 있다면 말씀해주세요. 프록시 환경이라 오타가 늦게 발견되기도 합니다. 일단 올려둡니다.

로직 아날라이저 개념 정리

전자기기가 작동할때 전류가 흐르고 전압이 인가되어 있는 상태와 해제되어 있는 상태, 전압이 강하게 가해진 상태와 약하게 가해진 상태들이 공존합니다. 라즈베리파이 피코로 개발을 할때도 이런 전류와 전압 신호가 가해지면 작동 상태가 어떠어떠할 것이라는 분석이 되는 원리가 있습니다.

우선 전류는 아날로그 신호입니다. 아날로그 신호는 자연상태의 날 것 그대로의 신호로, 연속적으로 변화하는 양입니다. 그런데 이를 기기로 제어하려면 일정 정도는 디지털화해야 합니다. 피코에서 전송되는 각종 GPIO 핀에 가해지는 신호는 전압세기로 구별해서 0이나 1로 대표되는 불리언값으로 변환되게 해서 관측하는데요. 이를 디지털 신호라고 하고 프로그램 디버깅과 작동 상황 유추에 쓰이죠.

전기통신 분야에서 데이터를 원활하게 송수신한다든지, 특정 기능을 동시에 작동시키기 위해 여러 이벤트나 프로세스 등을 조화시키는 작업 등에 로직 아날라이저의 디지털 신호에 대한 펄스 표시로 알 수 있습니다.

이는 펄스의 주기적인 성질에 의해 아래와 같은 약속이 가능해지죠.

위 그림은 라즈베리파이 피코에 장착되어 쓰이는 오디오 모듈의 펄스 그림인데요. 이들 중첩된 신호는 각 채널별로 특정 프로토콜의 각기 다른 핀아웃에서 나온 신호를 병렬해서 관찰하는 그림입니다.

이런 파형 위상(?)마다의 부분에 의미가 주어지는데 이 주어진 의미가 여러 채널의 신호와 함께 분석되어 작동 상황을 알 수 있고 결국 디버깅이 가능해집니다.

로직 아날라이저는 위와 같이, 각채널별로 인가되는 신호를 캡처해서 분석하고 화면에 표시를 해주는 기기인데요. 날것의 전류와 같은 아날로그 신호를 표시하는 오실로스코프에 비해 디지털 신호라고 하는 위에 해설한 신호를 보여주고, 분석에 편리하도록 여러 모드를 전환해서 볼 수 있게 해주는 편리한 기기입니다.

위에서 불리언값을 언급했는데요. 더 동적인 형태의 아날로그 신호에 비해 논리 상태를 표시하는 비교적 단순한 형태로 되어 있고, 회로나 시스템의 복잡한 논리 상태를 표시합니다. 위 두번째 그림처럼 디지털 신호 각각의 부분에 의미가 주어지게 됩니다. 기준은 SPI, I2C 등의 프로토콜의 핀아웃 성분을 각각의 채널에 연결해서 각각의 채널이 서로 중첩되는 모양을 보고 유추하게 되죠.

threshold, sample points, sample result, timing analysis와 같은 개념이 있네요.

위 그림은 예시로, 각각의 형태가 겹치는 형태나 펄스의 간격 등을 토대로 분석이 진행됩니다. 제가 알기로 우선 신호를 주고받는 프로토콜에 의해 대략 결정이 되구요. 제작사에서 정의하기도 한다고 합니다.

https://web.archive.org/web/20210909153137/https://literature.cdn.keysight.com/litweb/pdf/5968-8291E.pdf?id=1000001806:epsg:apn

에 더 자세한 해설이 나옵니다.

보통 가격이 비싼 제품들은 1GHz의 속도를 보장하구요. 채널이 개수가 늘어날수록 속도가 조금씩 떨어집니다. 한번에 여러 장비를 연결해서 쓸때는 채널수도 중요하고, 속도도 빠르면 좋네요. 그러나 이런 기기들은 비싸므로, 사양을 조금 낮추면 흔히 카피 제품이라고 하는 제품들이 있는데, 어떤 카피 제품들은 최고 16채널 연결 지원, 3채널부터 시작하면 100MHz 작동을 보여주기도 하구요. 이보다 더 저렴한 제품들은 최고 8채널에 최소채널로 캡처하면 24MHz의 작동을 보여주기도 합니다.

많은 경우 사양이 낮아도 초급 단계에서의 관측은 가능하다고 하는데요. 우선 비용을 들이면 들일수록 사양이 높아지는 것은 있는 것 같애요. 관측값 저장 기능이나 장착된 램 크기도 유의되던데 램 크기는 연속적으로 오랜 시간 작동시킬때 유의된다고 하구요. 비용을 일정 정도 들이면 전자공학을 지속하면서 복잡한 구성의 프로젝트를 진행할때 분명 보탬이 되어줄 것 같습니다.

디지털 카메라의 광학 성능과 소프트웨어적인 성능

디지털 카메라의 기본 성능은 광학 성능과 소프트웨어적인 성능에 의해 판가름납니다.

광학 성능은 순수 하드웨어적인 성능 지표구요. 렌즈의 구경, 밝기, 분해능등의 성능과, 센서의 면적, 화소, 해상력 등의 성능이 대표적인 광학 성능입니다. 한마디로 렌즈가 크고, 밝고, 한 지점과 인접 지점의 거리가 짧아도 분리해내는 능력이 크면 좋구요. 센서에 면적이 넓어서 기본 해상도가 크고, 화소가 많아서 확대시에도 선명하다면 좋습니다.

보통 DSLR이나 미러리스 카메라가 좋은 이유도, 렌즈와 센서가 좋아서입니다.

렌즈 구경이 커지면 광선들의 다발이 더 잘 들어와서 이미지도 밝아지고 흔들림에도 좋아지구요. 더 먼 곳에서 오는 빛을 잘 모아줄 수 있습니다. 센서가 커지면 픽셀 데이터를 더 많이 표현이 가능해져서 분해능과 해상력 면에서 좋아지는 원리죠.

요즘은 스마트폰으로도 쨍한 사진이 잘 얻어지는데요. 스마트폰은 작은 기기다보니 렌즈와 센서가 작지만, 소프트웨어적인 화상 처리 성능이 좋아서 이를 상쇄하는 경우네요. 화상 처리 성능은 픽셀을 증폭하거나, 조작해서 기본적으로 얻어진 날것의 빛 데이터를 가공하는 기술인데요. 광학 성능이 조금 쳐지더라도 요즘과 같은 화상 처리 기능으로 처리하면 화질 좋은 사진이 얻어지게 됩니다. 광학 성능에 비교하기 위해 소프트웨어적인 성능이라고 하는데요. 엄밀히 보면 화상 처리 프로세서가 하는 것이라 하드웨어라고도 하지만, 알고리즘 자체는 소프트웨어적인 것입니다. 내장 필터처럼 포토샵에 대응되는 화상 처리를 카메라 자체적으로 한다는 것이죠. 스마트폰은 광학 성능은 약한데, 화상 처리 기술의 발전으로 쨍한 사진을 만듭니다.

이런 화상 처리는 여러 디지털화된 사양에 영향을 받습니다.

디지털화된 색상 정보는 보통 RGB라고 해서 적색(red), 녹색(green), 파란색(blue)을 채널로 나누어 농도를 조합하는 방식으로 색상표현을 합니다.

비트심도라고 해서 자연의 색상을 디지털로 만들때, R, G, B 각 채널별로 계조 표현을 얼마나 단계를 두는지에 대한 사양이 있는데요. 전통적인 JPEG 방식으로 처리하면 각 채널별로 8비트씩이고, 비트는 0이나 1의 두단계를 표현하므로, 각 채널별로 2의 8승 표현이 되어 256가지 표현이 되구요. 10비트라면 2의 10승이니 1024 가지 표현이 되어 비트심도가 높아질 수록 이미지 보정할때 명암이 확 날아가는 정도가 낮아집니다.

이 경우에는 소프트웨어적인 화상 처리 기법에 의해 처리가 되는 예이구요. 스마트폰으로도 좋은 화질이 얻어지는 것과 관련이 있습니다.

요즘에는 스마트폰도 RAW 저장이 가능한 경우가 있으니 화질이 더 좋아질 수 있네요. RAW의 비트심도가 이에 중요한 요소입니다.

여튼 이렇구요. 여행가실때 사진 많이 찍으시느라 카메라에 관심이 있으신 경우가 많으실텐데요. 멀리 보이는 지평선 너머를 찍는 등의 활동을 하려면 렌즈가 중요하니 망원렌즈와 미러리스를 구하시는게 좋지만, 스냅샷으로 찍으시면서도 가까운 정감을 표현하는 정도로 만족하신다면 최신 스마트폰 중에 최대한 광학 성능도 보장되는 플래그십 기종을 쓰시면 좋을 것입니다.

이해가 잘 되게 해설한지는 확신이 없지만 정보력이 있을듯하여 올립니다.

아주 오래된 기술이 지원에서 해제되는 이유

전산학은 프로그램과 하드웨어 개발이 주로 이루어지는 분야입니다. 많은 경우 기술이 발전되면 성능이 개선되고 버그도 잡히는 것이 기대되죠. 때로는 버전업이 될때 오래전의 기술이 지원 해제가 되기도 합니다. 어떤 경우 그 기능 자체가 없어지고 다른 기술로 대체되기도 하구요. 하위 호환성을 위해 지속되더라도 실재 제작시에는 사용을 권장하지 않는 공지를 합니다.

이를 풀어서 설명하자면 이렇습니다.

보안이 문제인 경우
오래된 표준으로 만든 기술은 시간이 지나면 지원에서 해제됩니다. 리얼오디오나 어도비 플래시가 그 예죠. 이 경우 시장에서 완전히 사라진 기술이라, 오픈소스 개발자 같은 분들이 호환되는 기술을 개발하지 않는다면 영원히 안쓰게 될 것입니다. 이 경우 오래전에 제작된 웹페이지를 볼때 적절하게 표시가 안될 것입니다.

이 경우 기능을 그대로 두었을때 보안이 취약하게 되는 공격이 가능해질 수 있는데 기술 지원을 끊으면 사용자 컴퓨터가 악의적인 공격에 놓이게 되서 기능 자체를 단종시키는 경우네요. 이런 경우 유예 기간을 두어 점차적으로 다른 대체 기능으로 옮겨가게 합니다. 특히 기업에서 도입한 기술이 단종될때 이렇습니다.

제작사가 유지보수를 할 의지가 있더라도 성능 저하 등의 이유로 사용을 비권장하는 경우
이경우 하위 호환성을 위해 지원은 해주지만 해당 기술을 써서 제작하는 하드웨어나 소프트웨어에 해당 기술을 적용하는 것을 비권장하는 경우입니다. 이 경우 오래전에 만들어진 기능은 작동이 되지만, 때로는 오래되어 지원이 끊긴 기술임을 실행시 보여주기도 하죠.

이 경우에도 어쩔 수 없이 해당 기술을 써야 한다면 말리는게 불가능하지만, 지켜주는게 좋습니다.

프로그램을 만들때 제작사에서 제공하는 API에서 비권장하는 코드는 deprecated라고 하고, 완전하게 없애는 코드는 obsolete이라고 합니다. 이 두가지 코드는 프로그램 제작시 안쓰는 것이 좋습니다. 대체 기능을 찾아봐야죠.

기술자들의 여론이 보안에 아주 나쁘다고 해서 이 의견을 받아들인 경우
잘 아시는 ActiveX와 같은 기술이 예 같애요. ActiveX는 웹페이지에서 사용자 PC에 설정을 바꾸거나 작동을 일으키게 할 수 있는데 이게 보안이 취약해지는 이유가 됩니다. 그런데도 탁상행정으로 이 기술을 표준으로 되게 해서 기술자들이 외국 사정과 비교를 많이 해왔던 기술로, 마이크로소프트에서 IE를 단종하던 시절과 비슷한 시기에 단종했습니다.

이 경우에 이미 존재하던 ActiveX로 만든 기능에 세대 교체를 대처하려면 은행 같은 기업은 편리한데, SOHO 같은 경우 비용부담이 있게 되죠. 이 경우에도 단종을 해야 하나 말아냐 하나에 기술적인 원인 외에 사회경제적인 원인이 복합되기도 합니다.

우연하게 일어난 결함이 기술 자체를 비신뢰 대상으로 한 경우
USB 3.2 Gen 2×2에 대해 알게된적이 있는데 이게 특수한 경우인지 아니면 전면화된 경우인지는 모르지만 OS 업데이트나 개인 PC 특성에 의해 USB 포트가 작동을 안할때 이게 알려져서 논란이 되는 경우도 있습니다. 그러면 하드웨어 제작사에서도 헷갈리게 되고 이를 책임감으로 연구하지 않으면 안되고, 잘 알려지지도 않는다면 그 기술이 도태되기도 합니다. 문제가 퍼트려지면 전체 문제처럼 되죠.

이 경우 실재로는 특수한 문제인데, 기술이 도태되는 원인이 되기도 합니다.

시장 상황이 여론이 일으켜져서 단종 수순인데 업체측에서 비용을 들여가면서 연구해서 잘 된다고 하기도 애매한 경우 더 그렇죠. 연구해서 알려지게 해도 이미 시장 상황이 단종을 바라면 이역시도 우연하게 알려진 결함이 단종하게 하는 경우입니다.

이 정도로 특정적으로 해설해봅니다. 알아두시면 대처력이나 판단력도 확장되실 것입니다. 이 조건들을 잘 알면 좋네요.

암달의 법칙, 구스타프슨의 법칙, 리틀의 법칙

무어의 법칙이 프로세서 성능 향상의 주기를 논의했다면 단일 프로세서의 클락 속도 향상만으로는 발열 문제나 여러 다른 원인들이 겹쳐서 성능 향상이 불가능해졌다.

하나의 CPU 다이 안에 여러 개의 코어를 두고 처리하는 방안이 대안으로 유력하다. 그러나 이 경우에도 프로세서의 처리 속도와 타부품들의 처리 속도, 프로그램의 성능 등의 요인으로 인해 프로세서 코어를 늘린만큼 배수가 되지 않고 병목현상이 있게 된 만큼은 손실되어 성능 향상이 있게 된다.

이를 공식으로 만들어 각각의 시스템 별로 다른 상태를 반영하기 위해 암달의 법칙 공식이 개발되었다.

속도 향상  = 1 / [(1 – S)+S/P]

로 나타내고 S는 병렬화되어 처리되어 전체 작업에서 차지하는 값을 나타낸다. P는 프로세서의 개수 (또는 코어 수)다.

만약 부동 소수점 연산 시간이 전체 실행 시간의 50%를 차지하는 프로그램이 있었을때 프로세서의 연산장치를 2배로 늘리면 전체 성능 향상은 1/[(1-0.5)+0.5/2]=1.33이 되어 프로세서가 2배 빨라져도 성능 향상은 1.33배다.

프로그램의 실행을 2배 빠르게 하려면 2=1/[(1-0.5)+0.5/P]가 되고 0.5/P=0이어야 하므로 P=무한대다. 그래서 50%의 부하가 걸리는 경우 부동 소수점 연산을 위해 하드웨어에 투자하더라도 전체 성능은 2배가 안된다. (여기까지는 책의 예제)

이에 대해 1988년에 구스타프슨이 다른 유형의 법칙을 만들었는데 프로세서 수가 늘어나면 선형적으로 성능이 향상될 수 있다는 법칙이다. 이 법칙과 암달의 법칙은 시스템 성능 향상에 대한 아이디어를 제시해서 잘 알려져 있다.

암달의 법칙이 프로세서를 아무리 많이 병렬화하더라도 어느 시점이 되면 성능향상이 없는 한계가 있음을 말하는 법칙이라면 이를 비관적인 것으로 보고 효과적으로 병렬화하는 것이 가능하다는 법칙은 구스타프슨의 법칙이다.

이론상 성능 향상 비율 = P – n(P – 1)

이 공식에서 P는 프로세서의 개수, n은 병렬화되지 않은 부분의 비율이다. 이 공식으로 알 수 있는 사실은 동일한 시간에 처리 가능한 최대 처리율을 가리키고 암달의 법칙과 대비된다. 암달의 법칙은 실행 시간의 감소에 초점을 두었다면 구스타프슨의 경우 처리율에 초점을 두었다.

암달의 법칙에 의하면 프로세서 코어를 아무리 많이 늘려도 성능 향상폭은 제한적이다. 그러나 프로세서 제작 알고리즘이 고도화된 시대로 오면 성능 향상폭이 클 수 있다. 병렬화안된 부분이 전체 프로세스의 50%이고 코어가 32개 투입되면 16.5배의 데이터를 처리하게 된다.

성능 측정 공식으로 또하나 중요한 공식은 리틀의 법칙이라고 불리우는 공식이다. 본래 경영학에서 쓰이던 공식이지만 그 응용의 하나로 컴퓨터 공학에서 하드웨어 성능 측정이나 소프트웨어의 처리 속도 개선에도 쓰이게 된 공식이다.

리틀의 법칙은 통계적으로 안정 상태의 체제에 적용이 가능하다. 안정 상태이므로 대상이 정상적으로 균일하게 입출됨을 의미한다. 시간당 동시처리되는 요청 개수가 L이고 n은 전체 스레드의 평균 처리 개수이고 W는 평균 응답시간일때 리틀의 법칙은 아래처럼 된다.

L = nW

이 경우 단순화된 공식이지만 대기열에서 작동하는 하드웨어나 소프트웨어의 처리에 소요되는 응답시간과 같은 지표를 간단하게 예측할 수 있어 주목을 받았다. 성능 측정시에 하드웨어를 빠르게 하거나 소프트웨어의 실행을 빠르게 하는 경우 리틀의 법칙으로 대략 예측하여 성능 개선에 쓸 수 있다.

예를 들면 n이 25개, W가 100ms라면 250개의 처리가 1초에 동시에 된다.

마이크로프로세서의 성능 개선에 대한 노트

오늘 머리가 맹맹한게 개선되어 컴공 교과서를 더 읽었습니다. 노트를 남긴 것을 올립니다. 교과서에 나온 흐름을 참고해서 제 표현도 고안해서 해놨는데 몇 대목은 요약적입니다.


컴퓨터와 전자기기의 성능은 마이크로프로세서의 성능에 일차적으로 의존적입니다. 주변기기나 부품들의 성능도 중요하지만, 일단 중심이 되는 마이크로프로세서이기에 마이크로프로세서의 성능 개선이 전체 실행 속도의 개선에 중요한 구심점이 되는 것입니다.

요즘은 제작단가도 낮아지고 있어서 일회용으로 쓰고 버리는 마이크로프로세서도 있다고 하구요. 기술의 혁신이 가져온 시장인데, 제작단가는 낮추고 성능은 향상시키는 것입니다.

성능 향상은 명령어 인출과 저장, 실행, 버스와 캐시, 버퍼등의 하드웨어적 이점 등에 영향을 받습니다. 명령어를 한번에 많이 보내고 병렬로 처리하는 등의 단순해보이는 작업은 이들 구성요소들을 얼마나 효율적으로 분배하느냐에 따라 결정이 됩니다.

성능좋은 프로세서의 효용은 아래와 같습니다.

영상처리
3차원 렌더링
음성 인식
화상회의
멀티미디어 오소링
파일에 첨부되는 음성과 영상 실행
시뮬레이션 모델링

이들이 현재의 데스크탑 PC에서도 가능하게 프로세서 기능이 진화된 세상입니다. 속도와 성능은 대폭 개선되었지만, 오늘날의 컴퓨팅 기술은 폰노이만 형태의 IAS 컴퓨터와 구성요소 블록이 흡사합니다. 즉 조직은 이어져오는면이 있는데 이는 구조적으로 어떻게 성능이 결정되는지의 결정도 되죠. 예를 들면 마이크로프로세서가 나노세컨드로도 작동할때 보조기억장치는 1초에 80MB만 읽어들이면 병목현상이 있게 되고 이를 효과적으로 처리하는 기술들이 관건이 됩니다.

현대 프로세서들은 성장이 발전해서 여러 하드웨어적인 구조상으로 성능 향상을 주는 구현을 합니다. 아래와 같은 기술들이 우선 이해되면 좋습니다.

파이프라이닝(pipelining) – 명령어의 실행 단계를 여러개로 나누어 병렬로 실행하는 기술입니다. 여러개의 명령어를 동시에 서로 다른 단계에 실행해서 다수의 명령어를 동시에 실행합니다. 처리의 예를 들면 버퍼링을 하면서 영상의 디코더를 실행하는 것과 같은 연산을 할때 명령어로 읽어들이면서 다른 명령어를 해독하고 있으면 각각의 단계가 병렬로 실행되면서 프로세서가 바쁘게 돌아가는 작동이 되어 작업처리 속도가 빨라집니다. 이 각각의 단계는 파이프라인이라고 불리우며 이는 개념적으로 나타낸 도식의 각 단계로 유비됩니다. 인텔의 x86 계열 CPU는 파이프라인을 늘려서 처리속도 개선을 해왔는데, 각각의 파이프라인이 100개이고 4000MHz의 클럭속도일때, 각각의 파이프라인에 40MHz의 클록이 배정되게 작동합니다. 그러나 파이프라인을 너무 크게 설비하면 발열등의 현상으로 인해 성능외적인 문제가 있게 되어 요즘은 파이프라인을 적당히 설비하고 코어수를 늘려서 해결하는 방안이 널리 쓰입니다.

분기예측(branch prediction) – 프로세서는 알고리즘 설계를 토대로 소프트웨어의 작동을 미리 살펴보고 어떤 분기를 실행하여 명령어 집합이 다음에 처리될지 예측합니다. 명령어 집합을 미리 인출해서 버퍼에 저장하고 병렬처리를 합니다. 이 알고리즘을 고도화하면 이후에 나타날 여러 분기가 모두 예측될 수 있고 결국 효율이 높아집니다. 이는 잠재적으로 프로세서가 수행할 일의 양을 증가시켜 유후상태를 방지합니다. 그러면 작업 처리 속도도 증가합니다.

슈퍼스칼라 실행(superscalar execution) – 프로세서의 클럭 사이클마다 한개 이상의 명령어를 발송해서 여러개의 병렬처리가 가능해집니다.

데이터 흐름 분석(data flow analysis) – 명령어 사이의 결과값이나 데이터 의존성을 분석하여 최적의 실행 조건을 찾아냅니다. 프로그램 실행 순서를 너무 고지식하게 처리하기보다 준비되는 즉시 실행되도록 하여 지연을 줄여줍니다.

추정실행(speculative execution) – 분기 예측과 데이터 흐름 분석을 이용하는 경우, 명령어들이 실행되는 것을 결정하여 결과값을 임시 장소에 저장합니다. 이렇게 하면 필요한 것으로 예측되는 명령어들을 미리 실행함으로써 하드웨어를 가능한 한 바쁘게 만듭니다. 발열은 늘어나겠으나 처리속도가 개선됩니다.


프로세서의 속도가 무척이나 빨라져서 단순 지표로 40억개의 연산이 1초에 되기도 하고 놀라운 성능을 낸다. 하지만 컴퓨터의 속도는 프로세서만 빨라서는 안되고 타주변기기가 부품들의 속도가 지지되어야 향상이 가능하다. 프로세서의 속도와 주요 부품들의 속도를 최대한 맞추어주는 것을 성능 균형이라고 하고 다양한 부품이나 구성 요소들의 성능 불일치를 개선하는 것이 기술 개발의 한 주목 지점이다.

프로세서와 주기억장치 간의 인터페이스 기술
프로세서와 보조기억장치 간의 인터페이스 기술
그외 조합들

이 관건이다.

주기억장치는 x86 계열의 데스크탑용을 생각해보면 DDR 기술과 레이턴시가 그 지표가 된다. 레이턴시는 나노초 단위지만, 프로세서와 연동시 버스를 거쳐야 하므로 프로세서 내부의 캐시나 버퍼링보다는 통신이 오래 걸리는 편일 것이다. 3차원 모델링 표시들이 그 예가 된다. 이 경우 그래픽 카드 내에 램을 따로 달아 해결하기도 할 것이다. 모든 작업을 프로세서와 주기억장치의 통신으로만 해결하지 않고 해결하는 방법은 많다.

중요한 것은 기억장치들의 독립적인 성능향상도 그렇하지만 이들끼리의 통신을 얼마나 짧은 거리에서 얼마나 빠른 버스로 처리할지의 여부다. 상식적으로는 더 깊게 하는게 일반적이지만 때로는 더 넓게 해서 한번에 인출하는 개수를 높히기도 한다. DRAM을 칩상의 캐시나 버퍼링으로 포함하기도 한다. 프로세서 내부에도 캐시가 들어가고 외부에 두는 등의 선택지도 있다. 버스를 계층화하기도 한다.

설계적으로 입출력 장치들의 입출력 요구율과 입출력 처리율을 조정한다. 기술발전이 이루어져도 다양한 기술 대상에 대한 성능 변화는 얽혀있어서 이를 정리하고 균형을 맞추는게 중요하다.

마이크로프로세서의 성능 개선은 성능 균형을 고려하고 성능 불일치를 해결하는 것이다.

칩 조직과 구조 개선

성능 개선은 몇가지 기술적인 패턴이 있다.

프로세서 자체의 하드웨어 속도 개선 – 칩상의 논리게이트 수 감소와 동시에 더 많은 게이트를 조밀하게 배치.
프로세서와 주기억장치 사이의 속도 개선 – 캐시 크기와 속도 개선. 프로세서 내부에 위치시키도록 조정.
프로세서 아키텍처 개선 – 명령어 처리나 병렬성 개선.

대표적인 패턴은 클럭 속도 향상, 회로 밀도 증가다. 그러나 이 둘의 고도화가 진행될 수록 단점도 있게 된다.

전력 밀도가 높아진다. 발열과 쿨링 문제가 따라온다.
RC 지연이 된다. RC곱이 증가할때마다 지연도 길어진다. 칩상의 부품이 미세해질수록 저항이 증가하고, 더 가까이 위치할수록 커패시턴스도 증가한다.
기억장치 지연과 처리율 미비. 프로세서보다 느린 경우가 많다.

해결법은

칩상에 캐시 메모리의 배치를 늘린다
병렬처리를 위해 프로세서의 명령어 실행 회로를 고도화한다
많은 수의 트랜지스터를 직접하는 효율적 방법을 찾는다

이러한 것이 대표적인 설계에서의 성능 균형 맞추는 기법의 일단이다.

DAC와 ADC – 디지털화에 대한 이해

현실 세계에서 존재하는 물리량들은 아날로그적입니다. 아날로그라 함은 다시 말해 날 것 그대로의 자연적인 현상이라는 것입니다. 예를 들면 바람의 추운 정도, 열로 나타낼 수 있는 온도, 소리를 내는 음파와 같은 것입니다. 이 아날로그적인 자연 현상을 전자기기에서 의미있게 다루려면 전기적인 신호로 바꾸어야 합니다. 이 과정을 디지털화한다라고 설명합니다.

보통 센서라고 부르는 장비를 써서 아날로그적인 자연 현상을 전자기기에서 다룰 수 있는 데이터로 바꾸어야 하는데요. 여기에 DAC나 ADC가 관여합니다. DAC는 디지털에서 아날로그로 바꾸는 작업이고, ADC는 아날로그에서 디지털로 바꾸는 작업입니다.

흔히 말하는 이산 처리 과정인데요. 자연 현상을 측정한 데이터는 그래프로 보이면 연속적입니다. 주욱 이어지는 데이터의 흐름이죠. 그러나 전자기기는 처리할 수 있는 한도가 있기에 이를 변환하면 수치마다 딱딱 떨어져 있는 형태가 됩니다. 1부터 100까지로 나타난 아날로그 현상을 그래프로 그리면 특정 구간에서 보여지는 값들은 무한히 많은데요. 1부터 2까지에 1.00001, 1.00002, 1.00003, .. 1.000010, … 등으로 매우 촘촘합니다. 그러나 전자기기 내부 작동의 한도에서 이를 최대한 근사치로 변환해서 처리하는데 이를 가리켜 디지털화한다(digit-ization)이라고 하죠. 보통 정수형으로 변환한다고 설명합니다. 근사치지만, 고교시절 그래프를 그리듯이 대략적인 형태는 지속되기에 자연 상태의 데이터를 전자기기에서 다룰 수 있다고 간주하고 처리하는 것입니다.

전자기기의 작동은 기저에서 보면 두가지 작동으로 환원된다고 합니다. 전류가 인가되었음, 전류가 차단됨 이 두가지 상태입니다. 이를 0과 1 또는 1과 0 등으로 규정해서 데이터를 다루죠. 이 체제 내에서 정수도 표현하고 부동 소수도 표현합니다. 이 과정은 MCU의 비트수나 DAC, ADC의 샘플링 정확도에 의해 품질이 결정되는데요. MP3와 같이 44.1kHz, 128kbps 처럼 표시되는 것이 샘플링 정확도로, 소리를 그래프로 나타냈을때 근사치인 숫자로 변환시 얼마나 정밀한지 보는 척도입니다. 위에 말한 1부터 2까지 사이의 값들이 얼마나 촘촘한지를 의미합니다. 44.1kHz 128kbps보다 48kHz 128kbps가 음질이 더 좋다는 것도, 특정 구간의 그래프를 구성하는 숫자 샘플이 더 정밀하다는 것이구요. MCU 비트수와 DAC, ADC 회로의 성능도 결정 조건이 됩니다. 소프트웨어적인 API의 성능도 관건이구요.

이로부터 전자기기가 재현하는 온도 측정의 정확도, 소리 재생의 음질 등이 기술적으로 결정됩니다.

응용 분야는 영상 신호 처리, 음성 신호 처리, 온도 측정 등등으로 심화되죠.

최대한 전자기기가 알아볼 수 있는 근사치로 나타내면서도 원본 아날로그 값과 오차가 적게 하는 것이 디지털화 기술의 성패입니다. 이를 처리하는 것은 회로의 고도화와 처리 알고리즘의 고도화에 의지합니다.

알고 있는 사실을 요약적으로 해설해서 저보다 초보이신 분들께도 이해가 즉시되는 해설은 아니지만 ^^;; 일단 이해는 되실 것입니다. 위에 샘플된 각 수치들이 그래프로 그려져서 그래프 성분들의 복잡도가 단순화되는 것을 시각적으로 보이면 더 와닿는 해설이 되는데 그림판 열기가 싫어서 생략합니다.

라즈베리파이 피코로 구성하는 MP3 재생기도 DAC로 만듭니다. 이진화된 (디지털화된) MP3 음악파일을 읽어들여서 아날로그인 스피커 소리로 내보내는데 중요한 장치입니다.

일단 이정도로 생각난 것을 정리해두겠습니다. 요즘 생계지속용 공부하느라 공학공부는 재껴두었는데 그래도 틈틈히 라즈베리파이 피코 배우는 중입니다. 교재보다가 전에 배운 것이 생각나서 글로 썼는데 아주 대단한 글은 아니지만 일단은 개념 정리는 되었네요. 저를 위해 게시판도 따로 만들어주셔서 회원님들을 존경하고 있습니다. 열심히 하겠습니다.

C 언어의 함수 실행과 메모리에서 있는 일들 1

프로그램이 실행되면 메인 메모리에서 코드 세그먼트, 데이터 세그먼트, 스택, 빈 공간, 힙 메모리로 로드된다. 함수를 실행하면 스택에서 작동이 이루어진다. 스택은 LIFO(Last In First Out) 구조로 나중에 집어넣어진 것이 제일 먼저 빼내어지는 구조다. 이 구조가 필요한 이유는 함수 실행시 호출 순서에 따라 먼저 실행된 함수가 대기상태에 있고 나중에 실행된 함수가 먼저 실행되어야 하는 C 언어의 절차형 실행 방식 때문이다.

아래와 같은 소스코드가 실행된다고 생각해보자.

int main(void) {
    int a, b, sum;
    sum = add(a, b);
    return 0;
}

int add(int f, int s) {
    int total;
    total = f + s;
    return total;
}

모든 C 프로그램은 main()부터 실행하므로 실행직후의 스택 메모리 상태는 아래와 같다.

함수를 실행할때마다 스텍 메모리에 스택 프레임이 만들어진다. 매개변수는 함수에 넘겨진 변수로 위의 예제에서는 void가 왔으므로 아무런 매개변수가 없다. 지역 변수는 피호출 함수 내부의 변수로 a, b, sum에 해당한다. 리턴주소는 함수 실행후 실행할 바로 다음 주소다. 4바이트 명령으로 실행되는 체제라면 2036번지에 main(void)가 적재되고 끝나면 2040번지의 명령어를 실행한다. 리턴값은 예제에서는 0이다.

main() 함수에서는 add() 함수를 호출한다. 이미 main() 함수가 실행중이었다면 main() 함수 실행이 잠시 멈추고 add() 함수가 스택 메모리에 적재된다. 아래와 같이 얹혀진 것으로 그려볼 수 있다.

스택은 LIFO 구조이므로 add()의 작업이 우선 실행된다. 실행이 마쳐지면 다시 main() 함수로 돌아와 남은 라인을 실행한다.

메모리 번지 체제에서는 PC(Program Counter)에 다음에 실행할 명령어 주소가 저장되어 있을때 그 주소가 1008번지라면 현재 실행 주소는 1004번지다. 1004번지 실행할때 1016번지를 점유하는 함수를 실행한다면 PC 레지스터 값을 1016으로 바꿔야 하는데, 이 경우 그전에 스택 프레임의 리턴 주소란에 1008번지를 미리 저장해두어야 복귀후 원래 하던 일을 이어서 할 수 있다.

스택 프레임의 중요한 기능은 변수의 유효 영역의 제한이다. 보통 실행 스코프라는 말을 하는데, add()가 실행중이라면 f와 s, total에만 접근할 수 있고, main()의 a, b, sum에는 불가능하다. 어느 순서의 스택 프레임인지에 따라 사용 가능한 변수가 제한된다. 그래서 다음과 같은 구조에서 main()과 add()의 변수들은 실행되는 스코프가 다르다.

add()가 실행을 마침과 동시에 팝 되어 다시 main()이 실행된다.

스택은 함수 실행마다 늘었다 줄었다 하면서 메모리 사용을 효율적으로 관리한다. 만약 무한루프가 걸리면 스택 프레임이 무한정 쌓여서 힙 메모리 영역과 맞닿게 되어 가용 메모리가 없게 되기도 한다. 이를 스택 오버플로우라고 한다.

이 글은 주우석 선생님의 저서를 보고 요약식으로 정리하였습니다.