반응형

개발환경 CUBE MX + Keil

 

1. 프로젝트 생성 및 RCC 설정

- HSE 외부 크리스탈 사용(이미지 참고)

 

2. PA5 Output 설정

 

3. Code GENERATE 실행

 

4. Source Code 

 

int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */
  

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
/*
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);
HAL_Delay(1000);

HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET);
HAL_Delay(1000);

*/

// 두 코드 모두 동일 한 기능 수행

 

HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_5);
HAL_Delay(1000);

HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_5);
HAL_Delay(1000);
  }
  /* USER CODE END 3 */
}

 

5. F7 빌드 F8 컴파일

 

6. 컴파일 후 적용되지 않아 봤더니 Reset을 한번 해 주어야 함...

- 왜그런지는 잘 모르겠음... 일단 빌드업 부터 동작 확인 완료

 

다음 과제는 UART Serial 통신 구현

반응형

'Project > Nucleo-F103RB' 카테고리의 다른 글

Nucleo-F103RB Serial 통신3  (0) 2019.05.27
Nucleo-F103RB Serial 통신2  (0) 2019.05.21
Nucleo-F103RB 시리얼통신 입력으로 제어  (0) 2019.05.21
Nucleo-F103RB Serial 통신1  (0) 2019.05.21
Nucleo-F103RB 개발환경  (0) 2019.05.21
반응형

CUBE MX + Keil 

HAL 드라이버를 이용한 개발환경 구성

SYS, RCC 클럭 설정 내부클럭, 외부클럭 설정 방법 및 적용 방법

 

1. CUBE MX 새 프로젝트 생성

제품군 선택

 

2. Start Project

 

3. MCU UI와 새로운 프로젝트 생성이 됨.

 

4. 기본적으로 LED를 켜기위해 PA5 Output 설정만으로 LED를 켜고 끌 수 있음.

 

5. 클럭 설정은 PD0, PD1을 RCC_OSC_IN, RCC_OSC_OUT으로 설정한 뒤, 카테고리의 System Core탭 에서 설정이 가능하다.

설정이 되지 않을 경우 해당 핀이 주황색으로 출력이 되는 것을 볼 수 있다.

 

HSE 값을 crystal/ceramic resonator로 설정을 하게 되면 다음과 같이 핀이 녹색으로 정상적으로 적용이 된 것을 볼 수 있다.

 

6. Project Manger탭에 진입하여, 프로젝트 네임과 저장할 경로를 설정한다.

 

7. 나는 Keil V5를 사용할 것이기 때문에 Toolchain/IDE의 선택을 MDK-ARM V5로 선택한다.

자, 이제 설정이 완료되면 우측 상단의 GENERATE CODE버튼을 클릭하면 로딩바가 출력되며 완료시 폴더를 열지 Project를 열지 팝업 창이 출력된다.

 

다음 포스팅에서 LED를 OnOFF 참고.

 

반응형

'Project > Nucleo-F103RB' 카테고리의 다른 글

Nucleo-F103RB Serial 통신3  (0) 2019.05.27
Nucleo-F103RB Serial 통신2  (0) 2019.05.21
Nucleo-F103RB 시리얼통신 입력으로 제어  (0) 2019.05.21
Nucleo-F103RB Serial 통신1  (0) 2019.05.21
Nucleo-F103RB LED 켜기  (0) 2019.05.21
반응형
[기본적인 배선의 순서]

1.전원부 (파워, 그라운드)
파워의 흐름을 고려해서 부품을 배치하고, 파워배선의 길을 잡는다.
전류가 많이 흐르는 배선은 넓은 폭의 배선이 필요하므로 파워전용층으로 배선하는
것이 좋다.


2.클럭라인
클럭라인부터 짧은 경로로 배선을 한다.
크리스탈등의 배선은 가능하다면 쉴드를 해서 배선한다.


3.중요한 신호라인
중요한 신호라인은 짧은 경로로 배선한다. 임피던스 매칭회로일 경우에는 임피던스
계산값에 따른 배선폭으로 배선한다.


4.일반배선

     위의 중요한 신호들의 경로에서 남는 레이어를 활용하여 배선을 한다.


[신호라인의 배선설계 방법]

1.고정된 커넥터를 중심으로 배선 설계

2.제한된 기판에 배선밀도가 가장높은 부품(MPU, FPGA, Memory등)부터 배선 설계

