반응형

J-kit, 초음파센서 SR04 3개를 이용한 GPS 센서


센서에서 전방을 향해 초음파를 발사,

물체에 부딪혀 반사되는 초음파가 돌아오는 시간의 길이를 계산,

ECHO 핀에서 시간의 길이에 비례하는 펄스를 출력한다.


// MCU에서 해 줄 작업은,

10us길이의 TRIGGER 파형을 센서로 출력하고,

그 결과 센서에서 출력되는 ECHO 파형을 감지해 이를 거리로 계산하는 것이다.



if(EICRB==3){    // 라이징엣지에서 인터럽트가 걸리면

        start=TCNT1; // TCNT1값을 저장해두고

        EICRB=2;     // 다음번 인터럽트는 폴링엣지로 설정

    }

    else{            // 폴링엣지에서 인터럽트가 걸리면

        end=TCNT1;   // TCNT1값을 저장해두고

        EICRB=3;     // 다음번 인터럽트는 라이징엣지로 설정

        dist= (int)( (float)(end-start) / 14.5 ); // 58us / 4us = 14.5, cm로 변환

    }



    uS / 58 = centimeters or uS / 148 =inch


    왕복거리이기 때문에 1/2하여 29uS당 1cm


//



Sonar_GPS.zip


// ControlSet.h

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
#ifndef _CONTROL_SET_
#define _CONTROL_SET_
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
 
#define TEMPERATURE    25    
 
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |=  _BV(bit))
 
/*** Send start signal to ultrasonic sensor(NT-TS601) ***/    
// number = quantity
void SendSignal_0()
{        
    // Step 1. send signal during 10us
    sbi(PORTD,1);    
    _delay_us(10);            
    cbi(PORTD,1);
}
void SendSignal_1(){
    sbi(PORTD,3);
    _delay_us(10);
    cbi(PORTD,3);
}
void SendSignal_2(){
    sbi(PORTE,7);
    _delay_us(10);
    cbi(PORTE,7);
}
 
#endif
 
cs


//RegSet.h

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
#ifndef _REGISTER_SET_
#define _REGISTER_SET_
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
 
/*** Port Setting ***/    
// Quantity of Sonar Sensors : 6
// INT0 ~ INT6    
void PortInit()
{    
    DDRD = 0b00001010; // PD0 ~ PD3
    PORTD = 0b00000000;
    DDRE = 0b10000000;
    PORTE = 0b00000000;
}
 
/*** Timer Register Setting ***/    
// 1 cycle(20us) = 1/(16M/(2*8*(19+1))    
void TimerInit()
{        
    TCCR0 = (1<<WGM01)|(1<<CS01); // CTC mode, clk/8
    OCR0 = 58; // 58번째 비교 매치 인터럽트 발생
    TCNT0 = 0; // 0부터 시작
    TIMSK = (1<<OCIE0); // compare match enable
    TIFR = 0x00; // flag 초기화
    //29uS
}
 
/*** External Interrupt Setting ***/
// Refer to the following comments.
void ExtInit()
{    
    EICRA = 0b00110011;    // INT0 ~ INT3 -> Rising Edge Default
    EICRB = 0b00110000; // INT4 ~ INT7 -> Rising Edge Default
    EIMSK = 0b01000101; // INT0 ~ INT5 -> INT0, INT2, INT4 enable
    EIFR = 0xff;
}
 
#endif
 
/*** 
 
 �� Reference 1 : External Interrupt Control Register (EICR) A, B
 BIT   : [   7   |   6   |   5   |   4   |   3   |   2   |   1   |   0   ]
 EICRA : [ ISC31 | ISC30 | ISC21 | ISC20 | ISC11 | ISC10 | ISC01 | ISC00 ]
 BIT   : [   7   |   6   |   5   |   4   |   3   |   2   |   1   |   0   ]
 EICRB : [ ISC71 | ISC70 | ISC61 | ISC60 | ISC51 | ISC50 | ISC41 | ISC40 ]
 
 �� Reference 2 : Interrupt Sense Control (A)
 [ISCn1 | ISCn0 | Description                                                            ]
    0   |   0   | The low level of INTn generates an Interrupt request.  
    0   |   1   | Reserved
    1   |   0   | The falling edge of INTn generates asynchronously an interrupt request.
    1   |   1   | The rising edge of INTn generates asynchronously an interrupt request.
 �� Reference 3 : Interrupt Sense Control (B)
 [ISCn1 | ISCn0 | Description                                                            ]
    0   |   0   | The low level of INTn generates an Interrupt request.  
    0   |   1   | Any logical change on INTn generates an interrupt request.
    1   |   0   | The falling edge of INTn generates asynchronously an interrupt request.
    1   |   1   | The rising edge of INTn generates asynchronously an interrupt request.
 ***/
 
