'초보의 아웅다웅 설계하기'에 해당되는 글 273건

  1. 2018.12.18 Wiznet W7500P Keil에서 J-link(or ST-Link) 사용하여 디버깅
  2. 2018.12.06 STM32F Sleep Mode에서 Uart로 Wakeup하기
  3. 2018.11.27 GCC 컴파일러에서 특정 영역의 바이너리 값을 고정하기 위한 방법
  4. 2018.11.13 PICkit 프로그램 증발 오류
  5. 2018.11.12 Wiznet W7500P의 추가 메모리 사용
  6. 2018.10.22 SoftUart Only TX (2)
  7. 2018.10.21 PADS - PADS에서 갑자기 키보드 단축키 및 마우스 사용이 안될 때
  8. 2018.10.16 24LC1025 데이터 Read, Write
  9. 2018.09.20 PKCS5 패딩
  10. 2018.09.01 OLED QG-2864KSWLG01 내부 펌프 초기 코드
  11. 2018.08.28 바이트 어레이의 값 확인
  12. 2018.08.28 Uart 데이터 Byte 입력상의 입력 사이즈 초기화
  13. 2018.08.17 Partial Erase Done (areas with no algorithms skipped!) 에러 발생
  14. 2018.08.17 고정위치에 바이너리 라이팅하기
  15. 2018.08.16 IAR Debugger 다운로드 설정
  16. 2018.07.27 LCD 5*8 픽셀 글자
  17. 2018.07.23 Tamper 사용
  18. 2018.07.23 다중 이동식 저장장치
  19. 2018.07.22 USB Composite
  20. 2018.07.18 error C1189: #error : MFC does not support WINVER less than 0x0501.
  21. 2018.07.16 Buzzer Melody
  22. 2018.07.15 PADS - 4Layer PCB
  23. 2018.07.06 IAR 에서 고정 영역 SRAM과 ROM 사용
  24. 2018.06.28 STM32L432 Read Protection 버그인가?
  25. 2018.06.26 STM32L4xx에서 Brownout 설정
  26. 2018.06.13 Invasive Attack (2)
  27. 2018.05.30 STM32L4 ADC Low Layer Driver (1)
  28. 2018.05.17 WWDG에서 Watchdog 발생시 클리어 처리
  29. 2018.05.12 MAXIM사의 Max3xxxx (2)
  30. 2018.04.22 Bluetooth의 시작
2018.12.18 10:36

위즈넷 W7500P MCU를 Jlink 를 사용하여 디버깅하기 위한 설정


J-Link 사용시



ST-Link 사용시


Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.12.06 00:21

STM32F091 기준으로 하였습니다.

다른 시리즈와는 라이브러리가 달라 변경이 필요합니다.


main.c 파일에서 

int main(void)

{

  HAL_Init();


  /* Configure the system clock to 48 MHz */

  SystemClock_Config();

  /* Configure LED2 */

  BSP_LED_Init(LED2);


  /*##-1- Configure the UART peripheral ######################################*/

  /* Put the USART peripheral in the Asynchronous mode (UART Mode) */

  /* UART configured as follows:

      - Word Length = 8 Bits

      - Stop Bit = One Stop bit

      - Parity = None

      - BaudRate = 9600 baud

      - Hardware flow control disabled (RTS and CTS signals) */

  UartHandle.Instance        = USARTx;


  UartHandle.Init.BaudRate   = 9600;

  UartHandle.Init.WordLength = UART_WORDLENGTH_8B;

  UartHandle.Init.StopBits   = UART_STOPBITS_1;

  UartHandle.Init.Parity     = UART_PARITY_NONE;

  UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;

  UartHandle.Init.Mode       = UART_MODE_TX_RX;

  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; 

  if(HAL_UART_DeInit(&UartHandle) != HAL_OK)

  {

    Error_Handler();

  }  

  if(HAL_UART_Init(&UartHandle) != HAL_OK)

  {

    Error_Handler();

  }

__HAL_UART_ENABLE_IT(&UartHandle, UART_IT_RXNE);


  

UART1_printf("Start\r\n");

  /* Configure User push-button in Interrupt mode */

  BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);

  

  /* Wait for User push-button press before starting the Communication.

     In the meantime, LED2 is blinking */

  while(UserButtonStatus == 0)

  {

      /* Toggle LED2*/

      BSP_LED_Toggle(LED2); 

      HAL_Delay(100);

  }

  

  BSP_LED_Off(LED2); 

  

UART1_printf("HAL_PWR_EnterSTANDBYMode");

//HAL_PWR_DisableSEVOnPend();

//HAL_PWR_DisableSleepOnExit();

//HAL_PWR_DeInit();

HAL_SuspendTick();

HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);//PWR_MAINREGULATOR_ON, PWR_LOWPOWERREGULATOR_ON

HAL_ResumeTick();

  

  /* Turn on LED2 if test passes then enter infinite loop */

  BSP_LED_On(LED2); 

  /* Infinite loop */

  while (1)

  {

UART1_printf("HAL_PWR_Wakeup");

HAL_Delay(1000);

  }

}


/**

  * @brief  System Clock Configuration

  *         The system Clock is configured as follow : 

  *            System Clock source            = PLL (HSI48)

  *            SYSCLK(Hz)                     = 48000000

  *            HCLK(Hz)                       = 48000000

  *            AHB Prescaler                  = 1

  *            APB1 Prescaler                 = 1

  *            HSI Frequency(Hz)              = 48000000

  *            PREDIV                         = 2

  *            PLLMUL                         = 2

  *            Flash Latency(WS)              = 1

  * @param  None

  * @retval None

  */

void SystemClock_Config(void)

{

  RCC_ClkInitTypeDef RCC_ClkInitStruct;

  RCC_OscInitTypeDef RCC_OscInitStruct;

  

  /* Select HSI48 Oscillator as PLL source */

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI48;

  RCC_OscInitStruct.HSI48State = RCC_HSI48_ON;

  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;

  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI48;

  RCC_OscInitStruct.PLL.PREDIV = RCC_PREDIV_DIV2;

  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL2;

  if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)

  {

    /* Initialization Error */

    while(1); 

  }


  /* Select PLL as system clock source and configure the HCLK and PCLK1 clocks dividers */

  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1);

  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1)!= HAL_OK)

  {

    /* Initialization Error */

    while(1); 

  }

}


stm32f0xx_it.c 파일에서

extern void UART1_PutChar(char data);

void USARTx_IRQHandler(void)

{

uint8_t ch;

// HAL_UART_IRQHandler(&UartHandle); // HAL 드라이버가 제공하는 IRQ 핸들러

if ((__HAL_UART_GET_FLAG(&UartHandle, UART_FLAG_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&UartHandle, UART_IT_RXNE) != RESET)) { 

ch = 0x41;

UART1_PutChar(ch);

}

__HAL_UART_CLEAR_IT(&UartHandle, UART_CLEAR_PEF);

__HAL_UART_CLEAR_IT(&UartHandle, UART_FLAG_RXNE);

/* Disable the UART Parity Error Interrupt and RXNE interrupt*/

CLEAR_BIT(UartHandle.Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));

/* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */

CLEAR_BIT(UartHandle.Instance->CR3, USART_CR3_EIE);

}


stm32f0xx_hal_msp.c 파일에서

void HAL_UART_MspInit(UART_HandleTypeDef *huart)

{  

  GPIO_InitTypeDef  GPIO_InitStruct;

  

  /*##-1- Enable peripherals and GPIO Clocks #################################*/

  /* Enable GPIO TX/RX clock */

  USARTx_TX_GPIO_CLK_ENABLE();

  USARTx_RX_GPIO_CLK_ENABLE();



  /* Enable USARTx clock */

  USARTx_CLK_ENABLE(); 

  

  /*##-2- Configure peripheral GPIO ##########################################*/  

  /* UART TX GPIO pin configuration  */

  GPIO_InitStruct.Pin       = USARTx_TX_PIN;

  GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;

  GPIO_InitStruct.Pull      = GPIO_PULLUP;

  GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;

  GPIO_InitStruct.Alternate = USARTx_TX_AF;


  HAL_GPIO_Init(USARTx_TX_GPIO_PORT, &GPIO_InitStruct);


  /* UART RX GPIO pin configuration  */

  GPIO_InitStruct.Pin = USARTx_RX_PIN;

  GPIO_InitStruct.Alternate = USARTx_RX_AF;


  HAL_GPIO_Init(USARTx_RX_GPIO_PORT, &GPIO_InitStruct);

    

  /*##-3- Configure the NVIC for UART ########################################*/

  /* NVIC for USART */

  HAL_NVIC_SetPriority(USARTx_IRQn, 0, 0);

  HAL_NVIC_EnableIRQ(USARTx_IRQn);

}


/**

  * @brief UART MSP De-Initialization 

  *        This function frees the hardware resources used in this example:

  *          - Disable the Peripheral's clock

  *          - Revert GPIO and NVIC configuration to their default state

  * @param huart: UART handle pointer

  * @retval None

  */

void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)

{

  /*##-1- Reset peripherals ##################################################*/

  USARTx_FORCE_RESET();

  USARTx_RELEASE_RESET();


  /*##-2- Disable peripherals and GPIO Clocks #################################*/

  /* Configure UART Tx as alternate function  */

  HAL_GPIO_DeInit(USARTx_TX_GPIO_PORT, USARTx_TX_PIN);

  /* Configure UART Rx as alternate function  */

  HAL_GPIO_DeInit(USARTx_RX_GPIO_PORT, USARTx_RX_PIN);

  

  /*##-3- Disable the NVIC for UART ##########################################*/

  HAL_NVIC_DisableIRQ(USARTx_IRQn);

}



Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.11.27 17:23

GCC 컴파일러에서 특정 영역의 바이너리 값을 고정하기 위한 방법


main.c

/* 32Byte 데이터를 0으로 고정 */

unsigned char Blank_buffer[0x20] __attribute__ ((section(".init_array"))) = {0, };


app.linker

OUTPUT_ARCH(arm)

SECTIONS
{
    . = (0x00);
/* main.c에서 고정한 데이터의 위치 설정 */
    .init_array : {
    }

    /* text start */
    . = (0x20);
    .text : ... 중략

    /* data start */
    . = (0x20000000);
    .data : ... 중략
}




Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.11.13 21:58

Microchip사의 PICKIT에 대해 놀랄만한 이야기를 들었습니다.

귀를 씻고 들어도 진실인지 이해가 되지 않습니다.


모社의 제품이 필드에 나가서 동작을 하는데 PIC의 프로그램이 모두 증발하는 증상이 일어났다고 합니다.

업체에서 문의를 하는데 제품 라이팅시 PICKIT를 사용하여 라이팅을 하면 문제가 발생할 수 있다고 이야기 했다고 합니다.

사용중인 제품이?? 필드에 나가서 동작을 한참 잘하다가 프로그램이 다 날아갔는데 라이팅기 영향이다?

MICROCHIP사에서 그것도 공식홈에서 파는 제품이?(설사 그런 문제가 있다면 판매하는 것 자체가 문제 아닌가 싶네요. 좌충수도 이런 자충수를 두다니 본인들 스스로 문제 있는 제품이지만 판매하겠다. 라고 말하는건데요.)

이해가 되지 않습니다. 차라리 사용자가 뭔가 다른 행위를 한 것 같다가 더 나은 해명 같은데요.


Note: The PICkit 3 In-Circuit Debugger/Programmer is NOT a production programmer. It should be used for development purposes only. 

(프로그램이 삭제되는 부분에 대한 해명 부분이 이건가??????)


그런 해명을 하는 게 대리점의 답변이라면 MICROCHIP사의 제품을 절대로 사용하지 말아야 할 것 같습니다.(자료도 많은 ST나 TI 쓰는게 더 이득 거기다 ST는 공식홈에 문의하면 1, 2일 사이에 답변을 달아주고 한글로 문의해도 한글로 답을 주는데 핵이득) 


8bit 마이컴을 사용할 때 PIC시리즈만을 사용했던 저로써는 안타까울 따름이네요.

호주 기차사고 났을 때 다 타고 문제가 되어도 PIC만은 이상이 없었다 등의 제품이 매우 물리적으로 강하다고 홍보해왔었는데 아쉽네요.


솔직히 제 생각으로는 칩버그나 프로그램 버그가 아닐까 싶은데요. 속닥속닥 그냥 속마음입니다. 저도 8비트 마이컴을 PIC 로 시작했고, 주변에 아직도 쓰시는 엔지니어분들이 계시는 데 그런 이야기는 처음 들어본다네요. 속닥속닥 한때 PIC의 홍보 대사였는데... 창피하다 마이크로칩 


'초보의 아웅다웅 설계하기 > PIC32MX' 카테고리의 다른 글

PICkit 프로그램 증발 오류  (0) 2018.11.13
Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.11.12 23:08

이더넷 칩으로 유명한 위즈넷에서 W7500/W7500P에서 보면 최고 48KB까지 SRAM을 사용할 수 있다고 나와있습니다.

SDK를 보면 0x20000000에서 16KB(0x4000)까지 밖에 사용할 수 없는데요.

사용할 수 있는 방법을 찾아보면 Socket 버퍼를 메모리로 사용하는 방법입니다.(신박하네요.)

데이터 시트상에서보면 가상 주소에 물리주소가 겹쳐있는 형태로 되어 있는데 가상 주소가 실제 물리주소보다 크다보니 가상 주소 영역을 넘어가면 물리주소의 0번지부터 되돌아가는 형태로 되어있습니다.

0x461E0000부터 0x461EFFFF까지 잡는다고 해도 실제로는 2KB(0x800)까지밖에 사용하지 못하게 됩니다.

그래도 최대 4KB까지 사용할 수 있는 방법이 있는데요 Socket의 TX와 RX 사이를 겹쳐 잡는 겁니다.

다만 그렇게 되면 사용한 버퍼를 사용하는 소켓은 사용하지 못하게 됩니다.


예제)

START ADDRESS : 0x461EF800 SIZE : 0x1000  => Socket 7

START ADDRESS : 0x4612F800 SIZE : 0x1000  => Socket 6

START ADDRESS : 0x4616F800 SIZE : 0x1000  => Socket 5

START ADDRESS : 0x461AF800 SIZE : 0x1000  => Socket 4

...(3,2,1,0 도 동일하게)


Keil, ds5 등에서는 Scatter 파일 IAR에서는 icf 파일에서 설정해주면 됩니다.


(https://wizwiki.net/wiki/lib/exe/fetch.php?media=:products:w7500:w7500x_rm_v112_20181017_.pdf) 68Page


SDK를 보면서 ST 마이크로사의 STDLIB와 많이 유사한 패턴이 보이네요. 많이 사용하던 칩이라 그런지 눈에 잘 들어와서 좋네요. ㅎㅎ


Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.10.22 13:07

참고 사이트 : 

https://github.com/blalor/avr-softuart


위 사이트에 나와있는 소스코드를 STM32F103에서 동작하도록 변경

9600bps에 맞췄습니다만 본인이 사용하는 클럭 설정이나 다른 코어라면 코어의 처리 속도등을 고려해서 Timer의 발생 시간을 조절해주어야 합니다. 

계산해보면 1/9600 = 0.00010416... 이므로 오차율 감안하고 104us정도 나오도록 오실로스코프로 계산하면서 맞춰주면 될 것 같습니다.

softuart.c



##include <stdarg.h>

#include <stdio.h>


#define SU_TRUE    1

#define SU_FALSE   0



// 1 Startbit, 8 Databits, 1 Stopbit = 10 Bits/Frame

#define TX_NUM_OF_BITS (10)

volatile static unsigned char  flag_tx_busy;

volatile static unsigned char  timer_tx_ctr;

volatile static unsigned char  bits_left_in_tx;

volatile static unsigned short internal_tx_buffer; /* ! mt: was type uchar - this was wrong */


#define UARTTXPORT GPIOA

#define UARTTXPIN GPIO_Pin_9


#define set_tx_pin_high()      GPIO_SetBits(UARTTXPORT, UARTTXPIN)

#define set_tx_pin_low()       GPIO_ResetBits(UARTTXPORT, UARTTXPIN)



extern void TIM2_IRQHandler(void);

void TIM2_IRQHandler(void) 

{

  if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)

  {

    TIM_ClearITPendingBit(TIM2, TIM_IT_Update);

Tim2_IRQ();

  }

}


void Tim2_IRQ(void)

{

unsigned char tmp;

// Transmitter Section

if ( flag_tx_busy == SU_TRUE ) {

tmp = timer_tx_ctr;

if ( --tmp == 0 ) { // if ( --timer_tx_ctr <= 0 )

if ( internal_tx_buffer & 0x01 ) {

set_tx_pin_high();

}

else {

set_tx_pin_low();

}

internal_tx_buffer >>= 1;

tmp = 3; // timer_tx_ctr = 3;

if ( --bits_left_in_tx == 0 ) {

flag_tx_busy = SU_FALSE;

}

}

timer_tx_ctr = tmp;

}

}


void gpio_init(void)

{

GPIO_InitTypeDef GPIO_InitStruct;


/* Enable the GPIO_LED clock */

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);


set_tx_pin_high(); /* mt: set to high to avoid garbage on init */


/* Configure Led pin as output */

GPIO_InitStruct.GPIO_Pin = UARTTXPIN;

GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;

GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init(UARTTXPORT, &GPIO_InitStruct);

flag_tx_busy  = SU_FALSE;

}


void timer_init(void)

{

TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;

NVIC_InitTypeDef NVIC_InitStructure;

RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);


/* Time base configuration */

TIM_TimeBaseStructure.TIM_Period = 70 - 1;  // 

TIM_TimeBaseStructure.TIM_Prescaler = 35; // Timer/Count2 Clock = 36Mhz / (35 + 1) = 1Mhz = 1 usec

TIM_TimeBaseStructure.TIM_ClockDivision = 0;

TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // Ä«¿îÅ͸ðµåµ¿ÀÛ

TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);


/* TIM2 counter enable */