3.1,2 방법중 하나를 선택하여 배선설계를 한 후, 라우팅을 하지 않은 신호라인중에서
길이가 긴 신호라인부터 설계하고, 짧은 신호라인을 설계한다.

협업으로 설계할 경우에 1,2 방법을 서로 나눠서 설계 진행할 수 도 있다.


[배선 경로가 막막할때 해결법]

1.일반신호라인의 폭과 간격을 줄인다.

     임피던스 매칭이 불필요한 일반신호의 배선폭과 간격을 줄여서 배선 공간을 확보

2.여러층으로 배선되어있는 배선들을 하나의 Layer를 몰고, 층을 확보한다.

     특정층의 배선을 고집하지 말고, 차선과 차차선Layer를 생각하고 배선한다.

3.부품들의 위치를 변경한다.

     부품의 배치를 수정하여 배선 공간을 확보 할수 있는지 충분히 검토한다.

4.게이트 형태의 소자 내의 다른 게이트를 활용한다.

5.부품의 형태(Package)를 변경한다.
반응형
반응형

/* Atmega128 mtx128-s2보드와 ds3231 rtc모듈, char LCD wc0802C 제품으로 시계를 만들었다.

기능들을 함수로 빼놓았기 때문에 나중에 회로도와 핀맵만 맞는다면 사용할 수 있다.

회로도 그리기 너무 귀찮다아아

*/


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
/*
 * char_lcd.c
 *
 * Created: 2019-01-21 오후 4:25:21
 * Author : admin
 */
 
#include <avr/io.h>
#define F_CPU 16000000
#include <util/delay.h>
#include <stdio.h>
 
#define PORT_DATA PORTD
#define PORT_CONTROL PORTC
#define DDR_DATA DDRD
#define DDR_CONTROL DDRC
 
#define RS_PIN 0
#define RW_PIN 1
#define E_PIN 2
 
#define COMMAND_CLEAR_DISPLAY 0x01
#define COMMAND_8_BIT_MODE 0x38
#define COMMAND_4_BIT_MODE 0x28
 
#define COMMAND_DISPLAY_ON_OFF_BIT 2
#define COMMAND_CURSOR_ON_OFF_BIT 1
#define COMMAND_BLINK_ON_OFF_BIT 0
 
extern uint8_t MODE;
 
void LCD_Pulse_enable();
void LCD_write_data(uint8_t data);
void LCD_write_command(uint8_t command);
void LCD_clear();
void LCD_init();
void LCD_write_string(char *string);
void LCD_goto_XY(uint8_t row, uint8_t col);
//////////////////////////////////////////////////////////
 