cs



//SerialSet.h

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
#ifndef _SERIAL_COMMUNICATION_SET_
#define _SERIAL_COMMUNICATION_SET_
 
#include <avr/io.h>
 
/*** Serial Port Setting ***/    
// USART0 (PE0 - RXD, PE1 - TXD)
void SerialOpen(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 57600
        default:
            UBRR0L = 16;
            break;
    }
    UCSR0A = 0x00;
    UCSR0B = 0x18;
    UCSR0C = 0x06;  // 8 bit
}
 
/*** Function for sending 1 byte ***/    
void SendByte(char data)
{
    while((UCSR0A & 0x20) == 0x00);
    UDR0 = data;
}
 
/*** Function for sending line ***/
void SendLine(char *string)
{
    while(*string != '\0')
    {
        SendByte(*string);
        string++;
    }
}
 
#endif
 
cs



// main

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
#define F_CPU 16000000
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdio.h>
 
#include "RegSet.h"
#include "SerialSet.h"
#include "ControlSet.h"
 
unsigned int tick_0 = 0;
unsigned int pulse_end_0 = 0;
unsigned int tick_1 = 0;
unsigned int pulse_end_1 = 0;
unsigned int tick_2 = 0;
unsigned int pulse_end_2 = 0;
 
/*** Timer Interrupt ***/
ISR (TIMER0_COMP_vect)
{
    tick_0++;
    tick_1++;
    tick_2++;
}
 
/*** External Interrupt (INT0) ***/
ISR(INT0_vect)
{
    unsigned int pulse_tick = 0;
    pulse_tick = tick_0;
 
    if ((EICRA & 0b00000011) == 0b00000011)
    {
        cbi(EICRA,0);
        tick_0 = 0;
    }
    else
    {
        sbi(EICRA,0);
        pulse_end_0 = pulse_tick;
    }        
}
ISR(INT2_vect){
    unsigned int pulse_tick = 0;
    pulse_tick = tick_1;
    if ((EICRA & 0b00110000) == 0b00110000)
    {
        
        cbi(EICRA,4);
        tick_1 = 0;
    }
    else
    {
        sbi(EICRA,4);
        pulse_end_1 = pulse_tick;
    }
}
ISR(INT6_vect){
    unsigned int pulse_tick = 0;
    pulse_tick = tick_2;
    if ((EICRB & 0b00110000) == 0b00110000)
    {
        cbi(EICRB,4);
        tick_2 = 0;
    }
    else
    {
        sbi(EICRB,4);
        pulse_end_2 = pulse_tick;
    }
}
 
int main(void)
{
    PortInit();
    TimerInit();
    ExtInit();
 
    SerialOpen(115200);
 
    _delay_us(20);    // for System Stability.    
    int pulse0 =0;
    int pulse1 =0;
    int pulse2 =0;
    sei();    
    while(1)
    {
        SendSignal_0();
        for (int i =0; i<10;i++){
        pulse0 += pulse_end_0;
        }
        pulse0/=10; // 10회 평균값
        pulse0 -=8; // calibration
        _delay_ms(10);
        SendSignal_1();
        for (int i =0; i<10;i++){
            pulse1 += pulse_end_1;
        }
        pulse1/=10; // 10회 평균값
        _delay_ms(10);
        SendSignal_2();
        for (int i=0;i<10;i++){
            pulse2 += pulse_end_2;
        }
        pulse2/=10; // 10회 평균값
        pulse2 -=6; // calibration
        char str[20];
        sprintf(str,"%u,%u,%u\r\n",pulse0,pulse1,pulse2);
        SendLine(str);
        
 
        _delay_ms(50);
    }
}
 
 
cs


반응형
저작자표시 비영리 변경금지

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

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

1. Sensor Board

 - BST-BMA280-DS000-11-1393596_가속도계

 - BST-BME280_DS001-09-521021_습도압력온도센서

 - BSTBMG160DS00008_published_자이로스코프 // 제품 단종으로 인해 부품 교체

 - BST-BMG250-DS000-02-967971 자이로스코프

 - BST-BMI160-DS000-07-1366203_관성측정

 - BST-BMM150-DS001-01-1393684_자력계

 - MAX44009-59959_디지털조도센서