TIM_Cmd(TIM2, ENABLE);


/* TIM IT enable */

TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);


/* Enable the TIM2 gloabal Interrupt */

NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

NVIC_Init(&NVIC_InitStructure);

}



void softuart_init( void )

{

gpio_init();

/* 9600bps Setting */

timer_init();

}


unsigned char softuart_transmit_busy( void ) 

{

return ( flag_tx_busy == SU_TRUE ) ? 1 : 0;

}


void softuart_putchar( const char ch )

{

while ( flag_tx_busy == SU_TRUE ) {

; // wait for transmitter ready

  // add watchdog-reset here if needed;

}


// invoke_UART_transmit

timer_tx_ctr       = 3;

bits_left_in_tx    = TX_NUM_OF_BITS;

internal_tx_buffer = ( ch << 1 ) | 0x200;

flag_tx_busy       = SU_TRUE;

}

void softuart_puts( const char *s )

{

while ( *s ) {

softuart_putchar( *s++ );

}

}


void softuart_puts_P(char *string)

{

while(*string != '\0') softuart_putchar(*(string++));

}


void softuart_print(const char *fmt,...)

{

char string[256];

va_list ap;


va_start(ap,fmt);

vsprintf(string,fmt,ap);

va_end(ap);


softuart_puts_P(string);

}



void main(void)

{

softuart_init();

softuart_print("\r\nSoftuart Demo-Application Start \r\n");

}



Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

  1. uocraft 2018.11.10 15:59 신고  댓글주소  수정/삭제  댓글쓰기

    울온 관련 포스팅 좀...

2018.10.21 01:26

설정을 모두 리셋해주면 됩니다.




Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.10.16 09:05


int main(void)

{

 I2C_PortInit();


/* 초기 쓰레기값 읽어주기 */

     AT24LCXX_Init();

for(uint32_t i=0; i<260; i++){

tAT24CXX(i);

}

}





/* Includes ------------------------------------------------------------------*/

#include "stm32f10x.h"

#include "usr_softI2C.h"

#include "usr_uart.h"

#include "string.h"


/* Defines -------------------------------------------------------------------*/

#define I2C_PORT GPIOB

#define I2C_SCL GPIO_Pin_6          

#define I2C_SDA GPIO_Pin_7         


#define AT24CXX_BLOCKA_ADDR   0xA0//1010 0000

#define AT24CXX_BLOCKB_ADDR   0xA8//1010 1000


/*******************************************************************************

* Function Name : 

* Description   : 

* Parameters    : None

* Return        : None

*******************************************************************************/

void I2C_PortInit(void)

{

    /* I2C1 Periph clock enable */

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);


    GPIO_InitTypeDef  GPIO_InitStructure;


    /* Configure I2C1 pins: SCL and SDA */

    GPIO_InitStructure.GPIO_Pin =  I2C_SCL | I2C_SDA;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;

    GPIO_Init(I2C_PORT, &GPIO_InitStructure);

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void I2C_WRITE(unsigned char dat)