void LCD_Pulse_enable(){
    PORT_CONTROL |= (1<<E_PIN);
    _delay_us(1);
    PORT_CONTROL &= ~(1<<E_PIN);
    _delay_us(1);
}
void LCD_write_data(uint8_t data){
    PORT_CONTROL |= (1<<RS_PIN);
    if(MODE == 8){
        PORT_DATA = data;
        LCD_Pulse_enable();
    }
    else{
        PORT_DATA = data& 0xf0;
        LCD_Pulse_enable();
        PORT_DATA = (data<<4)&0xf0;
        LCD_Pulse_enable();
    }
    _delay_ms(2);
}
void LCD_write_command(uint8_t command){
    PORT_CONTROL&= ~(1<<RS_PIN);
    
    if(MODE ==8){
        PORT_DATA =command;
        LCD_Pulse_enable();
    }
    else {
        PORT_DATA = command & 0xf0;
        LCD_Pulse_enable();
        PORT_DATA = (command <<4& 0xf0;
        LCD_Pulse_enable();
    }
    _delay_ms(2);
}
void LCD_clear(){
    LCD_write_command(COMMAND_CLEAR_DISPLAY);
    _delay_ms(2);
}
void LCD_init(){
    _delay_ms(50);
    if(MODE == 8){
        DDR_DATA =0xff;
    }
    else DDR_DATA |= 0xf0;
    PORT_DATA = 0x00;
    DDR_CONTROL |= (1<<RS_PIN)|(1<<RW_PIN)|(1<<E_PIN);
    
    PORT_CONTROL &= ~(1<<RW_PIN);
    
    if(MODE == 8){
        LCD_write_command(COMMAND_8_BIT_MODE);
    }
    else{
        LCD_write_command(0x02);
        LCD_write_command(COMMAND_4_BIT_MODE);
    }
    
    uint8_t command = 0x08|(1<<COMMAND_DISPLAY_ON_OFF_BIT);
    LCD_write_command(command);
    
    LCD_clear();
    
    LCD_write_command(0x06);
}
void LCD_write_string(char *string){
    uint8_t i;
    for(i=0;string[i];i++){
        LCD_write_data(string[i]);
    }
}
void LCD_goto_XY(uint8_t row, uint8_t col){
    col %=16;
    row%=2;
    
    uint8_t address = (0x40*row)+col;
    uint8_t command =0x80+address;
    
    LCD_write_command(command);
}
 
uint8_t MODE = 4;
 
#define I2C_SCL PD0
#define I2C_SDA PD1
 
unsigned int sec, min, hour, day, month, year, week;
 
 
void uartInit(long buadrate)
{
    UCSR0A = 0x00// ready flag clear
    UCSR0B = 0x18// rx, tx enable
    UCSR0C = 0x06// tx data len : 8bit
    UBRR0H = 0;
    switch(buadrate){
        case 115200:
        UBRR0L = 8;
        break;
        
        case 57600:
        UBRR0L = 16;
        break;
        
        case 38400:
        UBRR0L = 25;
        break;
        
        case 19200:
        UBRR0L = 51;
        break;
        
        case 14400:
        UBRR0L = 68;
        break;
        
        case 9600:
        UBRR0L = 103;
        break;
        
        // Default 19200
        default:
        UBRR0L = 51;
        break;
    }
}
void send_data(unsigned char data)
{
    while(!(UCSR0A&0x20)); // 송신데이터를 받을 준비가 될때까지 대기
    UDR0 = data;
}
void SendLine(char *string)
{
    while(*string != '\0')
    {
        send_data(*string);
        string++;
    }
}
 
void init_i2c(){
    DDRD |= (1<<I2C_SCL);
    DDRD |= (1<<I2C_SDA);
    
    TWBR = 32// 200khz
}
void i2c_start(){
    TWCR = (1<< TWINT)|(1<<TWSTA)|(1<<TWEN);
    while(!(TWCR&(1<<TWINT))); // 시작완료 대기
}
void i2c_transmit(uint8_t data){
    TWDR = data;
    TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWEA);
    while(!(TWCR&(1<<TWINT))); // 전송완료 대기
}
uint8_t i2c_receive_ACK(){
    TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWEA);
    while(!(TWCR&(1<<TWINT)));
    return TWDR;
}
uint8_t i2c_receive_NACK(){
    TWCR = (1<<TWINT)|(1<<TWEN);
    while(!(TWCR&(1<<TWINT))); // 수신완료 대기
    return TWDR;
}
void i2c_stop(){
    TWCR = (1<<TWINT)|(1<<TWSTO)|(1<<TWEN);
    _delay_us(100);
}
 