2. MCU - Atmega 128


3. Bom list

Sensor board_BOM.xlsx


4. Cadence Orcad


 1) sensor lib

SENSOR_LIB.OLB

sensor_lib.opj


 2) board circuit

SENSOR BOARD.DSN

Sensor board_Circuit_page1.pdf

Sensor board_Circuit_page2.pdf



5. Cadence Allegro


 1) FootPrint symbol lib

Allegro_lib.zip



 2) PCB ArtWork

SENSOR BOARD.brd




6. 참고 자료

 - Bosch XDK110 Cross-Domain 개발 키트.link

- AN005_PCB_Guidelines_TRINAMIC_packages_Rev1.02.pdf

 

etc) 진행 자료.

AVR I2C(TWI) Interface.txt

Sensor board BOM.xlsx


반응형
저작자표시 비영리 변경금지

'Project > Sensor Board' 카테고리의 다른 글

[Sensor Board] 개선해야 할 점  (0) 2018.12.10
Sensor_Board AVR Source Code ver.1  (0) 2018.12.03
반응형

// serial 통신_ 문자열


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
/*
 * avr-1001.cpp
 *
 * Created: 2018-10-01 오전 9:23:35
 * Author : USER
 */ 
 
#include <avr/io.h>
#define F_CPU 16000000
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <stdlib.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;
unsigned int sec=0;
 
unsigned int num1Count,num2Count,num3Count,num4Count;
 
void fnd_display(int num){
    int fnd1,fnd2,fnd3,fnd4;
    fnd1 = num%10;
    fnd2 = (num/10)%10;
    fnd3 = (num/100)%10;
    fnd4 = num/1000;
    
    num1Count = fnd1;
    num2Count = fnd2;
    num3Count = fnd3;
    num4Count = fnd4;
    
    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);
    
}
ISR(TIMER0_OVF_vect){
    TCNT0 =256-5;
    count++;
    if (count >1000){
        sec++; count=0;
    }
}
 
void init_uart0(){
    UCSR0B = 0x18; // TXEN0 Transmitter Enable 
    UCSR0C = 0x06; // UCSZn Bits Settings Reserved
    
    //Baud Rate Registers
    UBRR0H = 0; 
    UBRR0L = 207;
}
void putchar0(char c){
    while(!(UCSR0A & 0x20)); // Double the USART Transmission Speed
    UDR0 = c;
}
char getchar0(){
    while(!(UCSR0A & (1<<RXC0)));
    return UDR0;
}
void putstr0(char *str){
    while(*str){putchar0(*str++);}
}
 
int main(void)
{
    /* Replace with your application code */
    
    DDRC = 0xff; // FND 출력설정
    DDRG = 0xff; // FND_SEL 출력설정
    DDRA = 0xff;
    PORTA = 0x00;
    
    init_uart0();
    
    char str1[10];
    
    TIMSK = 0x01; // R/W 선택 TIMER 0 사용
    TCCR0 = 0x04; // 분주비 64
    TCNT0 =256-5; // 0에서 시작 255가되어 256이 되면 OVF가 되어 인터럽트 구문을 실행한다.
 
    sei();
    while (1) 
    {
        fnd_display(1234);
        itoa(num4Count,str1,10);
        putstr0(str1);
        itoa(num3Count,str1,10);
        putstr0(str1);
        itoa(num2Count,str1,10);
        putstr0(str1);
        itoa(num1Count,str1,10);
        putstr0(str1);
    }
    return 0;
}
 
 
cs


반응형
저작자표시 비영리 변경금지

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

Sonar_GPS - C#Window Form  (0) 2018.10.21
Sonar_GPS  (0) 2018.10.11
Serial 통신_Uart0_문자 1개  (0) 2018.10.01
FND_Display with Timer/Counter  (0) 2018.10.01
LED 제어  (0) 2016.02.26
반응형

// Serial 통신_Uart0_문자 1개



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
/*
 * avr-1001.cpp
 *
 * Created: 2018-10-01 오전 9:23:35
 * Author : USER
 */ 
 
#include <avr/io.h>
#define F_CPU 16000000
#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;
unsigned int sec=0;
 
 
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);
}
ISR(TIMER0_OVF_vect){
    TCNT0 =256-5;
    count++;
    if (count >1000){
        sec++; count=0;
    }
}
 