{

u8 bit_cnt, tmp;

u8 bit_value;


for(bit_cnt=0; bit_cnt<8; bit_cnt++)

{

tmp = (dat << bit_cnt) & 0x80;

bit_value = (tmp >> 7) & 0x01;


if(bit_value == 1)

GPIO_SetBits(I2C_PORT,I2C_SDA);

else

GPIO_ResetBits(I2C_PORT,I2C_SDA);

delay_us(5);

GPIO_SetBits(I2C_PORT,I2C_SCL);

delay_us(5);

GPIO_ResetBits(I2C_PORT,I2C_SCL);

delay_us(5);

}

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void I2C_START(void)

{

GPIO_SetBits(I2C_PORT,I2C_SCL);//SCL=1;

delay_us(5);

GPIO_SetBits(I2C_PORT,I2C_SDA);//SDA=1;

delay_us(5);

GPIO_ResetBits(I2C_PORT,I2C_SDA);//SDA=0;

delay_us(5);

GPIO_ResetBits(I2C_PORT,I2C_SCL);//SCL=0;

delay_us(5);

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void I2C_STOP(void)

{

GPIO_ResetBits(I2C_PORT,I2C_SDA);

delay_us(5);

GPIO_SetBits(I2C_PORT,I2C_SCL);

delay_us(5);

GPIO_SetBits(I2C_PORT,I2C_SDA);

delay_us(7);

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void I2C_SEND_ACK(u8 bit_value)

{

if(bit_value == 1)

GPIO_SetBits(I2C_PORT,I2C_SDA);

else

GPIO_ResetBits(I2C_PORT,I2C_SDA);


delay_us(5);

GPIO_SetBits(I2C_PORT,I2C_SCL);

delay_us(5);

GPIO_ResetBits(I2C_PORT,I2C_SCL);

delay_us(5);

GPIO_SetBits(I2C_PORT,I2C_SDA);

delay_us(5);

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

uint8_t I2C_READ(void)

{

uint8_t i_byte, n;


GPIO_SetBits(I2C_PORT,I2C_SDA);

delay_us(5);


GPIO_InitTypeDef  GPIO_InitStructure;


/* Configure I2C1 pins: SCL and SDA */

GPIO_InitStructure.GPIO_Pin =  I2C_SDA;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;

GPIO_Init(I2C_PORT, &GPIO_InitStructure);


for(n=0; n<8; n++)

{

GPIO_SetBits(I2C_PORT,I2C_SCL);

delay_us(5);


if (GPIO_ReadInputDataBit(I2C_PORT,I2C_SDA)){

i_byte = (i_byte << 1) | 0x01; // msbit first

}

else{

i_byte = i_byte << 1;

}

GPIO_ResetBits(I2C_PORT,I2C_SCL);

delay_us(5);

}


/* Configure I2C1 pins: SCL and SDA */

GPIO_InitStructure.GPIO_Pin =  I2C_SDA;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;

GPIO_Init(I2C_PORT, &GPIO_InitStructure);


return(i_byte);

}


/*******************************************************************************

* Function Name : 

* Description   : 

* Parameters    : None

* Return        : None

*******************************************************************************/

void AT24CXX_Write(uint8_t Address, uint16_t addr, uint8_t* pBuffer,  uint16_t NumByteToWrite)

{

uint16_t unNum = 0;

for(uint8_t i=0; i <= NumByteToWrite/128; i++)

{

I2C_START();

I2C_WRITE(Address);

I2C_SEND_ACK(0);

I2C_WRITE((addr >> 8) & 0xff); // high byte of memory address

I2C_SEND_ACK(0);

I2C_WRITE(addr & 0xff); // low byte of mem address

I2C_SEND_ACK(0);

if(i < NumByteToWrite/128){

unNum = 128;

}

else{

unNum = NumByteToWrite%128;

}

/* While there is data to be written */

while(unNum--){

/* Send the current byte */

I2C_WRITE(*pBuffer);

/* Point to the next byte to be written */

pBuffer++;

I2C_SEND_ACK(0);

}

I2C_STOP();

addr += 128;


delay_ms(20);

}

}


/*******************************************************************************

* Function Name : 

* Description   : 

* Parameters    : None

* Return        : None

*******************************************************************************/

void AT24CXX_Read(uint8_t Address, uint16_t addr, uint8_t* pBuffer,  uint16_t NumByteToWrite)

{

I2C_START();

I2C_WRITE(Address);

I2C_SEND_ACK(0);

I2C_WRITE((addr >> 8) & 0xff);

I2C_SEND_ACK(0);

I2C_WRITE(addr & 0xff);

I2C_SEND_ACK(0);


I2C_START();

I2C_WRITE(Address | (1 << 0));

I2C_SEND_ACK(0);

 

while(NumByteToWrite--)

{

*pBuffer = I2C_READ();

pBuffer++;

if(NumByteToWrite){

I2C_SEND_ACK(0);

}

else{

I2C_SEND_ACK(1);

}

}

I2C_STOP();

}



/*******************************************************************************

* Function Name : 

* Description   : 

* Parameters    : None

* Return        : None

*******************************************************************************/

void AT24LCXX_1ByteWrite(uint8_t dev_adr, uint16_t mem_adr, uint8_t a_chDat)

{

I2C_START();

I2C_WRITE(AT24CXX_BLOCKA_ADDR | (dev_adr << 1));

I2C_SEND_ACK(0);

I2C_WRITE((mem_adr >> 8) & 0xff); // high byte of memory address

I2C_SEND_ACK(0);

I2C_WRITE(mem_adr & 0xff); // low byte of mem address

I2C_SEND_ACK(0);

I2C_WRITE(a_chDat); // and finally the data

I2C_SEND_ACK(0);

I2C_STOP();


delay_ms(25); // allow for the programming of the eeprom

}


/*******************************************************************************

* Function Name : 

* Description   : 

* Parameters    : None

* Return        : None

*******************************************************************************/

uint8_t AT24LCXX_1ByteRead(uint8_t dev_adr, uint16_t mem_adr)

{

uint8_t Dat;


I2C_START();

I2C_WRITE(AT24CXX_BLOCKA_ADDR | (dev_adr << 1));

I2C_SEND_ACK(0);

I2C_WRITE((mem_adr >> 8) & 0xff);

I2C_SEND_ACK(0);

I2C_WRITE(mem_adr & 0xff);

I2C_SEND_ACK(0);


I2C_START(); // no intermediate stop

I2C_WRITE(0xa1 | (dev_adr << 1)); // read operation

I2C_SEND_ACK(0);

Dat = I2C_READ();

I2C_SEND_ACK(1);

I2C_STOP();


return Dat;

}


/*******************************************************************************

* Function Name : 

* Description   : 

* Parameters    : None

* Return        : None

*******************************************************************************/

uint8_t AT24LCXX_Init(void)

{

uint8_t ch;

/* Dummy */

ch = AT24LCXX_1ByteRead(0x00, 0x00);

return ch;

}


/*******************************************************************************

* Function Name : 

* Description   : 

* Parameters    : None

* Return        : None

*******************************************************************************/

void tAT24CXX(uint32_t addr)

{

uint32_t mem_adr;

uint8_t dat[512], ch;

uint16_t n;

mem_adr = addr *512;

UART2_printf("addr %d, mem_adr %d \r\n", addr, mem_adr);

memset(dat, 0, sizeof(dat));

if(mem_adr < 0xFFFF){

AT24CXX_Read(AT24CXX_BLOCKA_ADDR, mem_adr, dat, 512);

}

else{

AT24CXX_Read(AT24CXX_BLOCKB_ADDR, mem_adr, dat, 512);

}

printData("dat b", dat, 512);


if(dat[0] != 0x32)

{

dat[0] = 0x32;

dat[1] = (addr >> 8) & 0xff;

dat[2] = (addr & 0xff);

UART2_printf("dat[1] %d, dat[2] %d \r\n", dat[1], dat[2]);

for(n=3; n<512; n++){

dat[n] = (uint8_t)(n%255);

}

if(mem_adr < 0xFFFF){

AT24CXX_Write(AT24CXX_BLOCKA_ADDR, mem_adr, dat, 512);

}

else{

AT24CXX_Write(AT24CXX_BLOCKB_ADDR, mem_adr, dat, 512);

}

printData("dat f", dat, 512);

}

delay_ms(1000);

}



/*******************************************************************************

* Function Name : 

* Description   : 

* Parameters    : None

* Return        : None

*******************************************************************************/

void tAT24CXX_1Byte(void)

{

long mem_adr;

uint8_t dat[512];

uint16_t n;


AT24LCXX_Init();

mem_adr=0x0000;

UART2_printf("dat b\r\n");

for(n=0; n<512; n++)

{

dat[n] = AT24LCXX_1ByteRead(0x00, mem_adr);

UART2_printf("%x", dat[n]);

++mem_adr;

}

UART2_printf("\r\n");

if(dat[0] != 0x31)

{

UART2_printf("dat f\r\n");

mem_adr=0x0000;

dat[0] = 0x31;

AT24LCXX_1ByteWrite(0x00, mem_adr, dat[0]);

mem_adr=0x0001;

for(n=1; n<512; n++)

{

dat[n] = (uint8_t)(n%255);

UART2_printf("%x", dat[n]);

AT24LCXX_1ByteWrite(0x00, mem_adr, dat[n]);

++mem_adr;

}

UART2_printf("\r\n");

UART2_printf("Write\r\n");

}


delay_ms(1500);

}



Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.09.20 15:04

암호 블록의 최소화 단위가 있는 경우 패딩 

PKCS5 Padding의 경우 잔여 배열에 남은 길이만큼을 적어 넣음.


key[16] = {0, };

in[16] = {0, };

ans[16] = {0, };



/* PKCS5Padding */

for(loop=0; loop<16; loop++){

in[loop]= 13;

}

key[0]=0x9D; key[1]=0x27; key[2]=0x35; key[3]=0x0C; key[4]=0xEC; key[5]=0xD0; key[6]=0x80; key[7]=0x37; key[8]=0xC2; key[9]=0xF6; key[10]=0xD8; key[11]=0x01; key[12]=0x83; key[13]=0x16; key[14]=0x7F; key[15]=0xEC; 


  /* in[16] = 0x61, 0x62, 0x63, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D... */

in[0]='a'; in[1]='b'; in[2]='c';


  /* Aria128 ECB Mode 에서의 결과값 */

ans[0]=0x6E;ans[1]=0x95;ans[2]=0x4D;ans[3]=0xE1;ans[4]=0xEE;ans[5]=0xC7;ans[6]=0xA8;ans[7]=0xC8;ans[8]=0xF7;ans[9]=0xB4;ans[10]=0x92;ans[11]=0xE2;ans[12]=0x41;ans[13]=0xC5;ans[14]=0xC0;ans[15]=0x38;





'초보의 아웅다웅 설계하기 > 암호' 카테고리의 다른 글

PKCS5 패딩  (0) 2018.09.20
Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.09.01 21:04

OLED QG-2864KSWLG01를 구해서 프로그램을 넣었습니다.

웹에 도는 소스코드와 데이터시트로 구현을 하여도 동작을 하지 않았습니다.

명령어를 넣을 때 데이터 시트와 웹에서는 0x80을 실제로는 0x00을 넣어야했습니다.

그리고 ACK 자리에도 데이터 시트와 웹에서는 1을 실제로는 0을 넣어야 했습니다.

아래 샘플코드입니다.

I2C가 패리패럴로 구현되지 않고 IO로 구현되어있습니다.

RES는 회로상에서 NPN TR로 ON/OFF 해서 High와 Low가 역으로 되어있습니다.



#define OLED_ADDRESS 0x78


#define I2C_PORT GPIOB

#define I2C_SCL GPIO_Pin_6         

#define I2C_SDA GPIO_Pin_7   

#define LCDRSTPORT GPIOE

#define LCDRSTPIN GPIO_Pin_2

#define LCDENPORT GPIOB

#define LCDENPIN GPIO_Pin_5



/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

static void OLED_RES(FunctionalState NewState)

{

  if (NewState == DISABLE){

    GPIO_SetBits(LCDRSTPORT, LCDRSTPIN);

  }

  else{

    GPIO_ResetBits(LCDRSTPORT, LCDRSTPIN);

  }

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void OLED_EN(FunctionalState NewState)

{

  if (NewState == DISABLE){

    GPIO_ResetBits(LCDENPORT, LCDENPIN);

  }

  else{

    GPIO_SetBits(LCDENPORT, LCDENPIN);

  }

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void OLED_SDA(FunctionalState NewState)

{

  if (NewState == DISABLE){

    GPIO_ResetBits(I2C_PORT, I2C_SDA);

  }

  else{

    GPIO_SetBits(I2C_PORT, I2C_SDA);

  }

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void OLED_SCL(FunctionalState NewState)

{

  if (NewState == DISABLE){

    GPIO_ResetBits(I2C_PORT, I2C_SCL);

  }

  else{

    GPIO_SetBits(I2C_PORT, I2C_SCL);

  }

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void OLED_Config(void)

GPIO_InitTypeDef GPIO_InitStructure;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);


OLED_RES(DISABLE);

OLED_EN(DISABLE);

GPIO_SetBits(I2C_PORT,I2C_SDA);

GPIO_SetBits(I2C_PORT,I2C_SCL);

/* LCD SDA/SCL */

GPIO_InitStructure.GPIO_Pin = I2C_SCL | I2C_SDA;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init(I2C_PORT, &GPIO_InitStructure);  

/* LCD EN */

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init(GPIOB, &GPIO_InitStructure);  


/* LCD RST */

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init(GPIOE, &GPIO_InitStructure);  

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void I2C_WRITE(unsigned char dat)

{

u8 bit_cnt, tmp;

u8 bit_value;


for(bit_cnt=0; bit_cnt<8; bit_cnt++)

{

tmp = (dat << bit_cnt) & 0x80;

bit_value = (tmp >> 7) & 0x01;


if(bit_value == 1)

GPIO_SetBits(I2C_PORT,I2C_SDA);

else

GPIO_ResetBits(I2C_PORT,I2C_SDA);

delay_us(3);

GPIO_SetBits(I2C_PORT,I2C_SCL);

delay_us(3);

GPIO_ResetBits(I2C_PORT,I2C_SCL);

delay_us(3);

}

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void I2C_Start(void)

{

GPIO_SetBits(I2C_PORT,I2C_SCL);//SCL=1;

delay_us(3);

GPIO_SetBits(I2C_PORT,I2C_SDA);//SDA=1;

delay_us(3);

GPIO_ResetBits(I2C_PORT,I2C_SDA);//SDA=0;

delay_us(3);

GPIO_ResetBits(I2C_PORT,I2C_SCL);//SCL=0;

delay_us(3);

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void I2C_Stop(void)

{

GPIO_ResetBits(I2C_PORT,I2C_SDA);

delay_us(3);

GPIO_SetBits(I2C_PORT,I2C_SCL);

delay_us(3);

GPIO_SetBits(I2C_PORT,I2C_SDA);

delay_us(5);

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void I2C_Ack(u8 bit_value)

{

if(bit_value == 1)

GPIO_SetBits(I2C_PORT,I2C_SDA);

else

GPIO_ResetBits(I2C_PORT,I2C_SDA);


delay_us(3);

GPIO_SetBits(I2C_PORT,I2C_SCL);

delay_us(3);

GPIO_ResetBits(I2C_PORT,I2C_SCL);

delay_us(3);

GPIO_SetBits(I2C_PORT,I2C_SDA);

delay_us(3);

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void write_i(unsigned char ins)

{

I2C_Start();

I2C_WRITE(OLED_ADDRESS);

I2C_Ack(0);

I2C_WRITE(0x00);

I2C_Ack(0);

I2C_WRITE(ins);

I2C_Ack(0);

I2C_Stop();

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void write_d(unsigned char dat)

{

I2C_Start();

I2C_WRITE(OLED_ADDRESS);

I2C_Ack(0);

I2C_WRITE(0x40);

I2C_Ack(0);

I2C_WRITE(dat);

I2C_Ack(0);

I2C_Stop();

}          


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void OLED_Init_InternalPump(void)

{

OLED_EN(ENABLE);

delay_us(1000);


OLED_RES(ENABLE);////RES=1;  

delay_us(1000);

OLED_RES(DISABLE);//RES=0;   

delay_us(1000);      

OLED_RES(ENABLE);////RES=1;

delay_us(1000);


write_i(0xAE);    /*display off*/       


write_i(0x02);    /*set lower column address*/       

write_i(0x10);    /*set higher column address*/


write_i(0x40);    /*set display start line*/


write_i(0xB0);    /*set page address*/


write_i(0x81);    /*contract control*/

write_i(0x80);    /*128*/


write_i(0xA1);    /*set segment remap*/


write_i(0xA6);    /*normal / reverse*/


write_i(0xA8);    /*multiplex ratio*/

write_i(0x3F);    /*duty = 1/64*/


write_i(0xad);    /*set charge pump enable*/

write_i(0x8b);     /*    0x8B    ??VCC   */


write_i(0x33);    /*0X30---0X33  set VPP   9V */


write_i(0xC8);    /*Com scan direction*/


write_i(0xD3);    /*set display offset*/

write_i(0x00);   /*   0x20  */


write_i(0xD5);    /*set osc division*/

write_i(0x80);    


write_i(0xD9);    /*set pre-charge period*/

write_i(0x1f);    /*0x22*/


write_i(0xDA);    /*set COM pins*/

write_i(0x12);


write_i(0xdb);    /*set vcomh*/

write_i(0x30);           


Fill_RAM(0x00); // Clear Screen

write_i(0xAF);    /*display ON*/    

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void main(void)

{

OLED_Config();

OLED_Init_InternalPump();


}

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.08.28 08:54

C#에서 입력된 바이트 어레이의 메모리 값 확인


속성에서 안전하기 않은 코드 허용에 체크를 하고 아래와 같이 설정을 하면 볼 수 있습니다.








Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.08.28 08:52

C#에서 입력 Uart 처리 

입력 사이즈를 확인하였던 intRecSize를 초기화해 주지 않으니 0x00의 비어있는 값이 버퍼에 쌓이는 경우가 있었습니다.



      private void ComPort_DataReceived(object sender, SerialDataReceivedEventArgs e)

        {

            if (rbAscii.Checked == true)

            {

                InputData = ComPort.ReadExisting();

                if (InputData != String.Empty)

                {

                    this.BeginInvoke(new SetTextCallback(SetText), new object[] { InputData });

                }

            }

            else

            {

  /* 입력된 데이터 량 */

                int intRecSize = ComPort.BytesToRead;


                while (intRecSize != 0)

                {

                    TimerCnt = 0;

                    byte[] buff = new byte[intRecSize];


                    ComPort.Read(buff, 0, intRecSize); 

                    

                    /* 입력된 데이터 처리 */



 intRecSize = 0;        

 }

   }

}

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.08.17 15:16

Keil 컴파일러를 사용하여 다운로드할 때 발생하는 에러 처리 방법


다운로드할 칩의 메모리 사이즈가 맞지 않을 경우 발생


Load "STM32F401xx\\STM32F401xx.axf" 

No Algorithm found for: 0806E000H - 0806FFFFH

No Algorithm found for: 08070000H - 0807FFF3H

Partial Erase Done (areas with no algorithms skipped!)

No Algorithm found for: 0806E000H - 0806FFFFH

No Algorithm found for: 08070000H - 0807FFF3H

Partial Programming Done (areas with no algorithms skipped!)

Partial Verify OK (areas with no algorithms skipped!)

Application running ...




Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.08.17 13:06


Keil에서 고정 위치에 바이너리 라이팅하기 

const unsigned char FixedROM[65520UL + 1] __attribute__((at(0x08010000))) = {0x00, };



IAR에서 고정위치에 바이너리 라이팅하기
#pragma location = 0x08010000
__root const unsigned char FixedROM[65520UL + 1] = {0x00, };


0x08010000는 위치하고 싶은 주소 



Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.08.16 14:56


Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.07.27 23:42

LCD 이미지 5*8 픽셀의 글자입니다.

LCD 컨트롤러에 따라 한번에 2픽셀씩 표현하는 경우에는 고민해서 적용하셔야할 것 같습니다.


이미지.xlsx



SSD1325 텍스트 작업 파일입니다.

SSD1325.xlsx


'초보의 아웅다웅 설계하기 > STM32' 카테고리의 다른 글

고정위치에 바이너리 라이팅하기  (0) 2018.08.17
IAR Debugger 다운로드 설정  (0) 2018.08.16
LCD 5*8 픽셀 글자  (0) 2018.07.27
Tamper 사용  (0) 2018.07.23
다중 이동식 저장장치  (0) 2018.07.23
USB Composite  (0) 2018.07.22
Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.07.23 15:28

내부 백업레지스터의 정보를 제거하는 용도로 사용하는 TAMPER 패리패럴을 설정하고 사용하는 방법입니다.

주요 정보를 저장해두고 유사시에 제거하는 용도로 사용하도록 설정하여 사용하면 될 것 같습니다.

TAMPER 핀은 PULL-DOWN해두고 유사시에 TAMPER 핀에 HIGH 신호를 주는 설정으로 하였습니다. 

전원 OFF 시에 전원이 TAMPER 핀으로 들어가지 않게 하기 위함이었습니다.



/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

void BackupRegister_Init(void)

{

NVIC_InitTypeDef NVIC_InitStructure;

/* Enable PWR and BKP clock */

RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);


/* Enable write access to Backup domain */

PWR_BackupAccessCmd(ENABLE);


/* Clear Tamper pin Event(TE) pending flag */

BKP_ClearFlag();


/* Enable Tamper pin */

BKP_TamperPinCmd(ENABLE);

/* Tamper pin active on low level */

BKP_TamperPinLevelConfig(BKP_TamperPinLevel_High);//BKP_TamperPinLevel_Low


/* Enable Tamper interrupt */

BKP_ITConfig(ENABLE);


  /* Enable TAMPER IRQChannel */

  NVIC_InitStructure.NVIC_IRQChannel = TAMPER_IRQn;

  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

  NVIC_Init(&NVIC_InitStructure);

  

UART1_printf("\r\n\n%X", BKP_ReadBackupRegister(BKP_DR1));

if (BKP_ReadBackupRegister(BKP_DR1) != 0xAAAA)

  {

    /* Backup data register value is not correct or not yet programmed (when

       the first time the program is executed) */


BKP_WriteBackupRegister(BKP_DR1, 0xAAAA);

UART1_printf("\r\n\n Write %X", BKP_ReadBackupRegister(BKP_DR1));

  }

  else

  {

    /* Check if the Power On Reset flag is set */

    if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET){

      UART1_printf("\r\n\n Power On Reset occurred....");

    }

    /* Check if the Pin Reset flag is set */

    else if (RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET){

      UART1_printf("\r\n\n External Reset occurred....");

    }

  }

  /* Clear reset flags */

  RCC_ClearFlag();

}





void TAMPER_IRQHandler(void)

{

  if(BKP_GetITStatus() != RESET)

  { /* Tamper detection event occured */



    /* Clear Tamper pin interrupt pending bit */

    BKP_ClearITPendingBit();


    /* Clear Tamper pin Event(TE) pending flag */

    BKP_ClearFlag();

  }

}

'초보의 아웅다웅 설계하기 > STM32' 카테고리의 다른 글

IAR Debugger 다운로드 설정  (0) 2018.08.16
LCD 5*8 픽셀 글자  (0) 2018.07.27
Tamper 사용  (0) 2018.07.23
다중 이동식 저장장치  (0) 2018.07.23
USB Composite  (0) 2018.07.22
error C1189: #error : MFC does not support WINVER less than 0x0501.  (0) 2018.07.18
Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.07.23 09:40

사용 MCU : STM32F103Zx

사용한 MassStorage 타입 :  SD, NandFlash, InterFlash


mass_mal.c에서 수정


#include "stm32f10x.h"

#include "stdio.h"

#include "bsp_sdio_sd.h"

#include "usr_nand.h"

#include "mass_mal.h"


#include "usr_led.h"

#include "usr_uart.h"


//#define MASSPRINT DEBUGPRINT

#define MASSPRINT(...)


typedef enum _MASS_ID

{

MASS_SD = 0,

MASS_NAND = 1,

MASS_INTERNNAL = 2,

}MASS_ID_E;


#define MAL_OK   0

#define MAL_FAIL 1

#define MAX_LUN  0 /* 0 SD, 1 SD, NAND Flash, 2 SD, NAND Flash, Internal Flash */


#define     FLASH_DISK_START_ADDRESS           0x08050000     /* Flash start address (10K for this bootloader) 0x08002800 -> 0x08060000 */

#define     FLASH_DISK_SIZE                0x20000        // 55296 -> 0xA000

#define     FLASH_PAGE_SIZE                       0x800         /* 1k -> 2K per page */

#define     WAIT_TIMEOUT                      100000 



uint32_t Mass_Memory_Size[3];

uint32_t Mass_Block_Size[3];

uint32_t Mass_Block_Count[3];


uint32_t Max_Lun = MAX_LUN;

/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

uint16_t MAL_Init(uint8_t lun)

{

uint16_t status = MAL_OK;

switch (lun)

{

case MASS_SD:

status = SD_Init();

if (status != SD_OK){

MASSPRINT("SD_Init() fail (%d) : file %s on line %d\r\n", status, __FILE__, __LINE__);

status = MAL_FAIL;

}

else{

MASSPRINT("SD_Init() Ok\r\n");

status = MAL_OK;

}

break;

case MASS_NAND:

if (NAND_Init() != NAND_OK){

MASSPRINT("NAND_Init() fail : file %s on line %d\r\n", __FILE__, __LINE__);

status = MAL_FAIL;

}

else{

MASSPRINT("NAND_Init() Ok\r\n");

status = MAL_OK;

}

break;

    case MASS_INTERNNAL:

FLASH_Unlock(); 

      break;

default:

break;

}

return status;

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

uint16_t MAL_Write(uint8_t lun, uint32_t Memory_Offset, uint32_t *Writebuff, uint16_t Transfer_Length)

{

uint16_t status = MAL_OK;

uint16_t i;

switch (lun)

{

case MASS_SD:

status = SD_WriteBlock((uint8_t*)Writebuff, Memory_Offset, Transfer_Length);

if (status != SD_OK)

{

MASSPRINT("SD_WriteBlock(, 0x%X, 0x%X) Fail(%d) \r\n", Memory_Offset, Transfer_Length, status);

status = MAL_FAIL;

}

else

{

MASSPRINT("SD_WriteBlock(, 0x%X, 0x%X) Ok\r\n", Memory_Offset, Transfer_Length);

status = MAL_OK;

}

break;

case MASS_NAND:

if (NAND_Write(Memory_Offset, Writebuff, Transfer_Length) != NAND_OK)

{

MASSPRINT("NAND_Write(0x%X, ,0x%X) Fail\r\n", Memory_Offset, Transfer_Length);

status = MAL_FAIL;

}

else

{

MASSPRINT("NAND_Write(0x%X, ,0x%X) Ok\r\n", Memory_Offset, Transfer_Length);

status = MAL_OK;

}

break;

    case MASS_INTERNNAL:

for(i = 0; i < Transfer_Length; i += FLASH_PAGE_SIZE)

if (FLASH_WaitForLastOperation(WAIT_TIMEOUT) != FLASH_TIMEOUT)

{

FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);

}

FLASH_ErasePage(FLASH_DISK_START_ADDRESS + Memory_Offset + i); 

}

 

for(i = 0; i < Transfer_Length; i += 4)

if(FLASH_WaitForLastOperation(WAIT_TIMEOUT) != FLASH_TIMEOUT)

{

FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR); 

FLASH_ProgramWord(FLASH_DISK_START_ADDRESS + Memory_Offset + i , Writebuff[i >> 2]); 

}

break;

 

default:

break;

}

return status;

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

uint16_t MAL_Read(uint8_t lun, uint32_t Memory_Offset, uint32_t *Readbuff, uint16_t Transfer_Length)

{

uint16_t status = MAL_OK;

uint16_t i;

switch (lun)

{

case MASS_SD:

status = SD_ReadBlock((uint8_t*)Readbuff, Memory_Offset, Transfer_Length);

if (status != SD_OK)

{

MASSPRINT("SD_ReadBlock(, 0x%X, 0x%X) Fail(%d) \r\n", Memory_Offset, Transfer_Length, status);

status = MAL_FAIL;

}

else

{

MASSPRINT("SD_ReadBlock(, 0x%X, 0x%X) Ok\r\n", Memory_Offset, Transfer_Length);

status = MAL_OK;

}

break;

case MASS_NAND:

if (NAND_Read(Memory_Offset, Readbuff, Transfer_Length) != NAND_OK)

{

MASSPRINT("NAND_Read(0x%X, ,0x%X) Fail\r\n", Memory_Offset, Transfer_Length);

status = MAL_FAIL;

}

else

{

MASSPRINT("NAND_Read(0x%X, ,0x%X) Ok\r\n", Memory_Offset, Transfer_Length);

status = MAL_OK;

}

break;

    case MASS_INTERNNAL:

    for(i = 0; i < Transfer_Length; i += 4)

{

Readbuff[i >> 2] = ((vu32*)(FLASH_DISK_START_ADDRESS + Memory_Offset))[i >> 2]; 

}

      break;

default:

break;

}

return status;

}


/*******************************************************************************

* Function Name : 

* Parameters    : 

* Return        : none

* Description   : 

*******************************************************************************/

uint16_t MAL_GetStatus (uint8_t lun)

{

SD_CardInfo mSDCardInfo;

uint32_t DeviceSizeMul = 0, NumberOfBlocks = 0;

uint32_t nand_id;

uint16_t status = MAL_OK;

switch (lun)

{

case MASS_SD:

{

status = SD_Init();

if (status != SD_OK)

{

MASSPRINT("SD_Init() fail (%d) : file %s on line %d\r\n", status, __FILE__, __LINE__);

status = MAL_FAIL;

break;

}


SD_GetCardInfo(&mSDCardInfo);

SD_SelectDeselect((uint32_t) (mSDCardInfo.RCA << 16));

DeviceSizeMul = (mSDCardInfo.SD_csd.DeviceSizeMul + 2);

if (mSDCardInfo.CardType == SDIO_HIGH_CAPACITY_SD_CARD){

Mass_Block_Count[MASS_SD] = (mSDCardInfo.SD_csd.DeviceSize + 1) * 1024;

MASSPRINT("SD_GetCardInfo() Ok, SDHC Card\r\n");

}

else{

NumberOfBlocks  = ((1 << (mSDCardInfo.SD_csd.RdBlockLen)) / 512);

Mass_Block_Count[MASS_SD] = ((mSDCardInfo.SD_csd.DeviceSize + 1) * (1 << DeviceSizeMul) << (NumberOfBlocks/2));

MASSPRINT("SD_GetCardInfo() Ok, Normal SD Card\r\n");

}

Mass_Block_Size[MASS_SD]  = 512;

status = SD_SelectDeselect((uint32_t) (mSDCardInfo.RCA << 16)); 

status = SD_EnableWideBusOperation(SDIO_BusWide_4b); 

if (status != SD_OK){

MASSPRINT("SD_EnableWideBusOperation(SDIO_BusWide_4b) Fail (%d)\r\n", status);

status = MAL_FAIL;

break;

}

status = SD_SetDeviceMode(SD_DMA_MODE);    

if (status != SD_OK){

MASSPRINT("SD_SetDeviceMode(SD_DMA_MODE) Fail (%d)\r\n", status);

status = MAL_FAIL;

break;

Mass_Memory_Size[MASS_SD] = Mass_Block_Count[MASS_SD] * Mass_Block_Size[MASS_SD];

OUTPUT_On(OUTPUTPIN_2);

MASSPRINT("MAL_GetStatus(MASS_SD) Ok. Memory Size = %uMB\r\n", Mass_Memory_Size[0]/(1024*1024));

status = MAL_OK;

break;

}

case MASS_NAND:

{

nand_id = NAND_ReadID();


if ((nand_id != 0)

{


Mass_Block_Count[MASS_NAND] = NAND_ZONE_SIZE * NAND_BLOCK_SIZE * NAND_MAX_ZONE;

Mass_Block_Size[MASS_NAND]  = NAND_PAGE_SIZE;

Mass_Memory_Size[MASS_NAND] = (Mass_Block_Count[MASS_NAND] * Mass_Block_Size[MASS_NAND]);


OUTPUT_On(OUTPUTPIN_2);

MASSPRINT("MAL_GetStatus(MASS_NAND) Ok. Memory Size = %uMB\r\n", Mass_Memory_Size[MASS_NAND]/(1024*1024));

status = MAL_OK;

}

else

{

MASSPRINT("MAL_GetStatus(MASS_NAND) Fail\r\n");

status = MAL_FAIL;

}

break;

}

case MASS_INTERNNAL:

{    

Mass_Block_Count[MASS_INTERNNAL] = FLASH_DISK_SIZE / FLASH_PAGE_SIZE; 

      Mass_Block_Size[MASS_INTERNNAL] =  FLASH_PAGE_SIZE; 

      Mass_Memory_Size[MASS_INTERNNAL] = FLASH_DISK_SIZE; 

break;

}

default:

status = MAL_FAIL;

break;

}

return status;

}



'초보의 아웅다웅 설계하기 > STM32' 카테고리의 다른 글

LCD 5*8 픽셀 글자  (0) 2018.07.27
Tamper 사용  (0) 2018.07.23
다중 이동식 저장장치  (0) 2018.07.23
USB Composite  (0) 2018.07.22
error C1189: #error : MFC does not support WINVER less than 0x0501.  (0) 2018.07.18
Buzzer Melody  (0) 2018.07.16
Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.07.22 00:00

ConfigDescriptor의 설정과 다른 Endpoint에서 값을 가져오는 경우를 주의하여야 할 것 같습니다. 

빠르게 짜려고 긁어오다가 주로 실수하는 부분이라서...


USB Composite 드라이버를 올려야 해서 Endpoint를 더 가져올 경우 


/*-----------------------------------------------------------*/

usb_conf.h에서 사용할 Endpoint In/Out EPx_xxx_Callback 함수 주석처리

Endpoint ADDR을 추가


#define BTABLE_ADDRESS      (0x00)


/* EP0  */

/* rx/tx buffer base address */

#define ENDP0_RXADDR        (0x18)

#define ENDP0_TXADDR        (0x58)


/* EP1  */

/* tx buffer base address */

//#define ENDP1_TXADDR        (0x98)

#define ENDP1_TXADDR        (0x98)

#define ENDP1_RXADDR        (0xD8)


/* EP2  */

/* Rx buffer base address */

//#define ENDP2_RXADDR        (0xD8)

#define ENDP2_TXADDR        (0x118)

#define ENDP2_RXADDR        (0x158)


/* CTR service routines */

/* associated to defined endpoints */

//#define  EP1_IN_Callback   NOP_Process

//#define  EP2_IN_Callback   NOP_Process

#define  EP3_IN_Callback   NOP_Process

#define  EP4_IN_Callback   NOP_Process

#define  EP5_IN_Callback   NOP_Process

#define  EP6_IN_Callback   NOP_Process

#define  EP7_IN_Callback   NOP_Process



//#define  EP1_OUT_Callback   NOP_Process

//#define  EP2_OUT_Callback   NOP_Process

#define  EP3_OUT_Callback  NOP_Process

#define  EP4_OUT_Callback   NOP_Process

#define  EP5_OUT_Callback   NOP_Process

#define  EP6_OUT_Callback   NOP_Process

#define  EP7_OUT_Callback   NOP_Process


/*-----------------------------------------------------------*/

usb_endp.c에 Callback를 넣고 처리할 부분 추가

void EP1_OUT_Callback(void)

{

  PMAToUserBufferCopy(Receive_Buffer, ENDP1_RXADDR, 2);

  if (Receive_Buffer[1] == 0)

  {

  }

  else 

  {

  }

}


void EP1_IN_Callback(void)

{

}


void EP2_IN_Callback(void)

{

}


void EP2_OUT_Callback(void)

{

}


/*-----------------------------------------------------------*/

usb_desc.c 및 h 변경


/* Includes ------------------------------------------------------------------*/
#include "usb_desc.h"
#define  DEV_DSC_VID0 0x83
#define  DEV_DSC_VID1 0x04

#define  DEV_DSC_PID0 0x20
#define  DEV_DSC_PID1 0x57

#define USB_DEVICE_DESCRIPTOR_TYPE              0x01
#define USB_OTG_HS_MAX_PACKET_SIZE           512
#define USB_OTG_FS_MAX_PACKET_SIZE           64
#define USB_OTG_MAX_EP0_SIZE                 64

#define USB_DEVICE_DESCRIPTOR_TYPE              0x01
#define USB_CONFIGURATION_DESCRIPTOR_TYPE       0x02
#define USB_STRING_DESCRIPTOR_TYPE              0x03
#define USB_INTERFACE_DESCRIPTOR_TYPE           0x04
#define USB_ENDPOINT_DESCRIPTOR_TYPE            0x05

#define HID_DESCRIPTOR_TYPE                     0x21
#define CUSTOMHID_SIZ_HID_DESC                  0x09
#define CUSTOMHID_OFF_HID_DESC                  0x12

#define Composite_SIZ_DEVICE_DESC               18
#define Composite_SIZ_CONFIG_DESC               66//64
#define CUSTOMHID_SIZ_REPORT_DESC               162
#define Composite_SIZ_STRING_LANGID             4
#define Composite_SIZ_STRING_VENDOR             28
#define Composite_SIZ_STRING_PRODUCT            48
#define Composite_SIZ_STRING_SERIAL             34
#define Composite_SIZ_STRING_INTERFACE         42

#define STANDARD_ENDPOINT_DESC_SIZE             0x09

const uint8_t Composite_DeviceDescriptor[Composite_SIZ_DEVICE_DESC] =
  {
    0x12,                       /*bLength */
    USB_DEVICE_DESCRIPTOR_TYPE, /*bDescriptorType*/
    0x00,                       /*bcdUSB */
    0x02,
    0x00,                       /*bDeviceClass*/
    0x00,                       /*bDeviceSubClass*/
    0x00,                       /*bDeviceProtocol*/
    USB_OTG_MAX_EP0_SIZE,   /* bMaxPacketSize0 0x40 = 64 */
DEV_DSC_VID0,   /* idVendor */
    DEV_DSC_VID1,
    DEV_DSC_PID0,   /* idProduct */
    DEV_DSC_PID1,
    0x00,                       /*bcdDevice rel. 2.00*/
    0x02,
    1,                          /*Index of string descriptor describing
                                              manufacturer */
    2,                          /*Index of string descriptor describing
                                             product*/
    3,                          /*Index of string descriptor describing the
                                             device serial number */
    0x01                        /*bNumConfigurations*/
  }
  ; /* Composite_DeviceDescriptor */


/* USB Configuration Descriptor */
/*   All Descriptors (Configuration, Interface, Endpoint, Class, Vendor */
const uint8_t Composite_ConfigDescriptor[Composite_SIZ_CONFIG_DESC] =
  {
    0x09, /* bLength: Configuration Descriptor size */
    USB_CONFIGURATION_DESCRIPTOR_TYPE, /* bDescriptorType: Configuration */
    Composite_SIZ_CONFIG_DESC,
    /* wTotalLength: Bytes returned */
    0x00,
    0x02,         /* bNumInterfaces: 2 interfaces */
    0x01,         /* bConfigurationValue: Configuration value */
    0x00,         /* iConfiguration: Index of string descriptor describing
                                 the configuration*/
    0xC0,         /* bmAttributes: Self powered */
    0x32,         /* MaxPower 100 mA: this current is used for detecting Vbus */

    /************** Descriptor of Custom HID interface ****************/
    /* 09 */
    0x09,         /* bLength: Interface Descriptor size */
    USB_INTERFACE_DESCRIPTOR_TYPE,/* bDescriptorType: Interface descriptor type */
    0x00,         /* bInterfaceNumber: Number of Interface */
    0x00,         /* bAlternateSetting: Alternate setting */
    0x02,         /* bNumEndpoints */
    0x03,         /* bInterfaceClass: HID */
    0x00,         /* bInterfaceSubClass : 1=BOOT, 0=no boot */
    0x00,         /* nInterfaceProtocol : 0=none, 1=keyboard, 2=mouse */
    2,//0,            /* iInterface: Index of string descriptor */
    /******************** Descriptor of Custom HID HID ********************/
    /* 18 */
    0x09,         /* bLength: HID Descriptor size */
    HID_DESCRIPTOR_TYPE, /* bDescriptorType: HID */
    0x10,         /* bcdHID: HID Class Spec release number */
    0x01,
    0x00,         /* bCountryCode: Hardware target country */
    0x01,         /* bNumDescriptors: Number of HID class descriptors to follow */
    0x22,         /* bDescriptorType */
    CUSTOMHID_SIZ_REPORT_DESC,/* wItemLength: Total length of Report descriptor */
    0x00,
    /******************** Descriptor of Custom HID endpoints ******************/
    /* 27 */
    0x07,          /* bLength: Endpoint Descriptor size */
    USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType: */

    0x81,          /* bEndpointAddress: Endpoint Address (IN) 0x81 */
    0x03,          /* bmAttributes: Interrupt endpoint */
    0x02,          /* wMaxPacketSize: 2 Bytes max */
    0x00,
    0x20,          /* bInterval: Polling Interval (32 ms) */
    /* 34 */
   
    0x07, /* bLength: Endpoint Descriptor size */
    USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType: */
/* Endpoint descriptor type */
    0x01, /* bEndpointAddress: */
/* Endpoint Address (OUT) */
    0x03, /* bmAttributes: Interrupt endpoint */
    0x02, /* wMaxPacketSize: 2 Bytes max  */
    0x00,
    0x20, /* bInterval: Polling Interval (20 ms) */
    /* 41 */
    /******************** Descriptor of Mass Storage interface ********************/
    /* 09 */
    0x09,   /* bLength: Interface Descriptor size */
    USB_INTERFACE_DESCRIPTOR_TYPE,   /* bDescriptorType: */
    /*      Interface descriptor type */
    0x01,   /* bInterfaceNumber: Number of Interface */ //0x00 => 0x01
    0x00,   /* bAlternateSetting: Alternate setting */
    0x02,   /* bNumEndpoints*/
    0x08,   /* bInterfaceClass: MASS STORAGE Class */
    0x06,   /* bInterfaceSubClass : SCSI transparent*/
    0x50,   /* nInterfaceProtocol */
    0X04,          /* iInterface: */ //4 ->1
    /* 18 */
    0x07,   /*Endpoint descriptor length = 7*/
    0x05,   /*Endpoint descriptor type */
    0x82,   /*Endpoint address (IN, address 1) *///0x81
    0x02,   /*Bulk endpoint type */
    0x40,   /*Maximum packet size (64 bytes) */
    0x00,
    0x00,   /*Polling interval in milliseconds */
    /* 25 */
    0x07,   /*Endpoint descriptor length = 7 */
    0x05,   /*Endpoint descriptor type */
    0x02,   /*Endpoint address (OUT, address 2) */
    0x02,   /*Bulk endpoint type */
    0x40,   /*Maximum packet size (64 bytes) */
    0x00,
    0x00     /*Polling interval in milliseconds*/
    /*32*/
  }; /* Composite_ConfigDescriptor */
const uint8_t CustomHID_ReportDescriptor[CUSTOMHID_SIZ_REPORT_DESC] =
  {                    
    0x05, 0x8c,            /* USAGE_PAGE (ST Page)           */                   
    0x09, 0x01,            /* USAGE (Demo Kit)               */    
    0xa1, 0x01,            /* COLLECTION (Application)       */            
    /* 6 */
    
    /* Led 1 */        
    0x85, 0x01,            /*     REPORT_ID (1)      */
    0x09, 0x01,            /*     USAGE (LED 1)              */
    0x15, 0x00,            /*     LOGICAL_MINIMUM (0)        */          
    0x25, 0x01,            /*     LOGICAL_MAXIMUM (1)        */           
    0x75, 0x08,            /*     REPORT_SIZE (8)            */        
    0x95, 0x01,            /*     REPORT_COUNT (1)           */       
    0xB1, 0x82,             /*    FEATURE (Data,Var,Abs,Vol) */     

    0x85, 0x01,            /*     REPORT_ID (1)              */
    0x09, 0x01,            /*     USAGE (LED 1)              */
    0x91, 0x82,            /*     OUTPUT (Data,Var,Abs,Vol)  */
    /* 26 */
    
    /* Led 2 */
    0x85, 0x02,            /*     REPORT_ID 2      */
    0x09, 0x02,            /*     USAGE (LED 2)              */
    0x15, 0x00,            /*     LOGICAL_MINIMUM (0)        */          
    0x25, 0x01,            /*     LOGICAL_MAXIMUM (1)        */           
    0x75, 0x08,            /*     REPORT_SIZE (8)            */        
    0x95, 0x01,            /*     REPORT_COUNT (1)           */       
    0xB1, 0x82,             /*    FEATURE (Data,Var,Abs,Vol) */     

    0x85, 0x02,            /*     REPORT_ID (2)              */
    0x09, 0x02,            /*     USAGE (LED 2)              */
    0x91, 0x82,            /*     OUTPUT (Data,Var,Abs,Vol)  */
    /* 46 */
    
    /* Led 3 */        
    0x85, 0x03,            /*     REPORT_ID (3)      */
    0x09, 0x03,            /*     USAGE (LED 3)              */
    0x15, 0x00,            /*     LOGICAL_MINIMUM (0)        */          
    0x25, 0x01,            /*     LOGICAL_MAXIMUM (1)        */           
    0x75, 0x08,            /*     REPORT_SIZE (8)            */        
    0x95, 0x01,            /*     REPORT_COUNT (1)           */       
    0xB1, 0x82,             /*    FEATURE (Data,Var,Abs,Vol) */     

    0x85, 0x03,            /*     REPORT_ID (3)              */
    0x09, 0x03,            /*     USAGE (LED 3)              */
    0x91, 0x82,            /*     OUTPUT (Data,Var,Abs,Vol)  */
    /* 66 */
    
    /* Led 4 */
    0x85, 0x04,            /*     REPORT_ID 4)      */
    0x09, 0x04,            /*     USAGE (LED 4)              */
    0x15, 0x00,            /*     LOGICAL_MINIMUM (0)        */          
    0x25, 0x01,            /*     LOGICAL_MAXIMUM (1)        */           
    0x75, 0x08,            /*     REPORT_SIZE (8)            */        
    0x95, 0x01,            /*     REPORT_COUNT (1)           */       
    0xB1, 0x82,            /*     FEATURE (Data,Var,Abs,Vol) */     

    0x85, 0x04,            /*     REPORT_ID (4)              */
    0x09, 0x04,            /*     USAGE (LED 4)              */
    0x91, 0x82,            /*     OUTPUT (Data,Var,Abs,Vol)  */
    /* 86 */
    
    /* key Push Button */  
    0x85, 0x05,            /*     REPORT_ID (5)              */
    0x09, 0x05,            /*     USAGE (Push Button)        */      
    0x15, 0x00,            /*     LOGICAL_MINIMUM (0)        */      
    0x25, 0x01,            /*     LOGICAL_MAXIMUM (1)        */      
    0x75, 0x01,            /*     REPORT_SIZE (1)            */  
    0x81, 0x82,            /*     INPUT (Data,Var,Abs,Vol)   */   
    
    0x09, 0x05,            /*     USAGE (Push Button)        */               
    0x75, 0x01,            /*     REPORT_SIZE (1)            */           
    0xb1, 0x82,            /*     FEATURE (Data,Var,Abs,Vol) */  
         
    0x75, 0x07,            /*     REPORT_SIZE (7)            */           
    0x81, 0x83,            /*     INPUT (Cnst,Var,Abs,Vol)   */                    
    0x85, 0x05,            /*     REPORT_ID (2)              */         
                    
    0x75, 0x07,            /*     REPORT_SIZE (7)            */           
    0xb1, 0x83,            /*     FEATURE (Cnst,Var,Abs,Vol) */                      
    /* 114 */

    /* Tamper Push Button */  
    0x85, 0x06,            /*     REPORT_ID (6)              */
    0x09, 0x06,            /*     USAGE (Tamper Push Button) */      
    0x15, 0x00,            /*     LOGICAL_MINIMUM (0)        */      
    0x25, 0x01,            /*     LOGICAL_MAXIMUM (1)        */      
    0x75, 0x01,            /*     REPORT_SIZE (1)            */  
    0x81, 0x82,            /*     INPUT (Data,Var,Abs,Vol)   */   
    
    0x09, 0x06,            /*     USAGE (Tamper Push Button) */               
    0x75, 0x01,            /*     REPORT_SIZE (1)            */           
    0xb1, 0x82,            /*     FEATURE (Data,Var,Abs,Vol) */  
         
    0x75, 0x07,            /*     REPORT_SIZE (7)            */           
    0x81, 0x83,            /*     INPUT (Cnst,Var,Abs,Vol)   */                    
    0x85, 0x06,            /*     REPORT_ID (6)              */         
                    
    0x75, 0x07,            /*     REPORT_SIZE (7)            */           
    0xb1, 0x83,            /*     FEATURE (Cnst,Var,Abs,Vol) */  
    /* 142 */
    
    /* ADC IN */
    0x85, 0x07,            /*     REPORT_ID (7)              */         
    0x09, 0x07,            /*     USAGE (ADC IN)             */          
    0x15, 0x00,            /*     LOGICAL_MINIMUM (0)        */               
    0x26, 0xff, 0x00,      /*     LOGICAL_MAXIMUM (255)      */                 
    0x75, 0x08,            /*     REPORT_SIZE (8)            */           
    0x81, 0x82,            /*     INPUT (Data,Var,Abs,Vol)   */                    
    0x85, 0x07,            /*     REPORT_ID (7)              */                 
    0x09, 0x07,            /*     USAGE (ADC in)             */                     
    0xb1, 0x82,            /*     FEATURE (Data,Var,Abs,Vol) */                                 
    /* 161 */

    0xc0           /*     END_COLLECTION              */
  }; /* CustomHID_ReportDescriptor */
/* USB String Descriptors (optional) */
const uint8_t Composite_StringLangID[Composite_SIZ_STRING_LANGID] =
{
Composite_SIZ_STRING_LANGID,
USB_STRING_DESCRIPTOR_TYPE,
0x09,
0x04
}; /* LangID = 0x0409: U.S. English */

const uint8_t Composite_StringVendor[Composite_SIZ_STRING_VENDOR] =
  {
    Composite_SIZ_STRING_VENDOR, /* Size of manufacturer string */
    0x03,           /* bDescriptorType = String descriptor */
    /* Manufacturer: "STMicroelectronics" */
    ' ', 0, ' ', 0, ' ', 0, ' ', 0, ' ', 0, ' ', 0, ' ', 0, ' ', 0, //16
    ' ', 0, ' ', 0, ' ', 0, ' ', 0, ' ', 0 //10
  };
const uint8_t Composite_StringProduct[Composite_SIZ_STRING_PRODUCT] =
{
Composite_SIZ_STRING_PRODUCT,          /* bLength */
USB_STRING_DESCRIPTOR_TYPE,        /* bDescriptorType */
' ', 0, ' ', 0, ' ', 0, ' ', 0, ' ', 0, ' ', 0, 'C', 0,
'o', 0, 'm', 0, 'p', 0, 'o', 0, 's', 0, 'i', 0, 't', 0,
'e', 0,' ',0, 'M', 0, 'S', 0, 'C', 0, '+', 0, 'H', 0, 'I', 0, 'D', 0
};

uint8_t Composite_StringSerial[Composite_SIZ_STRING_SERIAL] =
  {
    Composite_SIZ_STRING_SERIAL,
    0x03,
    /* Serial number*/
    '0',0x00,'0',0x00,'0',0x00,'0',0x00,'0',0x00,'0',0x00,
'0',0x00,'0',0x00,'0',0x00,'0',0x00,'0',0x00,'0',0x00,
'0',0x00,'0',0x00,'0',0x00,'0',0x00
  };

const uint8_t Composite_StringInterface[Composite_SIZ_STRING_INTERFACE] =
  {
    Composite_SIZ_STRING_INTERFACE,
    0x03,
    /* Interface 0: "ST Mass" */
    ' ',0x00,' ',0x00,' ',0x00,' ',0x00,
    ' ',0x00,' ',0x00,' ',0x00,' ',0x00,
    ' ',0x00,' ',0x00,' ',0x00,' ',0x00,
    ' ',0x00,' ',0x00,' ',0x00,' ',0x00,
    ' ',0x00,' ',0x00,' ',0x00,' ',0x00
  };

usb_prop.c

/******************** (C) COPYRIGHT 2011 STMicroelectronics ********************
* File Name          : usb_prop.c
* Author             : MCD Application Team
* Version            : V3.3.0
* Date               : 21-March-2011
* Description        : All processing related to Mass Storage Demo
********************************************************************************
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*******************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "usb_lib.h"
#include "usb_desc.h"
#include "usb_pwr.h"
#include "usb_bot.h"
#include "usb_hw.h"
#include "memory.h"
#include "mass_mal.h"
#include "usb_prop.h"

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/


DEVICE Device_Table =
  {
    EP_NUM,
    2
  };

DEVICE_PROP Device_Property =
  {
    CustomHID_init,
    CustomHID_Reset,
    CustomHID_Status_In,
    CustomHID_Status_Out,
    CustomHID_Data_Setup,
    CustomHID_NoData_Setup,
    CustomHID_Get_Interface_Setting,
    CustomHID_GetDeviceDescriptor,
    CustomHID_GetConfigDescriptor,
    CustomHID_GetStringDescriptor,
    0,
    0x40 /*MAX PACKET SIZE*/
  };
USER_STANDARD_REQUESTS User_Standard_Requests =
  {
    CustomHID_GetConfiguration,
    CustomHID_SetConfiguration,
    CustomHID_GetInterface,
    CustomHID_SetInterface,
    CustomHID_GetStatus,
    CustomHID_ClearFeature,
    CustomHID_SetEndPointFeature,
    CustomHID_SetDeviceFeature,
    CustomHID_SetDeviceAddress
  };

ONE_DESCRIPTOR Device_Descriptor =
  {
    (uint8_t*)Composite_DeviceDescriptor,
    Composite_SIZ_DEVICE_DESC
  };

ONE_DESCRIPTOR Config_Descriptor =
  {
    (uint8_t*)Composite_ConfigDescriptor,
    Composite_SIZ_CONFIG_DESC
  };

ONE_DESCRIPTOR CustomHID_Report_Descriptor =
  {
    (uint8_t *)CustomHID_ReportDescriptor,
    CUSTOMHID_SIZ_REPORT_DESC
  };

ONE_DESCRIPTOR CustomHID_Hid_Descriptor =
  {
    (uint8_t*)Composite_ConfigDescriptor + CUSTOMHID_OFF_HID_DESC,
    CUSTOMHID_SIZ_HID_DESC
  };

ONE_DESCRIPTOR String_Descriptor[5] =
  {
    {(uint8_t*)Composite_StringLangID, Composite_SIZ_STRING_LANGID},
    {(uint8_t*)Composite_StringVendor, Composite_SIZ_STRING_VENDOR},
    {(uint8_t*)Composite_StringProduct, Composite_SIZ_STRING_PRODUCT},
    {(uint8_t*)Composite_StringSerial, Composite_SIZ_STRING_SERIAL},
    {(uint8_t*)Composite_StringInterface, Composite_SIZ_STRING_INTERFACE}
  };

uint8_t *CustomHID_SetReport_Feature(uint16_t Length);
/* Extern variables ----------------------------------------------------------*/
extern unsigned char Bot_State;
extern Bulk_Only_CBW CBW;

/* Private function prototypes -----------------------------------------------*/
/* Extern function prototypes ------------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/*******************************************************************************
* Function Name  : MASS_init
* Description    : Mass Storage init routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void CustomHID_init()
{
  /* Update the serial number string descriptor with the data from the unique
  ID*/
  Get_SerialNum();

  pInformation->Current_Configuration = 0;

  /* Connect the device */
  PowerOn();

  /* Perform basic device initialization operations */
  USB_SIL_Init();

  bDeviceState = UNCONNECTED;
}

/*******************************************************************************
* Function Name  : MASS_Reset
* Description    : Mass Storage reset routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void CustomHID_Reset()
{
  /* Set the device as not configured */
  pInformation->Current_Configuration = 0;
  pInformation->Current_Interface = 0;/*the default Interface*/

  /* Current Feature initialization */
  pInformation->Current_Feature = Composite_ConfigDescriptor[7];

#ifdef STM32F10X_CL   
  
  /* EP0 is already configured by USB_SIL_Init() function */

  /* Init EP1 IN as Bulk endpoint */
  OTG_DEV_EP_Init(EP1_IN, OTG_DEV_EP_TYPE_BULK, BULK_MAX_PACKET_SIZE);
  
  /* Init EP2 OUT as Bulk endpoint */
  OTG_DEV_EP_Init(EP2_OUT, OTG_DEV_EP_TYPE_BULK, BULK_MAX_PACKET_SIZE); 
  
#else 

  SetBTABLE(BTABLE_ADDRESS);

  /* Initialize Endpoint 0 */
  SetEPType(ENDP0, EP_CONTROL);
  SetEPTxStatus(ENDP0, EP_TX_STALL);//  SetEPTxStatus(ENDP0, EP_TX_NAK);
  SetEPRxAddr(ENDP0, ENDP0_RXADDR);
  SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
  SetEPTxAddr(ENDP0, ENDP0_TXADDR);
  Clear_Status_Out(ENDP0);
  SetEPRxValid(ENDP0);

/* HID */
  SetEPType(ENDP1, EP_INTERRUPT);
  SetEPTxAddr(ENDP1, ENDP1_TXADDR);
  SetEPRxAddr(ENDP1, ENDP1_RXADDR);
  SetEPTxCount(ENDP1, 2);
  SetEPRxCount(ENDP1, 2);
  SetEPRxStatus(ENDP1, EP_RX_VALID);
  SetEPTxStatus(ENDP1, EP_TX_NAK);

/* Massstorage */
/* Initialize Endpoint 1 */
  SetEPType(ENDP2, EP_BULK);
  SetEPTxCount(ENDP2, Device_Property.MaxPacketSize);
  SetEPTxAddr(ENDP2, ENDP1_TXADDR);
  SetEPTxStatus(ENDP2, EP_TX_NAK);
  SetEPRxStatus(ENDP2, EP_RX_DIS);

  /* Initialize Endpoint 2 */
  SetEPType(ENDP2, EP_BULK);
  SetEPRxAddr(ENDP2, ENDP2_RXADDR);
  SetEPRxCount(ENDP2, Device_Property.MaxPacketSize);
  SetEPRxStatus(ENDP2, EP_RX_VALID);
  SetEPTxStatus(ENDP2, EP_TX_DIS);
  
  /* Set the device to response on default address */
  SetDeviceAddress(0);
#endif /* STM32F10X_CL */

  bDeviceState = ATTACHED;

  CBW.dSignature = BOT_CBW_SIGNATURE;
  Bot_State = BOT_IDLE;

  USB_NotConfigured_LED();
}

/*******************************************************************************
* Function Name  : Mass_Storage_SetConfiguration
* Description    : Handle the SetConfiguration request.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void CustomHID_SetConfiguration(void)
{
  if (pInformation->Current_Configuration != 0)
  {
    /* Device configured */
    bDeviceState = CONFIGURED;

#ifdef STM32F10X_CL 
    /* Init EP1 IN as Bulk endpoint */
    OTG_DEV_EP_Init(EP1_IN, OTG_DEV_EP_TYPE_BULK, BULK_MAX_PACKET_SIZE);
  
    /* Init EP2 OUT as Bulk endpoint */
    OTG_DEV_EP_Init(EP2_OUT, OTG_DEV_EP_TYPE_BULK, BULK_MAX_PACKET_SIZE);     
#else    
/* HID */
    ClearDTOG_RX(ENDP2);
    ClearDTOG_TX(ENDP1);
/* MassStorage */
    ClearDTOG_TX(ENDP1);
    ClearDTOG_RX(ENDP2);
#endif /* STM32F10X_CL */

    Bot_State = BOT_IDLE; /* set the Bot state machine to the IDLE state */
  }
}

/*******************************************************************************
* Function Name  : Mass_Storage_ClearFeature
* Description    : Handle the ClearFeature request.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void CustomHID_ClearFeature(void)//
{
  /* when the host send a CBW with invalid signature or invalid length the two
     Endpoints (IN & OUT) shall stall until receiving a Mass Storage Reset     */
  if (CBW.dSignature != BOT_CBW_SIGNATURE)
    Bot_Abort(BOTH_DIR);
}

/*******************************************************************************
* Function Name  : Mass_Storage_SetConfiguration.
* Description    : Update the device state to addressed.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void CustomHID_SetDeviceAddress (void)
{
  bDeviceState = ADDRESSED;
}
/*******************************************************************************
* Function Name  : CustomHID_Status_In.
* Description    : Joystick status IN routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void CustomHID_Status_In(void)
{  
  return;
}

/*******************************************************************************
* Function Name  : CustomHID_Status_Out
* Description    : Joystick status OUT routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void CustomHID_Status_Out (void)
{
  return;
}

/*******************************************************************************
* Function Name  : MASS_Status_In
* Description    : Mass Storage Status IN routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void MASS_Status_In(void)
{
  return;
}

/*******************************************************************************
* Function Name  : MASS_Status_Out
* Description    : Mass Storage Status OUT routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void MASS_Status_Out(void)
{
  return;
}

/*******************************************************************************
* Function Name  : MASS_Data_Setup.
* Description    : Handle the data class specific requests..
* Input          : RequestNo.
* Output         : None.
* Return         : RESULT.
*******************************************************************************/
RESULT CustomHID_Data_Setup(uint8_t RequestNo)
{
  uint8_t *(*CopyRoutine)(uint16_t);
    
  CopyRoutine = NULL;
  
  if ((RequestNo == GET_DESCRIPTOR)
      && (Type_Recipient == (STANDARD_REQUEST | INTERFACE_RECIPIENT)))
{    
    if(pInformation->USBwIndex0 == 0)
    {
      if (pInformation->USBwValue1 == REPORT_DESCRIPTOR)
      {
        CopyRoutine = CustomHID_GetReportDescriptor;
      }
      else if (pInformation->USBwValue1 == HID_DESCRIPTOR_TYPE)
      {
        CopyRoutine = CustomHID_GetHIDDescriptor;
      }
    }
  } /* End of GET_DESCRIPTOR */
  else if ((Type_Recipient == (CLASS_REQUEST | INTERFACE_RECIPIENT))
           && RequestNo == GET_PROTOCOL)
  {
    CopyRoutine = CustomHID_GetProtocolValue;
  }
if ((Type_Recipient == (CLASS_REQUEST | INTERFACE_RECIPIENT))
      && (RequestNo == GET_MAX_LUN) && (pInformation->USBwValue == 0)
      && (pInformation->USBwIndex == 0) && (pInformation->USBwLength == 0x01))
  {
    CopyRoutine = Get_Max_Lun;
  }
  
  if (CopyRoutine == NULL){
    return USB_UNSUPPORT;
  }
  
  pInformation->Ctrl_Info.CopyData = CopyRoutine;
  pInformation->Ctrl_Info.Usb_wOffset = 0;
  (*CopyRoutine)(0);
  return USB_SUCCESS;
}

/*******************************************************************************
* Function Name  : MASS_NoData_Setup.
* Description    : Handle the no data class specific requests.
* Input          : RequestNo.
* Output         : None.
* Return         : RESULT.
*******************************************************************************/
RESULT CustomHID_NoData_Setup(uint8_t RequestNo)
{
  if ((Type_Recipient == (CLASS_REQUEST | INTERFACE_RECIPIENT))
      && (RequestNo == SET_PROTOCOL))
  {
   #ifdef STM32F10X_CL 
    /* Init EP1 IN as Bulk endpoint */
    OTG_DEV_EP_Init(EP1_IN, OTG_DEV_EP_TYPE_BULK, BULK_MAX_PACKET_SIZE);
  
    /* Init EP2 OUT as Bulk endpoint */
    OTG_DEV_EP_Init(EP2_OUT, OTG_DEV_EP_TYPE_BULK, BULK_MAX_PACKET_SIZE);     
   #else
/* HID */
    ClearDTOG_RX(ENDP2);
    ClearDTOG_TX(ENDP1);
/* MassStorage */
    ClearDTOG_TX(ENDP1);
    ClearDTOG_RX(ENDP2);
   #endif /* STM32F10X_CL */

    /*initialize the CBW signature to enable the clear feature*/
    CBW.dSignature = BOT_CBW_SIGNATURE;
    Bot_State = BOT_IDLE;

    return CustomHID_SetProtocol();
  }
  return USB_UNSUPPORT;
}

/*******************************************************************************
* Function Name  : MASS_Get_Interface_Setting
* Description    : Test the interface and the alternate setting according to the
*                  supported one.
* Input          : uint8_t Interface, uint8_t AlternateSetting.
* Output         : None.
* Return         : RESULT.
*******************************************************************************/
RESULT CustomHID_Get_Interface_Setting(uint8_t Interface, uint8_t AlternateSetting)
{
  if (AlternateSetting > 0)
  {
    return USB_UNSUPPORT;/* in this application we don't have AlternateSetting*/
  }
  else if (Interface > 0)
  {
    return USB_UNSUPPORT;/*in this application we have only 1 interfaces*/
  }
  return USB_SUCCESS;
}

/*******************************************************************************
* Function Name  : MASS_GetDeviceDescriptor
* Description    : Get the device descriptor.
* Input          : uint16_t Length.
* Output         : None.
* Return         : None.
*******************************************************************************/
uint8_t *CustomHID_GetDeviceDescriptor(uint16_t Length)
{
  return Standard_GetDescriptorData(Length, &Device_Descriptor );
}

/*******************************************************************************
* Function Name  : MASS_GetConfigDescriptor
* Description    : Get the configuration descriptor.
* Input          : uint16_t Length.
* Output         : None.
* Return         : None.
*******************************************************************************/
uint8_t *CustomHID_GetConfigDescriptor(uint16_t Length)
{
  return Standard_GetDescriptorData(Length, &Config_Descriptor );
}

/*******************************************************************************
* Function Name  : MASS_GetStringDescriptor
* Description    : Get the string descriptors according to the needed index.
* Input          : uint16_t Length.
* Output         : None.
* Return         : None.
*******************************************************************************/
uint8_t *CustomHID_GetStringDescriptor(uint16_t Length)
{
  uint8_t wValue0 = pInformation->USBwValue0;

//  if (wValue0 > 5)
  if (wValue0 > 4)
  {
    return NULL;
  }
  else
  {
    return Standard_GetDescriptorData(Length, &String_Descriptor[wValue0]);
  }
}

uint32_t ProtocolValue;
uint8_t Report_Buf[2];  
/*******************************************************************************
* Function Name  : CustomHID_SetReport_Feature
* Description    : Set Feature request handling
* Input          : Length.
* Output         : None.
* Return         : Buffer
*******************************************************************************/
uint8_t *CustomHID_SetReport_Feature(uint16_t Length)
{
  if (Length == 0)
  {
    pInformation->Ctrl_Info.Usb_wLength = 2;
    return NULL;
  }
  else
  {
    return Report_Buf;
  }
}

/*******************************************************************************
* Function Name  : CustomHID_GetReportDescriptor.
* Description    : Gets the HID report descriptor.
* Input          : Length
* Output         : None.
* Return         : The address of the configuration descriptor.
*******************************************************************************/
uint8_t *CustomHID_GetReportDescriptor(uint16_t Length)
{
  return Standard_GetDescriptorData(Length, &CustomHID_Report_Descriptor);
}

/*******************************************************************************
* Function Name  : CustomHID_GetHIDDescriptor.
* Description    : Gets the HID descriptor.
* Input          : Length
* Output         : None.
* Return         : The address of the configuration descriptor.
*******************************************************************************/
uint8_t *CustomHID_GetHIDDescriptor(uint16_t Length)
{
  return Standard_GetDescriptorData(Length, &CustomHID_Hid_Descriptor);
}

/*******************************************************************************
* Function Name  : CustomHID_SetProtocol
* Description    : Joystick Set Protocol request routine.
* Input          : None.
* Output         : None.
* Return         : USB SUCCESS.
*******************************************************************************/
RESULT CustomHID_SetProtocol(void)
{
  uint8_t wValue0 = pInformation->USBwValue0;
  ProtocolValue = wValue0;
  return USB_SUCCESS;
}

/*******************************************************************************
* Function Name  : CustomHID_GetProtocolValue
* Description    : get the protocol value
* Input          : Length.
* Output         : None.
* Return         : address of the protocol value.
*******************************************************************************/
uint8_t *CustomHID_GetProtocolValue(uint16_t Length)
{
  if (Length == 0)
  {
    pInformation->Ctrl_Info.Usb_wLength = 1;
    return NULL;
  }
  else
  {
    return (uint8_t *)(&ProtocolValue);
  }
}

/*******************************************************************************
* Function Name  : Get_Max_Lun
* Description    : Handle the Get Max Lun request.
* Input          : uint16_t Length.
* Output         : None.
* Return         : None.
*******************************************************************************/
uint8_t *Get_Max_Lun(uint16_t Length)
{
  if (Length == 0)
  {
    pInformation->Ctrl_Info.Usb_wLength = LUN_DATA_LENGTH;
    return 0;
  }
  else
  {
    return (uint8_t *)&Max_Lun;
  }
}



'초보의 아웅다웅 설계하기 > STM32' 카테고리의 다른 글

Tamper 사용  (0) 2018.07.23
다중 이동식 저장장치  (0) 2018.07.23
USB Composite  (0) 2018.07.22
error C1189: #error : MFC does not support WINVER less than 0x0501.  (0) 2018.07.18
Buzzer Melody  (0) 2018.07.16
IAR 에서 고정 영역 SRAM과 ROM 사용  (0) 2018.07.06
Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.07.18 11:43

Custom_HID PC 프로그램 예제에서 에러문제



error C1189: #error : MFC does not support WINVER less than 0x0501. Please change the definition of WINVER in your project properties or precompiled header. c:\program files (x86)\microsoft visual studio 12.0\vc\atlmfc\include\afxv_w32.h 40 1 UsbHidDemonstrator



USB HID Demonstrator\src\StdAfx.h 에서 아래의 부분을 수정하여야 합니다.



#define WINVER 0x0500

=> 수정

#define WINVER 0x0A00



USB HID Demonstrator.zip


참고 :

http://poorman.tistory.com/144

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.07.16 15:13

Buzzer Melody 예제입니다.

멜로디를 위한 테스트 예제로 참고만 하면 될 것 같습니다.


void TIM2_Configuration(void)

{

TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;

NVIC_InitTypeDef NVIC_InitStructure;


/* TIM2 clock enable */

RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);


/* Time base configuration */

TIM_TimeBaseStructure.TIM_Period = 10;  // Overflow Interrupt On 10 usec 타이머주기

TIM_TimeBaseStructure.TIM_Prescaler = 35; // Timer/Count2 Clock = 36Mhz / (35 + 1) = 1Mhz = 1 usec

TIM_TimeBaseStructure.TIM_ClockDivision = 0;

TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // 카운터모드동작

TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);


  /* TIM2 counter enable */

  TIM_Cmd(TIM2, ENABLE);


/* TIM IT enable */

TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);


/* Enable the TIM2 gloabal Interrupt */

NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

NVIC_Init(&NVIC_InitStructure);

}


/*

unut : sec

도 0.030578 0.015289 0.007645 0.003822 0.001911 0.000956 0.000478 

C# 0.028862 0.014431 0.007215 0.003608 0.001804 0.000902 0.000451 

레 0.027242 0.013621 0.006810 0.003405 0.001703 0.000851 0.000426 

D# 0.025713 0.012856 0.006428 0.003214 0.001607 0.000804 0.000402 

미 0.024270 0.012135 0.006067 0.003034 0.001517 0.000758 0.000379 

파 0.022908 0.011454 0.005727 0.002863 0.001432 0.000716 0.000358 

F# 0.021622 0.010811 0.005405 0.002703 0.001351 0.000676 0.000338 

솔 0.020408 0.010204 0.005102 0.002551 0.001276 0.000638 0.000319 

G# 0.019263 0.009631 0.004816 0.002408 0.001204 0.000602 0.000301 

라 0.018182 0.009091 0.004545 0.002273 0.001136 0.000568 0.000284 

A# 0.017161 0.008581 0.004290 0.002145 0.001073 0.000536 0.000268 

시 0.016198 0.008099 0.004050 0.002025 0.001012 0.000506 0.000253 

0.000033 0.000065 0.000131 0.000262 0.000523 0.001047 0.002093 

0.000035 0.000069 0.000139 0.000277 0.000554 0.001109 0.002217 

0.000037 0.000073 0.000147 0.000294 0.000587 0.001175 0.002349 

0.000039 0.000078 0.000156 0.000311 0.000622 0.001245 0.002489 

0.000041 0.000082 0.000165 0.000330 0.000659 0.001319 0.002637 

0.000044 0.000087 0.000175 0.000349 0.000698 0.001397 0.002794 

0.000046 0.000092 0.000185 0.000370 0.000740 0.001480 0.002960 

0.000049 0.000098 0.000196 0.000392 0.000784 0.001568 0.003136 

0.000052 0.000104 0.000208 0.000415 0.000831 0.001661 0.003322 

0.000055 0.000110 0.000220 0.000440 0.000880 0.001760 0.003520 

0.000058 0.000117 0.000233 0.000466 0.000932 0.001865 0.003729 

0.000062 0.000123 0.000247 0.000494 0.000988 0.001976 0.003951 

*/


#define MUSIC_REST 0

#define MUSIC_DO 191

#define MUSIC_C_SHARP 180

#define MUSIC_RE 170

#define MUSIC_D_SHARP 161

#define MUSIC_MI 152

#define MUSIC_PA 143

#define MUSIC_F_SHARP 135

#define MUSIC_SOL 128

#define MUSIC_G_SHARP 120

#define MUSIC_RA 114

#define MUSIC_A_SHARP 107

#define MUSIC_SI 101

#define MUSIC_HDO 96



uint32_t Sound = 0;

uint32_t Music = 0;


int main(void)
{
  GPIO_InitTypeDef  GPIO_InitStructure;
  /* System Clocks Configuration */
  RCC_Configuration();
  
  /* Enable the GPIO BUZZER Clock */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

  /* Configure the GPIO BUZZER pin */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIOB, &GPIO_InitStructure);

  TIM2_Configuration();

  Music = MUSIC_SOL;
  Delay_Us(100000);
  Music = MUSIC_REST;
  Delay_Us(10000);
  Music = MUSIC_SOL;
  Delay_Us(100000);
  Music = MUSIC_RA;
  Delay_Us(100000);
  Music = MUSIC_REST;
  Delay_Us(10000);
  Music = MUSIC_RA;
  Delay_Us(100000);
  Music = MUSIC_SOL;
  Delay_Us(100000);
  Music = MUSIC_REST;
  Delay_Us(10000);
  Music = MUSIC_SOL;
  Delay_Us(100000);
  Music = MUSIC_MI;
  Delay_Us(100000);
  Delay_Us(100000);

  Music = MUSIC_SOL;
  Delay_Us(100000);
  Music = MUSIC_REST;
  Delay_Us(10000);
  Music = MUSIC_SOL;
  Delay_Us(100000);
  Music = MUSIC_MI;
  Delay_Us(100000);
  Music = MUSIC_REST;
  Delay_Us(10000);
  Music = MUSIC_MI;
  Delay_Us(100000);
  Music = MUSIC_RE;
  Delay_Us(100000);
  Delay_Us(100000);


  Music = MUSIC_SOL;
  Delay_Us(100000);
  Music = MUSIC_REST;
  Delay_Us(10000);
  Music = MUSIC_SOL;
  Delay_Us(100000);
  Music = MUSIC_RA;
  Delay_Us(100000);
  Music = MUSIC_REST;
  Delay_Us(10000);
  Music = MUSIC_RA;
  Delay_Us(100000);
  Music = MUSIC_SOL;
  Delay_Us(100000);
  Music = MUSIC_REST;
  Delay_Us(10000);
  Music = MUSIC_SOL;
  Delay_Us(100000);
  Music = MUSIC_MI;
  Delay_Us(100000);
  Delay_Us(100000);

  Music = MUSIC_SOL;
  Delay_Us(100000);
  Music = MUSIC_MI;
  Delay_Us(100000);
  Music = MUSIC_RE;
  Delay_Us(100000);
  Music = MUSIC_MI;
  Delay_Us(100000);
  Music = MUSIC_DO;
  Delay_Us(100000);
  Delay_Us(100000);
  TIM_Cmd(TIM2, DISABLE);
  GPIOB->BRR = GPIO_Pin_0;
}





stm32f10x_it.c


extern uint32_t Sound;

extern uint32_t Music;


/**

  * @brief  This function handles TIM2 global interrupt request.

  * @param  None

  * @retval None

  */

void TIM2_IRQHandler(void) // 1mS Timer

{

  if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)

  {

    TIM_ClearITPendingBit(TIM2, TIM_IT_Update);

    Sound++;

    if(Sound >= Music){

GPIOB->ODR ^= GPIO_Pin_0;

Sound = 0;

    }

  }

}

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.07.15 22:02

Via나 Clearance Rules는 하시는 곳에 맞춰서 변경하시면 됩니다.

예전에는 Min. 기본을 0.3 이상이나 0.5 이상이어야 어느 PCB 업체에서 해도 PCB 불량이 적다고 해서 기본으로 하였었는데 요즘은 그런 것 같지도 않네요. 


4Layer_Base.pcb


Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.07.06 10:55


/*------------------------------------------------------------------------------*/

.icf

/*-Specials-*/

define symbol __ICFEDIT_intvec_start__ = 0x08000000;

/*-Memory Regions-*/

define symbol __ICFEDIT_region_ROM_start__    = 0x08000000;

define symbol __ICFEDIT_region_ROM_end__      = 0x0800FFFF;

define symbol __ICFEDIT_region_RAM_start__    = 0x20000240;

define symbol __ICFEDIT_region_RAM_end__      = 0x20016FFF;


/*-Sizes-*/

define symbol __ICFEDIT_size_cstack__ = 0x400;

define symbol __ICFEDIT_size_heap__   = 0x200;

/**** End of ICF editor section. ###ICF###*/


/* Rom에서 원하는 함수나 고정값을 넣을 영역 */

define symbol __ICFEDIT_Fixed_region_ROM_start__    = 0x08010000;

define symbol __ICFEDIT_Fixed_region_ROM_end__      = 0x0801FFFF;


/* Ram에서 원하는 변수를 넣을 영역 */

define symbol __ICFEDIT_Fixed_region_SRAM_start__    = 0x20000000;

define symbol __ICFEDIT_Fixed_region_SRAM_end__      = 0x200001FF;




define memory mem with size = 4G;

define region ROM_region      = mem:[from __ICFEDIT_region_ROM_start__   to __ICFEDIT_region_ROM_end__];

define region Fixed_ROM_region      = mem:[from __ICFEDIT_Fixed_region_ROM_start__   to __ICFEDIT_Fixed_region_ROM_end__];

define region Fixed_SRAM_region    = mem:[from __ICFEDIT_Fixed_region_SRAM_start__   to __ICFEDIT_Fixed_region_SRAM_end__];

define region RAM_region      = mem:[from __ICFEDIT_region_RAM_start__   to __ICFEDIT_region_RAM_end__];



place in Fixed_ROM_region {readonly object Fixed_ROM.o};


place in Fixed_SRAM_region   {readwrite section .Fixed_Sram };


initialize by copy { readwrite };

do not initialize  { section .noinit };

initialize by copy { section .Fixed_Sram };


/*------------------------------------------------------------------------------*/


Fixed_ROM.c

/*------------------------------------------------------------------------------*/

int FixedData(int a, int b)

{

return (a+b);

}

/*------------------------------------------------------------------------------*/


Fixed_SRAM.c

/*------------------------------------------------------------------------------*/

#pragma section =".Fixed_Sram"


#pragma default_variable_attributes = @ ".Fixed_Sram"

uint32_t FixedSRAMData[10];


/* Stop placing data in section Fixed_SRAM_region */

#pragma default_variable_attributes =

/*------------------------------------------------------------------------------*/



Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.06.28 21:58

 STM32L432가 저가의 제품이라 사용하려고 하고 있습니다.

그런데 Read Protect 기능을 사용하면 기존에 라이팅 되어 있는 프로그램이 다 사라집니다. 당황스럽네요.

STM32F1XX 제품군에서 확인하면 괜찮은데 이 제품에서만 그러네요.(사라진게 아니라 동작을 안한거였슴니다)


놀랍습니다.

어제 질문글을 올렸는데 오늘 답변이 왔네요.

니가 무슨말 하는지 모르겠다라구요.. ㅠㅠ

제 영어실력이 딸려서 ㅠㅠ

어제까지만 해도 비관적 안티였었는데 하루만에 ST 찬양합니다.

그 후에 20분 간격으로 답변을 주고 받을 수 있었습니다.

채팅하는 줄....

 

Dear customer,

In relation to the read out protection in the reference manual of STM32L432KC, it is mentioned as follows :

"If the read protection is set while the debugger is still connected through JTAG/SWD, apply a POR (power-on reset) instead of a system reset."

To operate MCU after setting RDP Level1 using ST-Link utility, you need to physically reset MCU power. 

Thank you.


전원을 JTAG쪽에 안 넣고 따로 넣어도 안된다고 문의했더니 또 답변이 옵니다. 의미는 없었지만..


Dear customer,

Did you try a system reset or POR(power-on reset)? 

the below is the descripotion of ROP in the reference manual. 

"The read protection is activated by setting the RDP option byte and then, by applying a system reset to reload the new RDP option byte."

Thank you.


그러다 아 SWD 신호라인에 역으로 전원이 인가돼서 그러는 건 아닐까? 하고 신호선을 칼로 잘라냈더니 됩니다.

=> SWD나 JTAG단자를 완전 분리해야만 동작하는 부분이었습니다.

....( - _-);; 죄송합니다.

 

 그리고 ST에서 제공하는 UART 라이팅프로그램에서는 지원하지 않네요.

예전 버그들이 생각납니다.

UART 라이팅 프로그램 버그(하위버젼으로 내려서 사용해야했었던)였던가? 한참을 고쳐주지 않았던 느긋한? ST사의 대응이 생각나네요.

 

구글링을 하다보니 STM32L432제품을 다운로드할 수 있는 UART 프로그램이 있었습니다. 기존과 다르게 자동으로 칩을 선택해주는 게 아니라 사용하는 칩을 선택하여야 합니다. 그리고 정식본인지는 잘 모르겠습니다.... 판단은 각자가..

STMFlashLoader Demo_V2.9.0RC4.zip


ST에서 제공하는 STMFlashLoader

https://www.st.com/en/development-tools/flasher-stm32.html



나중에 검색해보시면 아시겠지만 Read Protection에도 보안 이슈가 있습니다.

대단한 놈들...

STM32L4 시리즈에서 FireWall이라는 옵션이 생겼는데 프로텍션과 비슷합니다.

ROM과 RAM 영역을 나눠서(*.icf(iar)나 *.sct(keil)) Code나 Data를 넣고 그 영역을 방화벽으로 접근못하게 하는 것 같습니다. 우왕...

Protection과 함께 쓰기를 권장하는데 프로그램에 설정해주고 하는 게 귀찮아서 크리한 거 아니면 안 쓸것 같습니다. 내부에 꼭 가지고 있어야 하는 SSP 같은 거 아니면 2중으로 하는 번거로움으로 인해...


결론은 ST 찬양합니다. 

갈 수록 (대응이) 좋아지네요. 개인적인 질문에도 답변해주는 거에 감탄!!! 

브x드컴 같은 곳은 중소기업이나 수량 적은 곳 사지말라고 하는 느낌인데... 무슨 포럼 가입도 안 시켜줘.... 

갓 ST... 







Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.06.26 13:34

STM32L4xx에서 BrownOut 설정

 HAL_FLASH_Unlock()을 하지 않고  HAL_FLASH_OB_Unlock()만을 하였더니 계속 에러가 발생하였습니다. 가만 생각해보면 당연한건데 그걸 놓쳤었네요.

전압레벨 설정은 아래와 같고 기본은 1.7V입니다.

ReadOut Protect도 같이 설정되어 있습니다.

 

#define OB_BOR_LEVEL_0            ((uint32_t)FLASH_OPTR_BOR_LEV_0)     /*!< Reset level threshold is around 1.7V */
#define OB_BOR_LEVEL_1            ((uint32_t)FLASH_OPTR_BOR_LEV_1)     /*!< Reset level threshold is around 2.0V */
#define OB_BOR_LEVEL_2            ((uint32_t)FLASH_OPTR_BOR_LEV_2)     /*!< Reset level threshold is around 2.2V */
#define OB_BOR_LEVEL_3            ((uint32_t)FLASH_OPTR_BOR_LEV_3)     /*!< Reset level threshold is around 2.5V */
#define OB_BOR_LEVEL_4            ((uint32_t)FLASH_OPTR_BOR_LEV_4)     /*!< Reset level threshold is around 2.8V */

 




#define USRCONFIGMASK 0xFFFFF8FF

#define BORLEVELMASK 0x00000700

/*******************************************************************************

* Function Name : 

* Parameters    : None

* Return        : None

* Description   : 

*******************************************************************************/

uint32_t Get_USRConfig(void) 

{

FLASH_OBProgramInitTypeDef FLASH_Handle;

/* Read option bytes */

HAL_FLASHEx_OBGetConfig(&FLASH_Handle);

return (FLASH_Handle.USERConfig & USRCONFIGMASK);

}


/*******************************************************************************

* Function Name : 

* Parameters    : None

* Return        : None

* Description   : 

*******************************************************************************/

uint32_t Get_BORConfig(void)

{

FLASH_OBProgramInitTypeDef FLASH_Handle;

/* Read option bytes */

HAL_FLASHEx_OBGetConfig(&FLASH_Handle);


return (FLASH_Handle.USERConfig & BORLEVELMASK);

}

 

void Config_BOR(void)

{

uint32_t BORTimeout = BOR_FLAG_TIMEOUT; 

FLASH_OBProgramInitTypeDef FLASH_Handle; 

HAL_FLASHEx_OBGetConfig(&FLASH_Handle); 

DEBUGPRINT("USERConfig %X\r\n", FLASH_Handle.USERConfig); 

DEBUGPRINT("FLASH_Handle.RDPLevel %X \r\n", FLASH_Handle.RDPLevel); 

if(Get_BORConfig() != BORLEVEL){ 

FLASH_Handle.USERConfig = (Get_USRConfig() | BORLEVEL); 

FLASH_Handle.OptionType = (OPTIONBYTE_USER | OPTIONBYTE_RDP); 

FLASH_Handle.USERType = OB_USER_BOR_LEV; 

FLASH_Handle.RDPLevel = OB_RDP_LEVEL_1; 

while (HAL_FLASH_Unlock() != HAL_OK){ 

if((BORTimeout--) == 0){DEBUGPRINT("HAL_FLASH_Unlock Fail\r\n");break;}

DEBUGPRINT("HAL_FLASH_Unlock\r\n"); 

    __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_OPTVERR); 

BORTimeout = BOR_FLAG_TIMEOUT; 

while (HAL_FLASH_OB_Unlock() != HAL_OK){ 

if((BORTimeout--) == 0){DEBUGPRINT("HAL_FLASH_OB_Unlock Fail\r\n");break;}

DEBUGPRINT("USERConfig %X\r\n", FLASH_Handle.USERConfig); 

DEBUGPRINT("FLASH_Handle.RDPLevel %X \r\n", FLASH_Handle.RDPLevel); 

BORTimeout = BOR_FLAG_TIMEOUT; 

while (HAL_FLASHEx_OBProgram(&FLASH_Handle) != HAL_OK){ 

if((BORTimeout--) == 0){DEBUGPRINT("HAL_FLASHEx_OBProgram Fail\r\n");break;}

DEBUGPRINT("HAL_FLASHEx_OBProgram\r\n"); 

BORTimeout = BOR_FLAG_TIMEOUT; 

while (HAL_FLASH_OB_Lock() != HAL_OK){ 

if((BORTimeout--) == 0){DEBUGPRINT("HAL_FLASH_OB_Lock Fail\r\n");break;}

DEBUGPRINT("HAL_FLASH_OB_Lock\r\n"); 

BORTimeout = BOR_FLAG_TIMEOUT; 

while (HAL_FLASH_Lock() != HAL_OK){ 

if((BORTimeout--) == 0){DEBUGPRINT("HAL_FLASH_Lock Fail\r\n");break;}

DEBUGPRINT("HAL_FLASH_Lock\r\n"); 

}

}

}

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.06.13 23:08

금번에 세미나를 다녀왔습니다.

주제중에서 Invasive Attack(Invasive Attack, Semiinvasive attack, Non invasive attack)과 관련된 내용이 있었는데 클럭 어택과 관련한 내용이 흥미로웠습니다.(연구하시는 분들은 예전부터 알고 계셨겠지만 전 처음이었습니다.)

X-TAL의 클럭 입력에서 클럭에 노이즈를 넣으면(한 클럭이 들어가야하는 데 클럭 노이즈를 실어서 2클럭을 집어넣는 경우 같은) 명령어를 뛰어넘어서 처리하는 경우가 있다는 설명이었습니다.

대표적인게 if, else 구문인데요.

 

편하게 8비트 어셈인 PIC로 비교하면 

f레지스터의 비트 b가 0이면 GOTO exit로 가고 그렇지 않으면 GOTO loop로 가는 명령이 있습니다. if else로 프로그램으로 짜면 저렇게 명령어 셋으로 들어가고 하나의 사이클에 하나의 번지씩 이동하게 됩니다.

 

BTFSC f, b

GOTO loop

GOTO exit

 

그런데 입력 클럭에 임의의 노이즈를 넣어서 주는 경우에는 f레지스터의 비트 b가 0이 아닌데도 불구하고  GOTO exit로 나갈 수 있다는 거죠. 그런데 이런 구문이 사용자의 아이디와 패스워드를 입력하고 확인하는 찰나에 들어간다면 틀린 패스워드에서도 정상 패스워드로 인식할 수 있습니다. 큰일이죠.

세미나에서는 이중 if문이나 case문을 제안하였습니다.

 

 제가 교육 갔었던 의료기기 Software V&V에서는 저런 상황 때문인지는 모르지만 if else는 쓰고 case문은 사용하는 것을 지양하라고 했습니다. 이상 상황시 아예 이상한 곳으로 가서 이상동작을 하는 것을 방지하는 차원이었겠지요.(실상 수천, 수만개의 제품을 다양한 곳에서 사용하다보면 전혀 예상하지 못하는 동작을 하는 경우도 있습니다. 그래서 프로그램은 한줄만 짜도 버그가 생길 수 있다고 생각합니다.)

 

이 부분 때문에 고민을 많이해야 할 것 같습니다.

 

또 하나의 마음에 드는 이슈가 있었는데요. 패스워드를 확인하고 처리하는 부분에서 한자리씩 확인한 다음에 틀린 부분에서 바로 빠져 나가는 경우 공격자가 시간을 확인하여 오래 걸리는 정도에 따라 몇자리까지 맞췄는 지 알 수 있는 부분이었습니다.

저도 통상적으로 이렇게 짜왔는데 앞으로는 타이머를 돌려서 맞든 틀리든 간에 일정 시간에 에러나 정상을 리턴하도록 짜야 할 것 같습니다.

 

 

세미나를 듣다보니 SOC를 직접 하는 부분도 상당히 끌렸는데요. 코어나 패리를 만드는 게 아닌 직접 침투를 방어하는 부분에 재미있었습니다. 상하에 랜덤패턴과 랜덤 데이터를 넣어서 비교기에서 서로 데이터가 다를 경우 직접 침투가 발생했다는 것을 알 수 있다는 부분입니다. 특수 칩도 아니고 일반 칩을 내부까지 직접까서 베끼다니 그렇게 까지 해야해? 라고 생각했는데 프린트 잉크 시장의 30%정도가 복사 잉크라고 하고 거기의 칩들이 복제칩이라고 하니 그럴만 하다고 생각했습니다.

 opamp를 넣고 히스테리시스 회로를 추가하여 조금 더 안정되게 만들면 어떨까? 라는 생각도 살짝 해봤습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

  1. uocraft 2018.06.19 18:50 신고  댓글주소  수정/삭제  댓글쓰기

    음 좋은 생각이네요

  2. 초보 HW 엔지니어 로망와니 2018.06.19 23:58 신고  댓글주소  수정/삭제  댓글쓰기

    그 외에도 다양한 것들이 있었어요. ㅎㅎ SRAM의 Cold boot Attack은 많이 알려진 기술이지만 그렇지 않더라도 삭제되는데 걸리는 시간을 이용한 어택이라던지 많이 사용되는 전류 소모를 확인하여 키값 확인하는 부분에서 내부에 Switching Regulator에서 처럼 내부 전원을 스위칭하여 같은 전류를 소모하게 하여(별로 좋은 생각은 아니였습니다.내부 노이즈가 다른 회로단에 문제를 줄 여지가 많아서) 확인을 어렵게 하기 라던지 재미있는 것들이 많았습니다.

2018.05.30 10:04

Low Layer Driver을 사용한 ADC

들어오는 ADC 값의 움직임을 크게 주기 위해 샘플링 주기를 짧게 가져왔습니다.(LL_ADC_SAMPLINGTIME_2CYCLES_5)

 

int main(void)
{

 uint32_t nBuf[128];

 uint8_t i;


  /* Configure the system clock to 80 MHz */
 SystemClock_LLConfig();
  /* ADC Configuration */
 ADC_Configuration(); 

 while(1){

  GetADC1(chBuf);

  for(i = 0; i< 11; i++){

   UART1_printf("ADC0 =%02X \r\n", chBuf[i]);

  }
 }

}

 

 

 

#include "math.h"
#include "usr_adc.h"
#include "usr_usart.h"

#include "stm32l4xx_ll_dma.h"
#include "stm32l4xx_ll_adc.h"
#include "stm32l4xx_ll_bus.h"
#include "stm32l4xx_ll_rcc.h"
#include "stm32l4xx_ll_gpio.h"


/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/

/* Variables for ADC conversion data */
__IO uint16_t aADCxConvertedData[ADC_CONVERTED_DATA_BUFFER_SIZE]; /* ADC group regular conversion data */


/*******************************************************************************
* Function Name :
* Parameters    : None
* Return        : None
* Description   :
*******************************************************************************/
void ADC_Configuration(void)
{
 ADCDMA_Init(eADCIntDisable);
 ADC_Init(eADCIntDisable);
 Activate_ADC();
}

/*******************************************************************************
* Function Name :
* Parameters    : None
* Return        : None
* Description   :
*******************************************************************************/
void ADCDMA_Init(const ADCEnableState a_chInt)
{
  /*## Configuration of DMA ##################################################*/
  /* Enable the peripheral clock of DMA */
  LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA1);
 
  /* Configure the DMA transfer */
  /*  - DMA transfer in circular mode to match with ADC configuration:        */
  /*    DMA unlimited requests.                                               */
  /*  - DMA transfer from ADC without address increment.                      */
  /*  - DMA transfer to memory with address increment.                        */
  /*  - DMA transfer from ADC by half-word to match with ADC configuration:   */
  /*    ADC resolution 12 bits.                                               */
  /*  - DMA transfer to memory by half-word to match with ADC conversion data */
  /*    buffer variable type: half-word.                                      */
  LL_DMA_ConfigTransfer(DMA1,
                        LL_DMA_CHANNEL_1,
                        LL_DMA_DIRECTION_PERIPH_TO_MEMORY |
                        LL_DMA_MODE_CIRCULAR              |
                        LL_DMA_PERIPH_NOINCREMENT         |
                        LL_DMA_MEMORY_INCREMENT           |
                        LL_DMA_PDATAALIGN_HALFWORD        |
                        LL_DMA_MDATAALIGN_HALFWORD        |
                        LL_DMA_PRIORITY_HIGH               );
 
  /* Select ADC as DMA transfer request */
  LL_DMA_SetPeriphRequest(DMA1,
                          LL_DMA_CHANNEL_1,
                          LL_DMA_REQUEST_0);
 
  /* Set DMA transfer addresses of source and destination */
  LL_DMA_ConfigAddresses(DMA1,
                         LL_DMA_CHANNEL_1,
                         LL_ADC_DMA_GetRegAddr(ADC1, LL_ADC_DMA_REG_REGULAR_DATA),
                         (uint32_t)&aADCxConvertedData,
                         LL_DMA_DIRECTION_PERIPH_TO_MEMORY);
 
  /* Set DMA transfer size */
  LL_DMA_SetDataLength(DMA1,
                       LL_DMA_CHANNEL_1,
                       ADC_CONVERTED_DATA_BUFFER_SIZE);
 
  /*## Activation of DMA #####################################################*/
  /* Enable the DMA transfer */
  LL_DMA_EnableChannel(DMA1,
                       LL_DMA_CHANNEL_1);


 if(a_chInt == eADCIntEnable){
  /* Enable DMA transfer interruption: transfer complete */
  LL_DMA_EnableIT_TC(DMA1,
            LL_DMA_CHANNEL_1);
  
  /* Enable DMA transfer interruption: transfer error */
  LL_DMA_EnableIT_TE(DMA1,
            LL_DMA_CHANNEL_1);

  /*## Configuration of NVIC #################################################*/
  /* Configure NVIC to enable DMA interruptions */
  NVIC_SetPriority(DMA1_Channel1_IRQn, 1);  /* DMA IRQ lower priority than ADC IRQ */
  NVIC_EnableIRQ(DMA1_Channel1_IRQn);
 }              
}

/*******************************************************************************
* Function Name :
* Parameters    :
* Return        : None
* Description   :
*******************************************************************************/
void ADC_Init(const ADCEnableState a_chInt)
{
  __IO uint32_t wait_loop_index = 0;
 
  /*## Configuration of GPIO used by ADC channels ############################*/
 LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOA);
 LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOB);

  /* Configure GPIO in analog mode to be used as ADC input */
  LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_1, LL_GPIO_MODE_ANALOG);//ADC_IN1
  LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_2, LL_GPIO_MODE_ANALOG);//ADC_IN2
  LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_3, LL_GPIO_MODE_ANALOG);//ADC_IN3
  LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_4, LL_GPIO_MODE_ANALOG);//ADC_IN4
  LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_5, LL_GPIO_MODE_ANALOG);//ADC_IN5
  LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_6, LL_GPIO_MODE_ANALOG);//ADC_IN6
  LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_7, LL_GPIO_MODE_ANALOG);//ADC_IN7
 
  LL_GPIO_SetPinMode(GPIOB, LL_GPIO_PIN_0, LL_GPIO_MODE_ANALOG);//ADC_IN8
  LL_GPIO_SetPinMode(GPIOB, LL_GPIO_PIN_1, LL_GPIO_MODE_ANALOG);//ADC_IN9


  /*## Configuration of ADC ##################################################*/
  /* Enable ADC clock (core clock) */
  LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_ADC);
 
  if(__LL_ADC_IS_ENABLED_ALL_COMMON_INSTANCE() == 0)
  {
    /* Set ADC clock (conversion clock) common to several ADC instances */
    LL_ADC_SetCommonClock(__LL_ADC_COMMON_INSTANCE(ADC1), LL_ADC_CLOCK_SYNC_PCLK_DIV2);
    /* Set ADC measurement path to internal channels */
    LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(ADC1), (LL_ADC_PATH_INTERNAL_VREFINT | LL_ADC_PATH_INTERNAL_TEMPSENSOR));
   
    /* Delay for ADC temperature sensor stabilization time.                   */
    wait_loop_index = ((LL_ADC_DELAY_TEMPSENSOR_STAB_US * (SystemCoreClock / (100000 * 2))) / 10);
    while(wait_loop_index != 0)
    {
      wait_loop_index--;
    }
    /* Set ADC multimode configuration */
    // LL_ADC_SetMultimode(__LL_ADC_COMMON_INSTANCE(ADC1), LL_ADC_MULTI_INDEPENDENT);
   
    /* Set ADC multimode DMA transfer */
    // LL_ADC_SetMultiDMATransfer(__LL_ADC_COMMON_INSTANCE(ADC1), LL_ADC_MULTI_REG_DMA_EACH_ADC);
   
    /* Set ADC multimode: delay between 2 sampling phases */
    // LL_ADC_SetMultiTwoSamplingDelay(__LL_ADC_COMMON_INSTANCE(ADC1), LL_ADC_MULTI_TWOSMP_DELAY_1CYCLE);
  }
 
  /*## Configuration of ADC hierarchical scope: ADC instance #################*/
  if (LL_ADC_IsEnabled(ADC1) == 0)
  {
   /* Note: Call of the functions below are commented because they are       */
    /*       useless in this example:                                         */
    /*       setting corresponding to default configuration from reset state. */
   
    /* Set ADC data resolution */
    // LL_ADC_SetResolution(ADC1, LL_ADC_RESOLUTION_12B);
   
    /* Set ADC conversion data alignment */
    // LL_ADC_SetResolution(ADC1, LL_ADC_DATA_ALIGN_RIGHT);
   
    /* Set ADC low power mode */
    // LL_ADC_SetLowPowerMode(ADC1, LL_ADC_LP_MODE_NONE);
   
    /* Set ADC selected offset number: channel and offset level */
    // LL_ADC_SetOffset(ADC1, LL_ADC_OFFSET_1, LL_ADC_CHANNEL_9, 0x000);
  }
 
  /*## Configuration of ADC hierarchical scope: ADC group regular ############*/
  if ((LL_ADC_IsEnabled(ADC1) == 0)               ||
      (LL_ADC_REG_IsConversionOngoing(ADC1) == 0)   )
  {
    /* Set ADC group regular trigger source */
    LL_ADC_REG_SetTriggerSource(ADC1, LL_ADC_REG_TRIG_SOFTWARE);
   
    /* Set ADC group regular trigger polarity */
    // LL_ADC_REG_SetTriggerEdge(ADC1, LL_ADC_REG_TRIG_EXT_RISING);
   
    /* Set ADC group regular continuous mode */
    LL_ADC_REG_SetContinuousMode(ADC1, LL_ADC_REG_CONV_SINGLE);
//    LL_ADC_REG_SetContinuousMode(ADC1, LL_ADC_REG_CONV_CONTINUOUS);
   
    /* Set ADC group regular conversion data transfer */
    // LL_ADC_REG_SetDMATransfer(ADC1, LL_ADC_REG_DMA_TRANSFER_NONE);
    LL_ADC_REG_SetDMATransfer(ADC1, LL_ADC_REG_DMA_TRANSFER_UNLIMITED);
   
    /* Set ADC group regular overrun behavior */
    LL_ADC_REG_SetOverrun(ADC1, LL_ADC_REG_OVR_DATA_OVERWRITTEN);
   
    /* Set ADC group regular sequencer length and scan direction */
//    LL_ADC_REG_SetSequencerLength(ADC1, LL_ADC_REG_SEQ_SCAN_DISABLE);
    LL_ADC_REG_SetSequencerLength(ADC1, LL_ADC_REG_SEQ_SCAN_ENABLE_11RANKS);
   
    /* Set ADC group regular sequencer discontinuous mode */
    // LL_ADC_REG_SetSequencerDiscont(ADC1, LL_ADC_REG_SEQ_DISCONT_DISABLE);
   
    /* Set ADC group regular sequence: channel on the selected sequence rank. */
    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_1, LL_ADC_CHANNEL_6);
    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_2, LL_ADC_CHANNEL_7);
    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_3, LL_ADC_CHANNEL_8);
    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_4, LL_ADC_CHANNEL_9);
    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_5, LL_ADC_CHANNEL_10);
    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_6, LL_ADC_CHANNEL_11);
    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_7, LL_ADC_CHANNEL_12);
    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_8, LL_ADC_CHANNEL_15);
    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_9, LL_ADC_CHANNEL_16);
    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_10, LL_ADC_CHANNEL_VREFINT);
    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_11, LL_ADC_CHANNEL_TEMPSENSOR);
  }

  /*## Configuration of ADC hierarchical scope: ADC group injected ###########*/
  if ((LL_ADC_IsEnabled(ADC1) == 0)               ||
      (LL_ADC_INJ_IsConversionOngoing(ADC1) == 0)   )
  {
    /* Note: Call of the functions below are commented because they are       */
    /*       useless in this example:                                         */
    /*       setting corresponding to default configuration from reset state. */
   
    /* Set ADC group injected trigger source */
    // LL_ADC_INJ_SetTriggerSource(ADC1, LL_ADC_INJ_TRIG_SOFTWARE);
   
    /* Set ADC group injected trigger polarity */
    // LL_ADC_INJ_SetTriggerEdge(ADC1, LL_ADC_INJ_TRIG_EXT_RISING);
   
    /* Set ADC group injected conversion trigger  */
    // LL_ADC_INJ_SetTrigAuto(ADC1, LL_ADC_INJ_TRIG_INDEPENDENT);
   
    /* Set ADC group injected contexts queue mode */
    /* Note: If ADC group injected contexts queue are enabled, configure      */
    /*       contexts using function "LL_ADC_INJ_ConfigQueueContext()".       */
    // LL_ADC_INJ_SetQueueMode(ADC1, LL_ADC_INJ_QUEUE_DISABLE);
   
    /* Set ADC group injected sequencer */
    /* Note: On this STM32 serie, ADC group injected sequencer is             */
    /*       fully configurable: sequencer length and each rank               */
    /*       affectation to a channel are configurable.                       */
    /*       Refer to description of function                                 */
    /*       "LL_ADC_INJ_SetSequencerLength()".                               */
   
    /* Set ADC group injected sequencer length and scan direction */
    // LL_ADC_INJ_SetSequencerLength(ADC1, LL_ADC_INJ_SEQ_SCAN_DISABLE);
   
    /* Set ADC group injected sequencer discontinuous mode */
    // LL_ADC_INJ_SetSequencerDiscont(ADC1, LL_ADC_INJ_SEQ_DISCONT_DISABLE);
   
    /* Set ADC group injected sequence: channel on the selected sequence rank. */
    // LL_ADC_INJ_SetSequencerRanks(ADC1, LL_ADC_INJ_RANK_1, LL_ADC_CHANNEL_9);
  }
 
 
  /*## Configuration of ADC hierarchical scope: channels #####################*/
  if ((LL_ADC_IsEnabled(ADC1) == 0)                    ||
      ((LL_ADC_REG_IsConversionOngoing(ADC1) == 0) &&
       (LL_ADC_INJ_IsConversionOngoing(ADC1) == 0)   )   )
  {
  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_6, LL_ADC_SAMPLINGTIME_2CYCLES_5);
  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_7, LL_ADC_SAMPLINGTIME_2CYCLES_5);
  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_8, LL_ADC_SAMPLINGTIME_2CYCLES_5);
  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_9, LL_ADC_SAMPLINGTIME_2CYCLES_5);
  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_10, LL_ADC_SAMPLINGTIME_2CYCLES_5);
  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_11, LL_ADC_SAMPLINGTIME_2CYCLES_5);
  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_12, LL_ADC_SAMPLINGTIME_2CYCLES_5);
  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_15, LL_ADC_SAMPLINGTIME_2CYCLES_5);
  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_16, LL_ADC_SAMPLINGTIME_2CYCLES_5);
    LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_VREFINT, LL_ADC_SAMPLINGTIME_2CYCLES_5);
    LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_TEMPSENSOR, LL_ADC_SAMPLINGTIME_2CYCLES_5);
   
  }
 
  /*## Configuration of ADC transversal scope: analog watchdog ###############*/ 
  /* Set ADC analog watchdog channels to be monitored */
  // LL_ADC_SetAnalogWDMonitChannels(ADC1, LL_ADC_AWD1, LL_ADC_AWD_DISABLE);
 
  /* Set ADC analog watchdog thresholds */
  // LL_ADC_ConfigAnalogWDThresholds(ADC1, LL_ADC_AWD1, 0xFFF, 0x000);
 
 
  /*## Configuration of ADC transversal scope: oversampling ##################*/
 
  /* Set ADC oversampling scope */
  // LL_ADC_SetOverSamplingScope(ADC1, LL_ADC_OVS_DISABLE);
 
  /* Set ADC oversampling parameters */
  // LL_ADC_ConfigOverSamplingRatioShift(ADC1, LL_ADC_OVS_RATIO_2, LL_ADC_OVS_SHIFT_NONE);
 
  /*## Configuration of ADC transversal scope: oversampling ##################*/
  /*## Configuration of ADC interruptions ####################################*/
  /* Enable interruption ADC group regular overrun */
  if(a_chInt == eADCIntEnable){
  /*## Configuration of NVIC #################################################*/
  /* Configure NVIC to enable ADC1 interruptions */
   NVIC_SetPriority(ADC1_2_IRQn, 0); /* ADC IRQ greater priority than DMA IRQ */
   NVIC_EnableIRQ(ADC1_2_IRQn);

   LL_ADC_EnableIT_EOS(ADC1);

   LL_ADC_EnableIT_OVR(ADC1); 
  }
}