uint8_t bcd_to_decimal(uint8_t bcd){
    return (bcd>>4*10 +(bcd&0x0f);
}
uint8_t decimal_to_bcd(uint8_t decimal){
    return (((decimal/10)<<4)|(decimal%10));
}
 
int main(void)
{    
    LCD_init();
    char lcd_buff[100];
    init_i2c();
    
    sec = min = hour = day = month = year = week= 0;
    char str[1000];
    
    uint8_t address = 0x68;
    // 초 분 시 요일 일 월 연
    uint8_t date[] = {0,10,12,2,10,10,19};
    
    
    i2c_start();
    i2c_transmit(address <<1);
    i2c_transmit(0);
    for (int i =0; i<7;i++){
        i2c_transmit(decimal_to_bcd(date[i]));
    }
    i2c_stop();
    DDRA = 0xff;
    PORTA = 0x00;
    
    while (1
    {
        i2c_start();
        i2c_transmit(address <<1);
        i2c_transmit(0);
        i2c_stop();
        
        i2c_start();
        i2c_transmit((address<<1)+1);
        
        sec = bcd_to_decimal(i2c_receive_ACK());
        min = bcd_to_decimal(i2c_receive_ACK());
        hour = bcd_to_decimal(i2c_receive_ACK());
        week = bcd_to_decimal(i2c_receive_ACK());
        day = bcd_to_decimal(i2c_receive_ACK());
        month = bcd_to_decimal(i2c_receive_ACK());
        year = bcd_to_decimal(i2c_receive_NACK());
        
        i2c_stop();
        
        LCD_goto_XY(0,0);
        sprintf(lcd_buff,"%d/%d/%d",year,month,day);
        LCD_write_string(lcd_buff);
        LCD_goto_XY(1,0);
        sprintf(str,"%d:%d:%d",hour,min,sec);
        LCD_write_string(str);
        
        /* LCD example
        LCD_goto_XY(1,1);
        LCD_write_string("hi");
        */
        
        //sprintf(lcd_buff,"%d/%d/%d",year,month,day);
        //sprintf (str, "%d sec, %d min, %d hour, %d week, %d day, %d month, %d year\r\n",sec,min,hour,week,day,month,year);
        //sprintf(str,"%d sec\r\n",sec);
        
    }
    return 0;
}
cs


반응형
반응형

j-kit-128을 이용하여 전체적인 시스템을 구현중입니다.

현재까지

1.led
2.buzzer(PWM적용 필요)
3.fnd
4.timer
5.switch(Ext interrupt 구현 필요)
6.serial통신

//미구현
7.adc_dimmer
8.cds
9.i2c
10. 추가로 wifi모듈을 달아서 wifi 통신도 해 볼 예정입니다.

미구현 항목들은 기능에 대한 숙지가 부족하여 좀더 공부 할 필요가 있을 것 같습니다.
j-kit-128을 이용하여 복습하고, 해당 키트를 이용하여 공부하시는 분들에게 도움이 되고자? 만들게 되었습니다.

기능 구현 및 개선이 되는대로 업로드 하겠습니다.
저도 부족한 점이 많기에 많은 가르침 부탁드립니다.


=======================================================================================

추가적으로 기능 구현한 내용


1. CDS (adc값 읽기)

2. extSwitch (외부 키 인터럽트)


// 추가 구현 예정

void init_pwmDimmer();//pwm dimmer

void init_i2c();//i2c 온도센서

void init_pwmMotor(); //pwm motor

void init_pwmBuzzer(); //pwm buzzer

void init_INTSerial(); // uart인터럽트


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
#include <avr/io.h>
#define F_CPU 16000000UL
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdio.h>
 
#define FND_NUM0 0x3f
#define FND_NUM1 0x06
#define FND_NUM2 0x5b
#define FND_NUM3 0x4f
#define FND_NUM4 0x66
#define FND_NUM5 0x6d
#define FND_NUM6 0x7d
#define FND_NUM7 0x27
#define FND_NUM8 0x7f
#define FND_NUM9 0x6f
 
#define FND_SEL1 0x01
#define FND_SEL2 0x02
#define FND_SEL3 0x04
#define FND_SEL4 0x08
 
unsigned int fnd[10]= {FND_NUM0,FND_NUM1,FND_NUM2,FND_NUM3,FND_NUM4,FND_NUM5,FND_NUM6,FND_NUM7,FND_NUM8,FND_NUM9};
unsigned int fnd_sel[4= {FND_SEL1,FND_SEL2,FND_SEL3,FND_SEL4};
unsigned int count=0, sec=0;
 
char textBuff[100];
unsigned int extCount=0;
 
void init_led();
void init_buzzer();
void init_fnd();
void init_switch();
void init_timer();
void init_serial();
void init_adc();
void init_extSwitch();
 
/* 미구현
void init_pwmDimmer();//pwm dimmer
void init_i2c();//i2c 온도센서
void init_pwmMotor(); //pwm motor
void init_pwmBuzzer(); //pwm buzzer
void init_INTSerial(); // uart인터럽트
*/
 
void fnd_display(int num);
void SendByte(char data);
void SendLine(char *string);
char ReceiveByte();
uint16_t read_adc(uint8_t channel);
 
void test_led();
void test_buzzer();
void test_fnd();
void test_switch();
void test_serial();
void test_timer();
void test_adc();
void test_extSwitch();
 
int main(void)
{
    init_led();
    init_buzzer();
    init_fnd();
    init_switch();
    init_timer();
    init_serial();
    init_adc();
    init_extSwitch();
    sei();
    while (1)
    {
        //test_led();
        //test_buzzer();
        //test_fnd();
        //test_switch();
        //test_timer();
        //test_serial();
        //test_adc();
        //test_extSwitch();
    }
}
 
void init_led(){
    DDRA = 0xff;
    PORTA = 0x00;
}
void test_led(){
    PORTA = 0x00;
    _delay_ms(1000);
    PORTA = 0xff;
    _delay_ms(1000);
}
void init_buzzer(){
    DDRB = 0x10;
}
void test_buzzer(){
    PORTB = 0x10;
    _delay_ms(10);
    PORTB = 0x10;
    _delay_ms(10);
}
void init_fnd(){
    DDRC = 0xff;
    DDRG = 0x00;
}
void test_fnd(){
    fnd_display(1234);
}
void fnd_display(int num){
    int fnd1,fnd2,fnd3,fnd4;
    fnd1 = num%10;
    fnd2 = (num/10)%10;
    fnd3 = (num/100)%10;
    fnd4 = num/1000;
 
    PORTC = fnd[fnd1];
    PORTG = fnd_sel[0];
    _delay_ms(1);
    PORTC = fnd[fnd2];
    PORTG = fnd_sel[1];
    _delay_ms(1);
    PORTC = fnd[fnd3];
    PORTG = fnd_sel[2];
    _delay_ms(1);
    PORTC = fnd[fnd4];
    PORTG = fnd_sel[3];
    _delay_ms(1);
}
void init_switch(){
    // pull-up
    DDRE = 0x00;
    PORTE = 0x30;
}
void test_switch(){
    init_led();
    if((PINE & 0x20)== 0x00)
    PORTA = 0xff;
    if((PINE & 0x10)== 0x00)
    PORTA = 0x00;
}
void init_timer(){
    TIMSK = 0x01// R/W 선택 TIMER 0 사용
    TCCR0 = 0x04// 분주비 64
    TCNT0 =256-5// 0에서 시작 255가되어 256이 되면 OVF가 되어 인터럽트 구문을 실행한다.
    /*
    Timer set
    1/16000000 = 0.0000000625
    64분주
    0.0000000625* 64 = 0.000004
    0부터 250회 돌면 0.000004 *250 = 0.001
    OVF 발생 count 증가
    1000번 발생하면 1초 가 된다.
    */
}
void test_timer(){
    init_fnd();
    init_serial();
    fnd_display(sec);
    sprintf(textBuff,"%d\r\n",sec);
    SendLine(textBuff);
}
void init_serial(long BaudRate){
    UBRR0H = 0;
    switch(BaudRate)
    {
        case 115200:
        UBRR0L = 8;
        break;
        
        case 57600:
        UBRR0L = 16;
        break;
        
        case 38400:
        UBRR0L = 25;
        break;
        
        case 19200:
        UBRR0L = 51;
        break;
        
        case 14400:
        UBRR0L = 68;
        break;
        
        case 9600:
        UBRR0L = 103;
        break;
        
        // Default 115200
        default:
        UBRR0L = 8;
        break;
    }
    UCSR0A = 0x00;
    UCSR0B = 0x18;
    UCSR0C = 0x06;  // 8 bit
}
void SendByte(char data)
{
    while((UCSR0A & 0x20== 0x00);
    UDR0 = data;
}
/*** Function for sending line ***/
void SendLine(char *string)
{
    while(*string != '\0')
    {
        SendByte(*string);
        string++;
    }
}
 
char ReceiveByte(){
    while(!(UCSR0A & (1<<RXC0)));
    return UDR0;
}
void test_serial(){
    SendByte('A');
    _delay_ms(10);
    SendLine("Hello World");
    
    if((ReceiveByte() == 'a'&& (ReceiveByte() =='b')){
        SendByte('o');
        SendByte('k');
    }
}
void init_adc(){
        ADCSRA |= ((1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)); //16Mhz/128 = 125Khz
        ADMUX |= (1<<REFS0);       //AVCC(5V)
        ADCSRA |= (1<<ADEN);      //ADC 인에이블
}
uint16_t read_adc(uint8_t channel){
    ADMUX &= 0xF0;
    ADMUX |= channel;
    
    ADCSRA |= (1<<ADSC);      //변환 시작
    while(ADCSRA&(1<<ADSC));//변환 완료되기를 기다림.
    
    return ADCW;  //ADC값 반환
}
void test_adc(){
    init_adc();
    init_fnd();
    uint16_t adcValue =0;
    adcValue = read_adc(0);
    sprintf(textBuff,"adcValue : %d\r\n",adcValue);
    SendLine(textBuff);
    fnd_display(adcValue);
    _delay_ms(100);
}
void init_extSwitch(){
    DDRE = 0x00;
    PORTE = 0xf0;
    EICRB =0x0a;
    
    EIMSK = 0x30// INT4, INT5 사용
}
void test_extSwitch(){
    init_fnd();
    fnd_display(extCount);
}
 
ISR(INT4_vect){
    extCount++;
}
ISR(INT5_vect){
    extCount--;
}
ISR(TIMER0_OVF_vect){
    TCNT0 =256-(256-5);
    count++;
    if (count >=1000){
        sec++; count=0;
    }
}
cs



jkit_190122.zip


반응형

'Project > j-kit-128-1실습' 카테고리의 다른 글

[j-kit-128] jkit 128 기능구현하기  (0) 2018.12.10
Sonar_GPS - C#Window Form  (0) 2018.10.21
Sonar_GPS  (0) 2018.10.11
Serial 통신_ 문자열 전송  (0) 2018.10.01
Serial 통신_Uart0_문자 1개  (0) 2018.10.01
반응형

Atmega8a 

8MHz Ext.OSC



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
/*
 * Study_Atmega8A.c
 *
 * Created: 2018-12-18 오후 10:30:25
 * Author : HeungSik
 */ 
 
#include <avr/io.h>
#define F_CPU 8000000
#define FOSC 8000000
#include <util/delay.h>
#define BAUD 9600
#define MYUBRR FOSC/16/BAUD-1
 
void init_serial();
void USART_Transmit(unsigned char data);
unsigned char USART_Receive( void );
 
void init_serial(unsigned int ubrr){
    UBRRH = (unsigned char)(ubrr >>8);
    UBRRL = (unsigned char)ubrr;
    //UBRRL = 25;
    /* Enable receiver and transmitter */
    UCSRB = (1<<RXEN)|(1<<TXEN);
    /* Set frame format: 8data, 2stop bit */
    UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);
}
void USART_Transmit( unsigned char data )
{
    /* Wait for empty transmit buffer */
    while ( !( UCSRA & (1<<UDRE)) )
    ;
    /* Put data into buffer, sends the data */
    UDR = data;
}
unsigned char USART_Receive( void )
{
    /* Wait for data to be received */
    while ( !(UCSRA & (1<<RXC)) )
    ;
    /* Get and return received data from buffer */
    return UDR;
}
void Transmit_Line(char *string){
    int i =0;
    while (*string != 0x00)
    {
        USART_Transmit(*string);
        i++;
    }
}
int main(void)
{
    
    init_serial(MYUBRR);
    
    while (1
    {
        USART_Transmit('a');
        
        _delay_ms(50);
    }
}
 
 
cs


다음은 BLE모듈 사용하여 LED 제어하기


반응형
반응형

1.jpg


자세히 보면 inch 와 mm 가 어느순간 뒤짚힌 듯한 느낌이 듭니다.

인치로 0603 이라고 말하면 mm 로는 1608 인데. mm 로 0603 이라고 말하면 inch 로는 0201 이 되기 때문에

표기를 할때 구분을 잘 해야 합니다.

 

뭐, 일반적으로 mm 사이즈 기준 1005,1608,2012 세가지를 주로  쓰기 때문에 

아직 전달상의 문제로 사이즈가 다른 chip 이 박힌적은 없지만, 만약 아주 소형 사이즈를 사용 하게 

될 경우 주의 해야 합니다.



반응형

'Study > 하드웨어' 카테고리의 다른 글

led 저항값 계산하기  (0) 2019.01.09
Noise 대책  (0) 2019.01.07
RC low-pass filter Design  (0) 2019.01.07
반응형

최소 구동 전압과 최대 구동 전압

LED는 최소 구동전압과 최대 구동전압이 있다. 최소 구동 전압보다 낮으면 흐리게 빛이 나고 최대 구동 전압보다 높으면 LED가 파손된다. 이를 표로 나타내면 아래와 같다. (출처)

색상구 분최소전압최대전압전류(일반)전류(최대)
Red1.8V2.3V20 ㎃50 ㎃
Orange2.0V2.3V30 ㎃50 ㎃
Real Yellow2.0V2.8V20 ㎃50 ㎃
emerald Green1.8V2.3V20 ㎃50 ㎃
Real Green3.0V3.6V20 ㎃50 ㎃
sky Blue3.4V3.8V20 ㎃50 ㎃
Real Blue3.4V3.8V20 ㎃50 ㎃
Pink3.4V3.8V20 ㎃50 ㎃
백○White3.4V4.0V20 ㎃50 ㎃

물론 정확한 스팩은 LED의 데이터 시트를 살펴봐야겠지만 데이터 시트가 없는 경우 위의 표를 참고한다.

따라서 LED를 작동할 때는 적당한 저항을 배치해서 LED에 가해지는 전압을 적절하게 조절해야 한다. 이를 위한 방법은 여러가지가 있지만 간단한 계산을 통해서 알아내는 방법을 살펴보자.

공식

(입력전압 -  LED를 켜기 위한 최소전압 )/전류 =  저항값

간단한 계산

예를들어서 적색 LED를 사용하고 입력전압이 5V라면 아래와 같이 계산하면 된다.

1000mA는 1A이다. 따라서 20mA는 20/1000A 즉 0.02A이다. (계산기)

(5V(입력전압) - 1.8V(LED 최소전압))/0.02A(전류) = 160옴

즉 160옴 보다 큰 저항을 사용하면 된다.

LED를 직렬로 연결했을 때

적색 LED 2개를 직렬로 연결했을 때 계산하는 법을 알아보자.

(5V - (1.8V X 2개)) / 0.02A = 70옴

반응형

'Study > 하드웨어' 카테고리의 다른 글

칩 저항 Size 표  (0) 2019.01.09
Noise 대책  (0) 2019.01.07
RC low-pass filter Design  (0) 2019.01.07
반응형
#include <stdlib.h>    // qsort 함수가 선언된 헤더 파일


int compare(const void *a, const void *b)    // 오름차순 비교 함수 구현
{
    int num1 = *(int *)a;    // void 포인터를 int 포인터로 변환한 뒤 역참조하여 값을 가져옴
    int num2 = *(int *)b;    // void 포인터를 int 포인터로 변환한 뒤 역참조하여 값을 가져옴

    if (num1 < num2)    // a가 b보다 작을 때는
        return -1;      // -1 반환
    
    if (num1 > num2)    // a가 b보다 클 때는
        return 1;       // 1 반환
    
    return 0;    // a와 b가 같을 때는 0 반환
}

int main()
{
    int numArr[10] = { 8, 4, 2, 5, 3, 7, 10, 1, 6, 9 };    // 정렬되지 않은 배열

    // 정렬할 배열, 요소 개수, 요소 크기, 비교 함수를 넣어줌
    qsort(numArr, sizeof(numArr) / sizeof(int), sizeof(int), compare);

    for (int i = 0; i < 10; i++)
    {
        printf("%d ", numArr[i]);    // 1 2 3 4 5 6 7 8 9 10
    }

    printf("\n");

    return 0;
}



// 내림차순


int compare(const void *a, const void *b)    // 내림차순 비교 함수 구현
{
    int num1 = *(int *)a;    // void 포인터를 int 포인터로 변환한 뒤 역참조하여 값을 가져옴
    int num2 = *(int *)b;    // void 포인터를 int 포인터로 변환한 뒤 역참조하여 값을 가져옴

    if (num1 > num2)    // a가 b보다 클 때는
        return -1;      // -1 반환
    
    if (num1 < num2)    // a가 b보다 작을 때는
        return 1;       // 1 반환
    
    return 0;           // a와 b가 같을 때는 0 반환
}



// 좀더 간단하게 구현 할 경우


int compare(const void *a, const void *b)
{
    return *(int *)a - *(int *)b;    // 오름차순
}
int compare(const void *a, const void *b)
{
    return *(int *)b - *(int *)a;    // 내림차순
}


반응형

'Study > C' 카테고리의 다른 글

Sprintf에 예제와 사용 예  (0) 2019.01.04
itoa, atoi 함수에 대하여  (0) 2019.01.04
C언어 - 자연수의 조합  (0) 2018.09.14
C언어 - 자판기  (0) 2018.09.14
C언어 - 포인터 이해  (0) 2018.09.07
반응형

https://www.google.com/search?q=APDS+100+tips&oq=APDS+100+tips&aqs=chrome..69i57j35i39.8554j0j8&sourceid=chrome&ie=UTF-8


https://www.analog.com/media/en/technical-documentation/application-notes/AN-1109.pdf


http://facta.junis.ni.ac.rs/eae/fu2k12/fu04.pdf

반응형

'Study > 하드웨어' 카테고리의 다른 글

칩 저항 Size 표  (0) 2019.01.09
led 저항값 계산하기  (0) 2019.01.09
RC low-pass filter Design  (0) 2019.01.07

+ Recent posts