void init_uart0(){
    UCSR0B = 0x18; // TXEN0 Transmitter Enable 
    UCSR0C = 0x06; // UCSZn Bits Settings Reserved
    
    //Baud Rate Registers
    UBRR0H = 0; 
    UBRR0L = 207;
}
void putchar0(char c){
    while(!(UCSR0A & 0x20)); // Double the USART Transmission Speed
    UDR0 = c;
}
char getchar0(){
    while(!(UCSR0A & (1<<RXC0)));
    return UDR0;
}
 
int main(void)
{
    /* Replace with your application code */
    DDRC = 0xff; // FND 출력설정
    DDRG = 0xff; // FND_SEL 출력설정
    DDRA = 0xff;
    PORTA = 0x00;
    
    init_uart0();
    
    TIMSK = 0x01; // R/W 선택 TIMER 0 사용
    TCCR0 = 0x04; // 분주비 64
    TCNT0 =256-5; // 0에서 시작 255가되어 256이 되면 OVF가 되어 인터럽트 구문을 실행한다.
    
    char c;
    sei();
    
    while (1) 
    {
        c =getchar0();
        putchar0(c);
    }
    return 0;
}
 
 
cs


반응형
저작자표시 비영리 변경금지

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

Sonar_GPS  (0) 2018.10.11
Serial 통신_ 문자열 전송  (0) 2018.10.01
FND_Display with Timer/Counter  (0) 2018.10.01
LED 제어  (0) 2016.02.26
FND 실습  (0) 2016.02.26
반응형

// FND_Display with Timer/Counter



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
/*
 * avr-1001.cpp
 *
 * Created: 2018-10-01 오전 9:23:35
 * Author : USER
 */ 
 
#include <avr/io.h>
#define F_CPU 16000000
#include <util/delay.h>
#include <avr/interrupt.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;
unsigned int sec=0;
 
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);
}
ISR(TIMER0_OVF_vect){
    TCNT0 =256-5;
    count++;
    if (count >1000){
        sec++; count=0;
    }
}
 
 
int main(void)
{
    /* Replace with your application code */
    DDRC = 0xff; // FND 출력설정
    DDRG = 0xff; // FND_SEL 출력설정
    
    TIMSK = 0x01; // R/W 선택 TIMER 0 사용
    TCCR0 = 0x04; // 분주비 64
    TCNT0 =256-5; // 0에서 시작 255가되어 256이 되면 OVF가 되어 인터럽트 구문을 실행한다.
    sei();
    while (1) 
    {
        fnd_display(sec);
    }
}
 
 
cs


반응형
저작자표시 비영리 변경금지

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

Serial 통신_ 문자열 전송  (0) 2018.10.01
Serial 통신_Uart0_문자 1개  (0) 2018.10.01
LED 제어  (0) 2016.02.26
FND 실습  (0) 2016.02.26
FND 실습 1/100초 스탑워치, 24시간 디지털 시계만들기  (0) 2016.02.26
반응형

1. Ring Counter // 1->2->4->8->16->32->64->128->1 순으로 1초마다 변함

int main()
{
 
  unsigned char count = 1;
 DDRA = 0xff;
 while(1)
 { 
  PORTA = count;
  _delay_ms(300);
  if(count<=64)
  count = count*2;
  else 
  count = 1;
 }
 
}

​

2.LED를 맨 오른쪽 1개만 켜고 이를 1초에 한칸씩 왼쪽으로 이동시키고 
왼쪽 끝에 도달하면 다시 오른쪽으로 한칸씩 이동시키기 (Boundary Detector)
int main()
{
 DDRA = 0xff;
 PORTA = 0x01;
 unsigned int i = 0;
 
 while(1){
  for(i=1;i<=0x80;i<<=1){
  PORTA = i;
  _delay_ms(50);
 }
  for(i=0x40;i>=0x01;i>>=1){
   PORTA = i;
   _delay_ms(50);
   if(!i)
    break;
  }
 }

}

반응형

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

Serial 통신_Uart0_문자 1개  (0) 2018.10.01
FND_Display with Timer/Counter  (0) 2018.10.01
FND 실습  (0) 2016.02.26
FND 실습 1/100초 스탑워치, 24시간 디지털 시계만들기  (0) 2016.02.26
회로도 참고  (0) 2016.02.26
반응형

 // FND 숫자 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F
 // 0 = 0x0f; 1 = 0x06; 2 = 0x5b; 3 = 0x4f; 4 = 0x66; 5 = 0x6d;
 // 6 = 0x7d; 7 = 0x27; 8 = 0x7f; 9 = 0x6f; A = 0x77; B = 0x7c;
 // C = 0x5e; D = 0x5e; E = 0x79; F = 0x71;
 // H = 0x76; E = 0x79; L = 0x38; P = 0x73;

 