/*******************************************************************************
* Function Name :
* Parameters    : None
* Return        : None
* Description   :
*******************************************************************************/
void ConversionStartPoll_ADC_GrpRegular(void)
{
  #if (USE_TIMEOUT == 1)
  uint32_t Timeout = 0; /* Variable used for timeout management */
  #endif /* USE_TIMEOUT */
  
  if ((LL_ADC_IsEnabled(ADC1) == 1)               &&
      (LL_ADC_IsDisableOngoing(ADC1) == 0)        &&
      (LL_ADC_REG_IsConversionOngoing(ADC1) == 0)   )
  {
    LL_ADC_REG_StartConversion(ADC1);
  }
  else
  {
    /* Error: ADC conversion start could not be performed */

  }
 
  #if (USE_TIMEOUT == 1)
  Timeout = ADC_UNITARY_CONVERSION_TIMEOUT_MS;
  #endif /* USE_TIMEOUT */
 
  while (LL_ADC_IsActiveFlag_EOC(ADC1) == 0)
  {
  #if (USE_TIMEOUT == 1)
    /* Check Systick counter flag to decrement the time-out value */
    if (LL_SYSTICK_IsActiveCounterFlag())
    {
      if(Timeout-- == 0)
      {

      }
    }
  #endif /* USE_TIMEOUT */
  }

  LL_ADC_ClearFlag_EOC(ADC1); 
}

/*******************************************************************************
* Function Name :
* Description   :
* Parameters    :
* Return        :
* Description   :
*******************************************************************************/
int32_t GetADC1(uint16_t *chpADC)
{
 uint8_t ADCLoop;
 
  if ((LL_ADC_IsEnabled(ADC1) == 1)               &&
      (LL_ADC_IsDisableOngoing(ADC1) == 0)        &&
      (LL_ADC_REG_IsConversionOngoing(ADC1) == 0)   )
  {
    LL_ADC_REG_StartConversion(ADC1);
  }
  else
  {
    /* Error: ADC conversion start could not be performed */
    UART1_printf("Error\r\n");
  }
 
 for(ADCLoop = 0; ADCLoop < ADC_CONVERTED_DATA_BUFFER_SIZE; ADCLoop++){
  chpADC[ADCLoop] = __LL_ADC_CALC_DATA_TO_VOLTAGE(VDDA_APPLI, aADCxConvertedData[ADCLoop], LL_ADC_RESOLUTION_12B);
 }

 return __LL_ADC_CALC_TEMPERATURE(VDDA_APPLI, aADCxConvertedData[ADC_CONVERTED_DATA_BUFFER_SIZE - 1], LL_ADC_RESOLUTION_12B);
}

/*******************************************************************************
* Function Name :
* Parameters    : None
* Return        : None
* Description   :
*******************************************************************************/
void AdcGrpRegularOverrunError_Callback(void)
{
  /* Disable ADC group regular overrun interruption */
  LL_ADC_DisableIT_OVR(ADC1);
}