FND에 ‘HELP’라고 디스플레이해 보기
int main()
{
 DDRC = 0xff;
 DDRG = 0xff;
 while(1){
 PORTC = 0x76;
 PORTG = 0x08;
 _delay_ms(5);
 PORTC = 0x79;
 PORTG = 0x04;
 _delay_ms(5);
 PORTC = 0x38;
 PORTG = 0x02;
 _delay_ms(5);
 PORTC = 0x73;
 PORTG = 0x01;
 _delay_ms(5);
 
} }

 

‘HELP’ 깜빡이면서 디스플레이

int main()
{
 DDRC = 0xff;
 DDRG = 0xff;
 unsigned int i;
 while(1){

  for(i=0;i<15;i++)
  {
 PORTC = 0x76;
 PORTG = 0x08;
 _delay_ms(5);
 PORTC = 0x79;
 PORTG = 0x04;
 _delay_ms(5);
 PORTC = 0x38;
 PORTG = 0x02;
 _delay_ms(5);
 PORTC = 0x73;
 PORTG = 0x01;
 _delay_ms(5);
 }
 PORTC = 0x00;
 PORTG = 0xff;
 _delay_ms(500);

} }

반응형

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

FND_Display with Timer/Counter  (0) 2018.10.01
LED 제어  (0) 2016.02.26
FND 실습 1/100초 스탑워치, 24시간 디지털 시계만들기  (0) 2016.02.26
회로도 참고  (0) 2016.02.26
jkit switch 제어/ 인터럽트사용  (0) 2016.02.26
반응형

unsigned char digit[10] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7c, 0x07, 0x7f, 0x67};
unsigned char fnd_sel[4] = {0x08, 0x04, 0x02, 0x01};
unsigned char fnd[4];
int main()
{
 DDRC = 0xff; // led출력 설정
 DDRG = 0x0f; // TR 출력 설정
int i=0, count=0;
 while(1){
  count++;
 if (count == 10000)
   count = 0;
 fnd[3] = (count/1000)%10;
 fnd[2] = (count/100)%10;
 fnd[1] = (count/10)%10;
 fnd[0] = count%10;
  for (i=0; i<4; i++)
  { PORTC = digit[fnd[i]];
  PORTG = fnd_sel[i];
  _delay_ms(2); }
} 
}
// 오른쪽 1의자리 부터 count
unsigned char digit[10] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7c, 0x07, 0x7f, 0x67};
unsigned char fnd_sel[4] = {0x08, 0x04, 0x02, 0x01};
unsigned char fnd[4];
int main()
{
 DDRC = 0xff; // led출력 설정
 DDRG = 0x0f; // TR 출력 설정
int i=0, count=0;
 while(1){
  count++;
 if (count == 10000)
   count = 0;
 fnd[0] = (count/1000)%10;
 fnd[1] = (count/100)%10;
 fnd[2] = (count/10)%10;
 fnd[3] = count%10;
  for (i=0; i<4; i++)
  { PORTC = digit[fnd[i]];
  PORTG = fnd_sel[i];
  _delay_ms(2); }
} 
}

 

 

1의자리 숫자는 컨트롤러 속도가 워낙 빨라서 변하는 값이 보이질 않네..

여기까지는 실습 예제가 있어서 쉽게 풀 수 있었다.

하지만 24시간 디지털 시계 만들기는 조금 까다로웠다.


unsigned char digit[10] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7c, 0x07, 0x7f, 0x67};
unsigned char fnd_sel[4] = {0x08, 0x04, 0x02, 0x01};
unsigned char fnd[4];
int main()
{
 DDRC = 0xff; // led출력 설정
 DDRG = 0x0f; // TR 출력 설정
int i=0, count=0, j=0;
 while(1){
  count++;
 if (count == 1440 )
   count = 0;
 fnd[0] = (count/600)%3;
 fnd[1] = (count/60)%10;
 fnd[2] = (count/10)%6;
 fnd[3] = count%10;
  for(j=0; j<2800;j++){
  for (i=0; i<4; i++)
  { PORTC = digit[fnd[i]];
  PORTG = fnd_sel[i];
  _delay_ms(5); }}
} 
}
시간은 정확하지 않지만 2800 부분 수정하여 정확한 시간을 맞출 수 있을 것 같다.

반응형

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