/*******************************************************************************
* Function Name :
* Parameters    : None
* Return        : None
* Description   :
*******************************************************************************/
void AdcGrpRegularSequenceConvComplete_Callback(void)
{
}

/*******************************************************************************
* Function Name :
* Parameters    : None
* Return        : None
* Description   :
*******************************************************************************/
void AdcDmaTransferError_Callback(void)
{
}

/*******************************************************************************
* Function Name :
* Parameters    : None
* Return        : None
* Description   :
*******************************************************************************/
void AdcDmaTransferComplete_Callback(void)
{
}

 
Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

  1. uocraft 2018.06.19 18:51 신고  댓글주소  수정/삭제  댓글쓰기

    ADC값의 움직임이 커지겠군요

2018.05.17 08:59

WWDG에서 Watchdog 발생시 클리어 처리

WWDG 사용중에 특정 목적에서는 WWDG가 동작하지 않아야하는데 이런 목적으로 사용할 경우 인터럽트에서 클리어 처리 해주어야 합니다. WWDG나 IWDG는 동작하도록 한번 설정을 하면 플래그에 다시 사용히자 않도록 설정을 하여도 되지 않습니다. 이럴 때를 위해서 인터럽트과 인터럽트가 아닌 곳에서 처리하도록 양쪽에 처리를 하였습니다.

(STM32L432에서 구현된 부분)

메인 .c

tFunc_Typedef  Func_Operate[] =
{
 /* Random Source */
// {GenRandom, "GetADC", 0}, 

 /* UART */
 {GetuPacket, "GetUartPacket", 0},
 /* SPI */
 {GetsPacket, "GetSPIPacket", 0},

 /* Input Button - Erase Function */
 {InputStatus, "InputStatus", 0},
 
 /* Output Status Pulse Wave For Normal Operation */
 {OutputStatus, "OutputStatus", 0},
 
 /* WatchDog Timer Reset */
 {SetWWDGCount, "SetWWDGCount", 0},
};

 

void main(void)

{

 /* Watch Dog Timer Configuration */
 WWDG_Configuration();
 OUTPUT_On(OUTPUTPIN_2);  
 while(1){
    if(Func_Operate[FuncIndex++].OperateFunc() == exit){break;}
  if (FuncIndex >= COUNT_OF_FUNCTION(Func_Operate)){
   FuncIndex = 0;
  }
 }

인터럽트가 발생하지 않으면서 처리해야하는 부분

....

}

 

인터럽트 처리 .c

void WWDG_IRQHandler(void)
{
  if(LL_WWDG_IsActiveFlag_EWKUP(WWDG) == 1)
  {
    /* Clear the Autoreload match interrupt flag */
    LL_WWDG_ClearFlag_EWKUP(WWDG);
   
    WWDG_Callback();
  }
}

 