FND_Display with Timer/Counter  (0) 2018.10.01
LED 제어  (0) 2016.02.26
FND 실습  (0) 2016.02.26
회로도 참고  (0) 2016.02.26
jkit switch 제어/ 인터럽트사용  (0) 2016.02.26
반응형

J_kit_128_1

전자 회로도 참고


jkit-128-1 회로도.pdf

 

 

 

반응형

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

FND_Display with Timer/Counter  (0) 2018.10.01
LED 제어  (0) 2016.02.26
FND 실습  (0) 2016.02.26
FND 실습 1/100초 스탑워치, 24시간 디지털 시계만들기  (0) 2016.02.26
jkit switch 제어/ 인터럽트사용  (0) 2016.02.26
반응형

* 인터럽트 : 방해하다, 훼방놓다의 뜻, 긴급하거나 불규칙적인 사건의 처리, 외부와의 인터페이스, 폴링(polling)으로 처리하기에는 프로세싱 타임 낭비

HOW 

 - 현재 수행중인 일을 잠시 중단하고 급한 일을 처리

 - 일이 끝나면 본래의 일을 다시 이어서 수행

 - 이때, 급한 일을 해결하는 작업을 인터럽트 서비스 루틴이라 하는데, 각 인터럽트마다 고유의 인터럽트 서비스 루틴 존재

 - 인터럽트가 여러 개 동시에 걸리면 우선 순위에 따라 조치

* 인터럽트 서비스 루틴

 - 인터럽트가 발생하면 프로세서는 현재 수행중인 프로그램을 멈추고 상태 레지스터와 PC 등을 스택에 잠시 저장 후 인터럽트 서비스 루틴으로 점프, 인터럽트 서비스 루틴을 실행한 후에는 이전의 프로그램으로 복귀하여 정상적인 절차를 실행한다.


* 인터럽트 스위치로 1/100 스톱워치 만들기

 - 메인

1. 초기설정

2. state 변수 값 설정 : stop

3. 인터럽트 활성화

4. state 검사 후 stop 상태시 복사된 10초, 1초, 1/10초, 1/100초 변수를 디스플레이하고, go 상태면 현재의 10초, 1초, 1/10초, 1/100초 변수를 디스플레이
 - 인터럽트 INT4
1. state 값이 stop시 go 변경
2. state go 일시 stop으로 변경 후 이때 시간 값 복사 저장
 - 인터럽트 INT5
1. 변수 및 복사된 시간 값 0으로 초기화
2. state 값 stop으로 초기화

#include <avr/io.h> 

#include <avr/interrupt.h>

#define F_CPU 16000000UL

#define __DELAY_BACKWARD_COMPATIBLE__

#include <util/delay.h>

#define STOP 0

#define GO 1

volatile int cur_time = 0;

volatile int stop_time = 0;

volatile int state = STOP; 

unsigned char digit[]= {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7c, 0x07, 0x7f, 0x67};

unsigned char fnd_sel[4] = {0x01, 0x02, 0x04, 0x08};

SIGNAL(SIG_INTERRUPT4) 

{ 

if (state == STOP)

 state = GO; 

  else 

{ 

state = STOP; 

  stop_time = cur_time; 

} 

} 

SIGNAL(SIG_INTERRUPT5) 

{

state = STOP; 

cur_time = 0; stop_time = 0; 

}

void init( ) 

{

DDRC = 0xff; // FND Data 

DDRG = 0x0f; // FND Select 

DDRE = 0xcf; // INT4, 5

PORTC = digit[0]; PORTG = 0x0f; EICRB = 0x0a; //falling edge 

EIMSK = 0x30; //interrupt en 

sei(); 

}


void display_fnd(int count) // 수행시간 = 약 10ms 

{ 

int i, fnd[4]; 

fnd[3] = (count/1000)%10; // 천 자리

fnd[2] = (count/100)%10; // 백 자리

fnd[1] = (count/10)%10; // 십 자리 

fnd[0] = count%10; // 일 자리 

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

{

PORTC = digit[fnd[i]];

PORTG = fnd_sel[i];

_delay_ms(2+i%2); 

}

}


int main()

{

init( );

while(1)

{ 

if (state == STOP)

display_fnd(stop_time);

else display_fnd(cur_time);

cur_time++;

}

}

반응형

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

FND_Display with Timer/Counter  (0) 2018.10.01
LED 제어  (0) 2016.02.26
FND 실습  (0) 2016.02.26
FND 실습 1/100초 스탑워치, 24시간 디지털 시계만들기  (0) 2016.02.26
회로도 참고  (0) 2016.02.26

+ Recent posts

티스토리툴바