관련 제어 파일 .c

/* Includes ------------------------------------------------------------------*/
#include "usr_wwdg.h"
#include "usr_usart.h"

#include "stm32l4xx_ll_bus.h"
#include "stm32l4xx_ll_rcc.h"
#include "stm32l4xx_ll_wwdg.h"

uint8_t g_chWWDGEnableFlag = 0;
/*******************************************************************************
* Function Name :
* Parameters    :
* Return        : None
* Description   :
*******************************************************************************/
void WWDG_Reset(void)
{
  if (LL_RCC_IsActiveFlag_WWDGRST()) {
    /* clear WWDG reset flag */
    LL_RCC_ClearResetFlags();
  }
}

/*******************************************************************************
* Function Name :
* Parameters    :
* Return        : None
* Description   :
*******************************************************************************/
void WWDG_init(void)
{
  /* Enable the peripheral clock of DBG register (uncomment for debug purpose) */
  /*LL_DBGMCU_APB1_GRP1_FreezePeriph(LL_DBGMCU_APB1_GRP1_WWDG_STOP); */
 
  /* Enable the peripheral clock WWDG */
  LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_WWDG);

  /* Configure WWDG */
  LL_WWDG_SetPrescaler(WWDG, LL_WWDG_PRESCALER_8);
  LL_WWDG_SetWindow(WWDG, WWDGCNT);                
  LL_WWDG_SetCounter(WWDG, WWDGCNT);          
  LL_WWDG_Enable(WWDG);          

 
 NVIC_SetPriority(WWDG_IRQn, 0); 
 NVIC_EnableIRQ(WWDG_IRQn);
 
 LL_WWDG_EnableIT_EWKUP(WWDG);  
}

/*******************************************************************************
* Function Name :
* Parameters    : None
* Return        : None
* Description   :
void WWDG_IRQHandler(void)
{
  if(LL_WWDG_IsActiveFlag_EWKUP(WWDG) == 1)
  {
    LL_WWDG_ClearFlag_EWKUP(WWDG);
   
    WWDG_Callback();
  }
}
*******************************************************************************/ 
void WWDG_Callback(void)
{
 if(g_chWWDGEnableFlag == 0){
  SetWWDGCount();
 }
 else{
  UART1_printf("SetWWDG Non Clear\r\n");
 }
}

/*******************************************************************************
* Function Name :
* Parameters    :
* Return        : None
* Description   :
*******************************************************************************/
void GetWWDGCount(void)
{
 LL_WWDG_GetCounter(WWDG);
}

/*******************************************************************************
* Function Name :
* Parameters    :
* Return        : None
* Description   :
*******************************************************************************/
uint32_t SetWWDGCount(void)
{
 LL_WWDG_SetCounter(WWDG, WWDGCNT);
 
 return 1;
}

/*******************************************************************************
* Function Name :
* Parameters    :
* Return        : None
* Description   :
*******************************************************************************/
void WWDG_Configuration(void)
{
 WWDG_Reset();
  WWDG_init();
 g_chWWDGEnableFlag = 1;
}

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2018.05.12 08:28

Maxim사의 MAX3xxxx 칩입니다.

Maxim을 선택한 이유는 RSA 키 생성이 하드웨어로 되어있어 생성 가능하다는 부분이 매력적이었습니다. Big Integer 소수를 MCU급에서 생성한다는 게 너무 어렵습니다. (사실 돌려봤었는데 십여분 기다리다가 생성이 안되서 포기했습니다. 사용하는 유저가 몇초만 기다려도 너무 오래걸린다고 생각하는데 분단위로도 생성이 안된다니!!! - 도어락 개발할 때 문 열릴 때 모터 돌아가는 그 몇초도 길다고 생각해서 멜로디를 넣어 체감시간을 다른 방향으로 돌렸는데 말이죠.) 이 소수 생성기는 추후에 동형 암호에 사용하려고 생각하고 있습니다. (이 MCU에서 별도로 소수 생성 부분만 빼줄 수 있도록 내부 로직이 설계되어 있다면요...)

 

Maxim의 컴파일러는 대부분의 무료툴들처럼 기본적으로 GCC 컴파일러를 Eclipse 환경에 링크시켜 사용하도록 되어 있습니다.(Eclipse 환경이라고 툴이 다 무료는 아닙니다. - DS5나 RealView 같은건 유료 툴!!!) Maxim 사는 NDA를 맺고 자료를 Open 하는 것을 매우 꺼려하므로 이 글이 처음이자 마지막이 될 것 같습니다. 사용하면서 장단점과 같은 부분도 공유할 수 없을 것 같습니다.

처음 SDK Folder 안에 예제를 가져와야겠다는 생각에 C:\Program Files (x86)\Maxim Integrated\MAX32558 폴더 안에 자료를 import 하려했습니다. 그런데 프로젝트 파일이 없어서 처음 접하는 사람은 어렵겠구나 생각하며 Project 만들기에 돌입하였습니다. 진행하다보니 두둥!! import할 수있도록 Project만 없고 만들면서 선택하는 부분에 다 들어있었습니다. (위의 판단이 성급했던 부분 죄송합니다.)

개발 보드를 처음 받았을 때도 ST처럼 싸게 많이 풀었으면 했는데 보면서 초도에 개발보드 구매비용은 비싸도 여러칩을 변경하면서 사용할 수 있도록 되어있는 걸보며 다른 방향으로 고민을 많이 했겠구나하는 생각을 했었습니다.(참고로 MCU Socket에 넣어서 발송이 되어 왔는데 받아보니 MCU가 빠져있었습니다. 회로를 아는 사람이야 데이터 시트를 보며 넣으면 되는데 볼 줄 모르는 사람을 위해 이 부분도 배려가 좀 되어 있었으면 합니다.)

사용을 해보면서 공개해도 되는 부분은 공개하도록 하겠습니다.

 

 

'초보의 아웅다웅 설계하기 > Max3xxxx(Maxim)' 카테고리의 다른 글

MAXIM사의 Max3xxxx  (2) 2018.05.12
Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

  1. uocraft 2018.05.18 01:14 신고  댓글주소  수정/삭제  댓글쓰기

    그 Maxim이 아니었군요... 꼬무룩

2018.04.22 11:58

블루투스 관련 프로젝트를 하기 전에 페어링을 어떻게 하는 가 등을 보다보니 아래의 동영상을 찾게 되었습니다. 정상동작하는 지 확인해 보았으니 이제부터 시작이겠죠.

공부할 게 많은 프로젝트가 될 것 같습니다.

 

https://www.youtube.com/watch?v=Jn05CU3mxzo

 

 

 

Bluetooth_Tutorial.zip

 

 

 

 

 

 

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요