이해와 암기 사이

tb_ALU

이해와암기 사이 — Sun, 23 Apr 2023 03:31:52 +0900

module tb_ALU_32bit;
    // Inputs
    reg [31:0] a_in;
    reg [31:0] b_in;
    reg [3:0] op;

    // Outputs
    wire [31:0] result;
    wire zero;
    wire overflow;

    // Instantiate the Unit Under Tset (UUT)
    ALU_32bit uut(
        .a_in(a_in),
        .b_in(b_in),
        .op(op),
        .result(result),
        .zero(zero),
        .overflow(overflow)
        );

        initial begin
            // Initialize Inputs
            a_in =0;
            b_in =0;
            op = 0;

            // Wait 100ns for flobal reset
            #100;

// a b AND , 연산 a[n]=1 & a[n+1]=1 이면 result[n]=1 그외엔 0
            a_in = 2000;
            b_in = 1000;
            op = 4'b0000;

#50;
            // a,b or 연산 a[n+1]=1 이면 result[n]=1 그외엔 0
            a_in = 2000;
            b_in = 1000;
            op = 4'b0001;

            #50;

// a, b ADD 연산
            a_in = 2000;
            b_in = 1000;
            op = 4'b0010;

#50;

            // a, b 뺄샘 , 결과 양수
            a_in = 2000;
            b_in = 1000;
            op = 4'b0110;

#50;

            // a,b 뺄샘 a=b  result = 0 , zero =1
            a_in = 1000;
            b_in = 1000;
            op = 4'b0110;
            #50;

// a,b 뺄셈 a<b result = 음수
            a_in = 1000;
            b_in = 2000;
            op = 4'b0110;
            #50;

            // a 와 b의 NOR 연산 b[n+1]=0 , b[n] =0 이면 result[n]=1 나머지 0
            a_in = 1000;
            b_in = 2000;
            op = 4'b1100;
            #50;

            // a가 b보다 작은지 체크 result = 00000001 (hex)
            a_in = 1000;
            b_in = 2000;
            op = 4'b0111;
            #50;

            a_in = 2000;
            b_in = 1000;
            op = 4'b0111; // a가 b보다 작은지 체크 result = 0 예상
            #50;

            a_in = 1000;
            b_in = 1000;
            op = 4'b0110; // a<b 체크 a=b result =0 예상
            #50;
//op = 4'b0010; // a,b 덧셈 명령 overflow =1 예상  a[31]=0 b[31]=0 co[30]=1

// carry_out=0 co[30]=1 XOR(carry_out,co[30])=1 overflow
            a_in =  32'b01111111111111111111111111111111; // 2^31-1 32bit max value
            b_in =  1;
            #50;


a_in = 32'b01111111111111111111111111111111; // 2^31-1 = 2147483647 (32bit 최대 숫자)
b_in = 1;
op = 4'b0110;

// a,b 뺼셈 result= 2'b01111111111111111111111111111110 a[31]=0 b'+1 [31]=1 c[30]=1 carry_out=1 XOR c[30] carry_out = 0
#50;

a_in = 1;
b_in = 32'b01111111111111111111111111111111; // 2^31-1 = 2147483647 (32bit 최대 숫자)
op = 4'b0110;

//SUB overflow = 0 a[31]=0 b'+1 [31] = 1 c[30]=0 carry_out=0
#50;

a_in = 32'b10000000000000000000000000000001; // -2^31
b_in = 32'b01111111111111111111111111111111; // 2^31-1 = 2147483647 (32bit 최대 숫자)
op = 4'b0110;

//SUB overflow = 1 a[31]=1 b'+1 [31]=1 cin=0 carry out =1
#50;

a_in = 32'b10000000000000000000000000000001; //-2^31+1 = -2147483647
b_in = -1; // b=11111111111111111111111111111111
op = 4'b0010;

//ADD overflow = 0? a[31]=1 b[31] = 1 , c[30] =1 carry out = 1, XOR c[30] carry_out=0
#50;

a_in = 32'b10000000000000000000000000000000; //-2^31 = -2147483648 (32bit 최소 숫자)
b_in = -1;
op = 4'b0010;

//ADD overflow = 1 a[31]=1 b[31] = 1 , c[30] =0 carry out = 1, XOR c[30] carry_out=1
#50;

a_in = 0;
b_in = 32'b10000000000000000000000000000000; //-2^31 = -2147483648 (32bit 최소 숫자)
op = 4'b0110;

// SUB overflow = 1 a[31]=0 b[31] = 1 , c[0]=1 c[30] =1 carry out = 0, XOR c[30] carry_out=1
// invert b 하고 c[0]=1 이니까 overflow가 되는구나
#50;
end
endmodule

CA ALU

이해와암기 사이 — Sun, 23 Apr 2023 03:11:07 +0900

module RISCVALU( ALUctl, A, B, ALUOut, Zero);
    input [3:0] ALUctl;
    input [63:0] A,B;
    output reg [63:0] ALUOut;
    output Zero;

    assign Zero = (ALUOut ==0); // ALUOut 0 이면 제로 1
    always @(ALUctl, A, B) begin
        case (ALUctl)
            0: ALUOut <= A & B; // 0000 and
            1: ALUOut <= A | B; // 0001 or
            2: ALUOut <= A + B; // 0010 덧셈
            6: ALUOut <= A - B ; //0110 뺼샘
            7: ALUOut <= A < B ? 1 : 0 ; // 0111 A가 B보다 작은지 체크 set less than
            12: ALUOut <= ~(A | B); // 1100 Nor 00일때 참
            default : ALUOut <= 0;
        endcase
    end
endmodule

module ALU_32bit(
    input [31:0] a_in,
    input [31:0] b_in,
    input [3:0] op,
    output [31:0] result,
    output zero,
    output overflow
    );
    wire [30:0] co;
    wire set;

    ALU_1bit u0         (a_in[0], b_in[0], (op[2] & op[1]), op[3], op[2], set , op[1:0] , result[0], co[0]);

// op=xx11 result[0]에 set이 입력됨 // op x11x 일때 c_in 1이 들어감
    ALU_1bit u1         (a_in[1], b_in[1], co[0], op[3], op[2], 1'b0, op[1:0] , result[1], co[1]); // set에 result[1~31]에는 0
    ALU_1bit u2         (a_in[2], b_in[2], co[1], op[3], op[2], 1'b0, op[1:0] , result[2], co[2]);
    ALU_1bit u3         (a_in[3], b_in[3], co[2], op[3], op[2], 1'b0, op[1:0] , result[3], co[3]);
    ALU_1bit u4         (a_in[4], b_in[4], co[3], op[3], op[2], 1'b0, op[1:0] , result[4], co[4]);
    ALU_1bit u5         (a_in[5], b_in[5], co[4], op[3], op[2], 1'b0, op[1:0] , result[5], co[5]);
    ALU_1bit u6         (a_in[6], b_in[6], co[5], op[3], op[2], 1'b0, op[1:0] , result[6], co[6]);
    ALU_1bit u7         (a_in[7], b_in[7], co[6], op[3], op[2], 1'b0, op[1:0] , result[7], co[7]);
    ALU_1bit u8         (a_in[8], b_in[8], co[7], op[3], op[2], 1'b0, op[1:0] , result[8], co[8]);
    ALU_1bit u9         (a_in[9], b_in[9], co[8], op[3], op[2], 1'b0, op[1:0] , result[9], co[9]);
    ALU_1bit u10         (a_in[10], b_in[10], co[9], op[3], op[2], 1'b0, op[1:0] , result[10], co[10]);
    ALU_1bit u11         (a_in[11], b_in[11], co[10], op[3], op[2], 1'b0, op[1:0] , result[11], co[11]);
    ALU_1bit u12         (a_in[12], b_in[12], co[11], op[3], op[2], 1'b0, op[1:0] , result[12], co[12]);
    ALU_1bit u13         (a_in[13], b_in[13], co[12], op[3], op[2], 1'b0, op[1:0] , result[13], co[13]);
    ALU_1bit u14         (a_in[14], b_in[14], co[13], op[3], op[2], 1'b0, op[1:0] , result[14], co[14]);
    ALU_1bit u15         (a_in[15], b_in[15], co[14], op[3], op[2], 1'b0, op[1:0] , result[15], co[15]);
    ALU_1bit u16         (a_in[16], b_in[16], co[15], op[3], op[2], 1'b0, op[1:0] , result[16], co[16]);
    ALU_1bit u17         (a_in[17], b_in[17], co[16], op[3], op[2], 1'b0, op[1:0] , result[17], co[17]);
    ALU_1bit u18         (a_in[18], b_in[18], co[17], op[3], op[2], 1'b0, op[1:0] , result[18], co[18]);
    ALU_1bit u19         (a_in[19], b_in[19], co[18], op[3], op[2], 1'b0, op[1:0] , result[19], co[19]);
    ALU_1bit u20         (a_in[20], b_in[20], co[19], op[3], op[2], 1'b0, op[1:0] , result[20], co[20]);
    ALU_1bit u21         (a_in[21], b_in[21], co[20], op[3], op[2], 1'b0, op[1:0] , result[21], co[21]);
    ALU_1bit u22         (a_in[22], b_in[22], co[21], op[3], op[2], 1'b0, op[1:0] , result[22], co[22]);
    ALU_1bit u23         (a_in[23], b_in[23], co[22], op[3], op[2], 1'b0, op[1:0] , result[23], co[23]);
    ALU_1bit u24         (a_in[24], b_in[24], co[23], op[3], op[2], 1'b0, op[1:0] , result[24], co[24]);
    ALU_1bit u25         (a_in[25], b_in[25], co[24], op[3], op[2], 1'b0, op[1:0] , result[25], co[25]);
    ALU_1bit u26         (a_in[26], b_in[26], co[25], op[3], op[2], 1'b0, op[1:0] , result[26], co[26]);
    ALU_1bit u27         (a_in[27], b_in[27], co[26], op[3], op[2], 1'b0, op[1:0] , result[27], co[27]);
    ALU_1bit u28         (a_in[28], b_in[28], co[27], op[3], op[2], 1'b0, op[1:0] , result[28], co[28]);
    ALU_1bit u29         (a_in[29], b_in[29], co[28], op[3], op[2], 1'b0, op[1:0] , result[29], co[29]);
    ALU_1bit u30         (a_in[30], b_in[30], co[29], op[3], op[2], 1'b0, op[1:0] , result[30], co[30]);
    ALU_1bit_overflow u31(a_in[31], b_in[31], co[30], op[3], op[2], 1'b0, op[1:0] , result[31], set , overflow);

    assign zero = ~|(result) ; // NOR result 모든 비트가 0이면 zero 참

endmodule

module ALU_1bit(
    input a_in,
    input b_in,
    input carry_in,
    input invert_a,
    input invert_b,
    input less,
    input [1:0] op, // 00 AND 명령 , 01 OR 명령 , 10 ADD 명령, 11 slt 명령, 00 NOR 명령
    output result,
    output carry_out
    );

    wire a_out, b_out;
    wire and_out,or_out,sum;

    fulladder_1bit_structuarl add( .a(a_out) , .b(b_out) , .carry_in(carry_in) , .sum(sum) , .carry_out(carry_out) );
    mux_operation m2( op, and_out, or_out , sum, less, result);
    // MUX에서 연산 결과중 하나를 op를 보고  선택해야함

    and( and_out, a_out , b_out );
    or( or_out, a_out, b_out);
    xor( a_out, a_in, invert_a ); // invert A 명령 , invert_a 이 1이면 A가 1이면 0 A가 0이면 1
    xor( b_out, b_in, invert_b ); // invert B 명령 , invert_b 이 1이면 B가 1이면 0 B가 0이면 1
    // invert 명령이 정해지면 a_out, b_out 값이 정해짐

endmodule

module mux_operation(
    input [1:0] op,
    input and_out,
    input or_out,
    input sum,
    input less,
    output result
    );

    assign result =  (op==2'b00) ? and_out :
                     (op==2'b01) ? or_out :
                     (op==2'b10) ? sum :
                     (op==2'b11) ? less : 1'b0; // result[63:1] 까지는 모두 0이 들어감 result[0]에는 A+B'+1=A-B 의 MSB가 할당됌

endmodule

module ALU_1bit_overflow(
    input ai, // a_in
    input bi, //b_in
    input ci, // carry_in
    input aiv, // a_invert
    input biv, // b_invert
    input less,
    input [1:0] op,
    output re, // result
    output set, // less than
    output of // overflow
    );
    wire ao,bo,co;
    wire o1,o2,o3;

    fulladder_1bit_structuarl add( ao, bo, ci, o3, co); // o3에는 sum , co에는 carry_out 나옴

    mux_operation m2(op, o1, o2, o3, less, re); // o1=and_out , o2=or_out, o3=sum, less=less, re=result

    and( o1 , ao, bo);
    or( o2 ,ao, bo);
    xor(ao, ai, aiv );
    xor(bo, bi, biv );
    assign set = o3; // A+B'+1 =A-B 했는데 MSB가 1이면 slt 0이면 sgt
    assign of = (ci^co) ; // overflow truthtable . a와 b의 부호가 같을때 ci과 co 가 다르면 overflow

endmodule

module fulladder_1bit_structuarl(
    input a,
    input b,
    input carry_in,
    output sum,
    output carry_out
    );
    wire s1,carry_case1,carry_case2;

    xor G1(s1,a,b); // s1 =  a , b 둘중 하나만 1이면
    xor G2(sum,s1,carry_in); // sum = s1 , carry_in 둘중 하나만 1이면
    and G3(carry_case1,a,b); // a,b가 둘다 1이면 carry case1
    and G4(carry_case2,s1,carry_in); // a,b 둘중 하나만 1이면서 carry_in도 1이면 carry case2
    xor G5(carry_out,carry_case2,carry_case1); // carry_case 둘중 하나만 1이면 carry_out

endmodule

Phasor

이해와암기 사이 — Thu, 13 Apr 2023 14:34:46 +0900

Phasor 아무리 공부해도 이해가 잘안된다.

Phasor 설명은 들으면 너무 당연해서 이해가 된다.

복소수를 극좌표,오일로공식,벡터로 표현할 수 있다. 얼마나 간단해?

그럼에도 Phasor가 이해 안됐던건 각각의 극좌표,오일러공식,벡터 표현에 대한 물리적 의미를 모르기 때문이라고 생각한다.

우리가 표현하는 숫자 $1,2,3,4,5$ 같은건 저항이나 질량 어떤 물리량을 나타낸다. 그걸 표현하려고 숫자를 쓴다.

그런데 이 물리량들 사이에서 어떤 관계가 있다는걸 알게 됐다. $4=1+3$ 같은 이걸 대수학 $Algebra$에서는 $y=1+x$ 이런식으로 나타냈다. 직각삼각형이 발견되고 $cos(\theta)=$$y\over x$ 이런 식도 얻어 냈다.

음수의 개념이 발견되고 가만히 생각해보니까 이상하다.

$1은 1\times (+1)$ 이다. $5는 5\times (+1)$ 이다. $-1은? 1\times(-1)$이다. $-5는 5\times(-1)$이다.

대수학에서는 $-x=x\times(-1)$로 나타낸다.

숫자에는 앞으로 가든지$\times(+1)$ 뒤로가든지$\times(-1)$ 어떤 방향이 있다는걸 알아냈다.

그런데 $\times(+1)$ , $\times(-1)$ 이 두 방향의 절반에 해당하는 방향이란것도 있을까? 숫자가 방향을 가진다면 그 방향이 꼭 1과 -1뿐일까? 방향은 크기가 1인 어떤 곱하기로 표현된다. 상상으로 1과 -1사이의 절반에 해당하는 방향을 정의해보자.

$\sqrt-1$ $\times$$\sqrt-1$$=-1=i^2$

$-5는 5\times i^2 $

그런데 이쯤되면 또 궁금해진다. $i$가 +1과 -1의 방향의 절반을 나타낸다면 $i$ 방향의 절반은 어떻게 정의될까?

그리고 그 절반의 절반은? 절반의 절반의 절반은?

이것을 각도 개념으로 생각해보면 1에서 -1까지로 변하는 방향은 각도와 연결지어 생각할 수 있다.

어떤수에 -1을 곱한다는건 방향이 1에서 -1까지 $180^{\circ}$ 변했다는 뜻이고 어떤수에 $i$를 곱한다는건 방향 1에서 -1까지 $90^{\circ}$ 변했다는 말과 같다. i방향의 절반은 $45^{\circ}$ 변했다는 말과 같을 것이다.

오일러는 그걸 이렇게 표현했다.

$$e^{j\theta}=cos(\theta)+jsin(\theta)$$

$$e^{j0}=cos(0)+jsin(0)=1+j0=1$$

$$e^{j\cfrac{\pi}{4}}=cos(\cfrac{\pi}{4})+jsin(\cfrac{\pi}{4})=\cfrac{\sqrt2}{2}+j\cfrac{\sqrt2}{2}$$

$$e^{j\cfrac{\pi}{2}}=cos(\cfrac{\pi}{2})+jsin(\cfrac{\pi}{2})=j$$

$$e^{j\pi}=cos(\pi)+jsin(\pi)=-1$$

다시 처음으로 가서 숫자는 물리량을 표현하기위한 도구라고 했다. $e^{j\theta}$ 라는 숫자는 +1이나 -1처럼 방향을 위해 곱해지는 어떤 수이다. $1\times e^{j\theta}$ 라고 하면 크기가 1인 물리량이 $\theta$ 만큼 회전한 값이다.

오일러 공식까지 잘 이해가 된 지금 이순간 $e^{2\pi ft}$를 곱해보자

$$e^{j2\pi ft}e^{j\theta}=(cos(\theta)+jsin(\theta))(cos(2\pi ft)+jsin(2\pi ft))$$

$$e^{j2\pi ft}e^{j\theta}=cos(2\pi ft)cos(\theta)+j^2sin(2\pi ft)sin(\theta) +j(cos(2\pi ft)sin(\theta)+sin(2\pi ft)cos(\theta))$$

$$e^{j2\pi ft}e^{j\theta}=cos(2\pi ft)cos(\theta)-sin(2\pi ft)sin(\theta) +j(cos(2\pi ft)sin(\theta)+sin(2\pi ft)cos(\theta))\tag1$$

이제 좌변을 정리해보자

$$ e^{j2\pi ft}e^{j\theta}=e^{j(2\pi ft + \theta)} = e^{j\phi}$$

오일러 공식 꼴로 정리된다. 풀어보면

$$e^{j\phi}=cos(\phi)+jsin(\phi)$$

$$e^{j(2\pi ft + \theta)}=cos(2\pi ft + \theta)+jsin(2\pi ft + \theta)\tag2$$

1과 2가 같으므로 정리하면

$$e^{j(2\pi ft + \theta)}=cos(2\pi ft + \theta)+jsin(2\pi ft + \theta)\\=cos(2\pi ft)cos(\theta)-sin(2\pi ft)sin(\theta) +j(cos(2\pi ft)sin(\theta)+sin(2\pi ft)cos(\theta))\tag3$$

3번식을 잘 살펴보고 역으로 $cos$을 정의해보자 $\Re$기호는 Real part라고 읽고 $j$항을 버리고 실수부를 취하는 기호다.

$$cos(2\pi ft + \theta)=cos(2\pi ft)cos(\theta)-sin(2\pi ft)sin(\theta)$$

$$cos(2\pi ft + \theta)=\Re \{cos(2\pi ft)cos(\theta)-sin(2\pi ft)sin(\theta) +j(cos(2\pi ft)sin(\theta)+sin(2\pi ft)cos(\theta))\}$$

$$cos(2\pi ft + \theta)=\Re \{e^{j2\pi ft}e^{j\theta}\}$$

이제 다왔다. 마지막으로 하나만 더 짚고 넘어가자.

$cos(0)=1$이고 $cos(\cfrac{\pi}{4})=\cfrac{\sqrt2}{2}$이고 $cos(\cfrac{\pi}{2})=0$이다. 변수로 각도를쓴다.

우리는 발전소에서 터빈의 시간에 따른 회전에 의해 교류 전류를 얻는다. 그리고 우리는 그 교류전류가 궁금하다.

전류는 시간에 따라서 정현파(cos sin 모양을 정현파라고 한다) 모양이고 전압도 마찬가지이다.

그럼 $cos(x)$ 에서 그 값을 결정짓는 변수가 각도가 아닌 1초 2초 3초 4초 5초 이런 시간이어야 한다.

$cos( radian ) = cos( second \times \cfrac{1}{second} \times radian )$
이렇게 바꾸고 보니 시간변수로 $\pi$를 쓰는건 너무 불편할거 같다. $t=3.14...$초라니 끔찍하다.

1초가 되면 $2\pi$가 나와서 $cos$함수가 1주기를 가지면 편할거 같다.

$cos( radian ) = cos( second \times \cfrac{1}{second} \times 2\pi )$

$cos( radian ) = cos( t \times f \times 2\pi )=cos(t \times \omega)$ $\quad \omega = 2\pi f$, $\quad f=1/T$ ,$\quad v=\lambda$ ,$\quad f=\cfrac{\lambda}{T}$

페이저를 이해하기위한 모든 준비가 끝났다.

어떤 교류전기($cos(2\pi ft)$)를 해석함에 있어서 물리량 $V , I , R,L,C$들의 관계가 궁금한데 그것들의 관계는 $cos(2\pi ft)$에 대해서 위상차이($e^{j\theta}$)로만 나타나지 주파수(f)는 바뀌진 않는다는 사실

$cos(2\pi ft + \theta)=cos(2\pi ft)cos(\theta)-sin(2\pi ft)sin(\theta)$

$cos(2\pi ft + \theta)=cos(\theta)cos(2\pi ft)-sin(\theta)sin(2\pi ft)$

이제 이 크기가 1인 숫자를 A배 곱해서 물리량을 나타내보자. 5V 3V 이런식의 의미로

$ \Re \{Ae^{j2\pi ft}e^{j\theta}\}=Acos(2\pi ft + \theta)=Acos(\theta) cos(2\pi ft)-Asin(\theta)sin(2\pi ft)$

$Acos(2\pi ft + \theta)=Xcos(2\pi ft)-Ysin(2\pi ft)$

$ 2\pi ft$주파수는 이미 알고 있는 물리량이므로 우리가 궁금한 물리량 위상차 $\theta$에 관한 부분을 변수로 바꾸면 위와 같은 식이된다.

$ X=Acos(\theta), Y=Asin(\theta)$

이제 페이저의 정의를 따라가서 하나씩 설명해보면

오일러 공식으로 돌아가서 $e^{j2\pi ft}Ae^{j\theta}$ 위상차 부분의 항만 떼서 생각해보자

$Ae^{j\theta} = Acos(\theta)+jAsin(\theta) = X+jY$ 이걸 주파수 $f$에대한 $Phasor$ 복소표현이라고 부른다.

극좌표 표현은 (X,Y)를 복소평면에 찍고 길이와 각을 구해서 표현한다. $Phasor$ 이해와는 관계 없으므로 여기서 자세히 다루진 않겠다.

햇갈리지말고 예제를 보면서 따라가자

예제1 $V=2j$ 일때 v(t)는?

$e^{j2\pi ft}Ae^{j\theta}$ 을 머리속에 넣고 살자

$Ae^{j\theta}=X+jY=2*0+j2*1=cos(\pi /4)+j2sin(\pi /4)\\=2e^{j\pi /4} ,\quad 2\angle 90^{\circ}$

$v(t)=X\cdot cos(2\pi ft)+Y\cdot -sin(2\pi ft)$

$v(t)=-2sin(2\pi ft)$

예제2 $v(t)=cos(2\pi ft)$ 의 복소표현은?
$X=1 , Y=0$

$V=1$ $ \quad 1\angle 0^{\circ}$

예제3 $v(t)=cos(2\pi ft)+2sin(2\pi ft)$ 의 복소표현은?

$X=1, Y=-2$

$V=1-2j$ $ \quad \sqrt{5} \angle -63.43^{\circ} $

정리

$Phasor$는 주파수 f가 고정일때 $ 2\pi ft + \theta $ 에서 위상차 $\theta$에 대한 부분을 오일러 공식을 이용해 $e^{j2\pi ft}Ae^{j\theta}$ 곱하기로 분리했고 위상차 $\theta$ 항을 $V=X+jY$로 표현했다.

새로운 개념이 어떻게 정의되는지 알았으니 왜? 쓰는지 알아보자

$V=X+jY \quad Acos(\omega t + \theta)= Xcos(\omega t)-Ysin(\omega t) \quad ,for \quad \omega = 2\pi ft$

$V_{1}=X_{1}+jY_{1} \quad Acos(\omega t + \theta_{1})= X_{1}cos(\omega t)-Y_{1}sin(\omega t)$

$V_{2}=X_{2}+jY_{2} \quad Acos(\omega t + \theta_{2})= X_{2}cos(\omega t)-Y_{2}sin(\omega t)$

$V_{1}+V_{2}= \{ X_{1}+X_{2} \} + j \{Y_{1}+Y_{2}\} = X+jY $

$X_{1}cos(\omega t)-Y_{1}sin(\omega t)+X_{2}cos(\omega t)-Y_{2}sin(\omega t) = (X_{1}+X_{2})cos(\omega t)-(Y_{1}+Y_{2})sin(\omega t)\\= Xcos(\omega t)-Ysin(\omega t)$
덧셈법칙이 성립하는걸 Additivity 가 성립한다고 한다. 주파수f에 대한 페이저끼리 더해도 결과는 주파수 f에대한 페이저다.

$pV=pX+jpY \quad pAcos(\omega t + \theta)= pXcos(\omega t)-pYsin(\omega t)=p\{Xcos(\omega t)-Ysin(\omega t)\}$
p는 실수이다. 위 성질이 성립하는걸 Homogeneity를 만족한다고 한다.

오일러공식(=극좌표) 모양으로 정리해서 곱셈을 해보면 더 재밌다.

$e^{j2\pi ft}A_{1}e^{j\theta_{1}}$ , $ e^{j2\pi ft}A_{2}e^{j\theta_{2}} $

곱하면 $ A_{1}e^{j\theta_{1}}\cdot A_{2}e^{j\theta_{2}} = A_{1}A_{2}e^{j(\theta_{1}+\theta_{2})}=Ae^{j\theta}$
$Phasor$끼리의 곱셈은 극좌표 표현으로 바꾼뒤 크기는 곱하고 각은 더해주면 결과도 $Phasor$이다.

미분

$e^{j2\pi ft}Ae^{j\theta}$

Basic System Properties

이해와암기 사이 — Thu, 6 Apr 2023 15:20:07 +0900

어떤 관측이나 샘플링으로 우리가 시간 $t$에따라 값이 결정되는 함수 $x(t)$를 알고 있다

이제 이걸 $System$이란 상자에 넣는다

자판기에 동전을 넣고 버튼을 누르면 음료수가 나온다.

키보드를 누르면 화면에 글씨가 나온다.

input이 있으면 output이 있다. 그걸 시스템이라고 하자

이제 $y(t)$란 output을 얻었다.

중고등학교때 배운 $y(t)=x(t)$는 지금 여기서 잊어버려라. 시스템을 배우는데 혼돈을 주는 요인이된다.

물리적인 현상에 집중해보자. 현재까지 일어난 일을 정리하면

$x(t)$의 정의 : 시간 $t$에 따라 결정되는 $Input, 우리는 이걸 미리 알고 있다.$

$y(t)$의 정의 : $System$에 입력을 받아서 시간$t$에따라 결정된 $Output$

오로지 정의에 따라서 생각 해보자.

간단하게 $t=-1$ (과거), $t=0$ (지금) , $t=1$ (미래) 라고 생각해보자

$x(0)$ 이면 지금에서 input이다. $x(t)$ 정의 자체가 시간 t에서 Input이라고 했다.

$x(-1)$ 이면 과거에서 input이다.

$x(1)$ 이면 미래에서 input이다.

여기까지가 준비 이제 이걸로 시스템의 6가지 성질을 알아보자.

시스템은 Input과 Output을 =로 연결해주는 역할을 한다. 어떻게 연결하는지는 시스템 마음이다.

$y(t) = x(t+5)$ 이녀석은 어떤 시스템일까? 해석해보자 지금(t=0) 과거(t=-1) 미래(t=1) 각각에 대하여

$$y(0) = x(0+5)$$

현재의 결과값 $y(0)$이 $x(5)$이다. 즉, 현재의 아웃풋이 t=5초일때 인풋으로 결정된다는 말과 같다.

$x(5)$는 미래의 입력값이다.

$$y(-1) = x(-1+5)$$

$$y(1) = x(1+5)$$

마찬가지로 과거의 값이 미래 입력을 받아서 결정된다. 미래의 값또한 미래입력에 대해서 결정된다.

몇가지 예제를 보자

$$y(t)=x(2t)$$

$t=0$일때, $y(0)=x(0)$ , $t=0$과 $x(0)$ 시점이 같다

$t=-1$일때, $y(-1)=x(-2)$ , $t=-1$과 $x(-2)$ 시점이 다르다.

$t=1$일때, $y(1)=x(2)$ , $t=-2$와 $x(2)$ 시점이 다르다.

무조건 괄호안의 숫자만 보고 판단한다.

$$y(t)=x(-t)$$

$t=0$일때, $y(0)=x(0)$ 아웃풋이 현재 인풋으로 정해진다. $t=0$과 $x(0)$ 시점이 같다.

$t=-1$일때, $y(-1)=x(1)$ 아웃풋이 미래 인풋으로 정해진다. $t=-1$과 $x(1)$이 시점이 다르다.

$t=1$일때, $y(1)=x(-1)$ 아웃풋이 과거인풋으로 정해진다. $t=1$과 $x(-1)$이 시점이 다르다.

$$y(t)=sin(2t)\times x(t)$$

$t=0$일때, $y(0)=sin(2\times 0)\times x(0)$ , $t=0$과 $x(0)$이 시점이 같다.

$t=-1$일때, $y(-1)=sin(2\times -1)\times x(-1)$ , $t=-1$과 $x(-1)$이 시점이 같다.

$t=1$일때, $y(1)=sin(2\times 1)\times x(1)$ , $t=1$과 $x(1)$이 시점이 같다.

$$y(t)=e^{-x(t)-t}$$

이제 눈치 챘으면 안해봐도 $t=-1,0,1$ 일때 $x(-1),x(0),x(1)$ 인풋으로 그 시간의 입력값을 받것을 알 수 있을것이다.

앞에 무엇이 곱해졌건 어떤 형태를 띄건간에 그건 시스템이 결정하는 일이고 우리는 그 시스팀이 어떤 인풋을 받아서 t=? 일때 값을 결정하는지만 관심있다.

$$y(t)=\int^t_{-\infty}x(t)dt$$

하지만 무작정 $x(t)$만보고 달려들면 안된다. 항상 의미를 잘 생각해야한다. 이 시스템은 어떻게 될까?

편의상 아래와 같은 x(t)가 있다고 생각해보자

t=-4이거나 그보다 작을때는 적분값이 0이므로 아웃풋이 0이 될것이다.

t=0이면? 적분값은 3.5가 될것이다.

t가 1정도 왔다고 해보자 3.5+ 0부터1까지의 x(t) 값을 모두 더한게 y(1)이 될것이다.

이 시스템은 y(1)=y(0)+x(0.1)+...+x(0.2)+...+x(0.3)+...x(0.9)+... 과거의 인풋으로 현재 값이 결정된다.

이제 다 알아봤다. 특징을 구분할 수 있는 눈을 가졌으니 특징이 어떤것들이 있는지 살펴보자.

1. 첫번째 특징 Static and Dynamic (Memoryless / Memory)

아웃풋이 오직 현재의 입력에만 의존한다. $sin(-3t)$가 곱해지건 $e^{-1/t}$가 곱해지건 $t=T$일때 오직 인풋$x(T)$에만 관계되면 이를 Static 시스템(=Memoryless System)이라고 한다.

2. 두번째 특징 Casual

아웃풋이 오직 현재까지의(지금보다 과거도 됨) 입력에만 의존한다. 즉 $t=T$일때 $x(T+k) ,(k>0)$의 인풋을 요구하지 않는다. 어떤 아웃풋이건 현재나 과거에 입력이 있었다고 생각하면 좋다.

3. 세번째 특징 Time invarient

시스템이 시간에따라 변하지 않는다.

이를 직관적으로 이해하려면 시스템과 아웃풋 인풋을 나눠서 생각 할 필요가 있다.

아웃풋은 $y(t)$ 인풋은 $x(t)$ 그리고 그 둘을 $=$로 연결해주는게 시스템이라고 했다.

$$y(t)=x(2t)$$

$$y(t)=e^t\times x(2t)$$

다음 두가지 경우를 생각해보자. 첫번째 시스템은 $t=1$ 일때 $y=x(2)$ 이고 $t=1-1=0$ 일때 $y(0)=x(0)$ 이다.

두번째 시스템은 어떤가? $t=1$일때 $y=e*x(2) = 2.718..\times x(2)$ $t=1-1$일때 $y(0)=x(0)$이다.

t와 input 관계는 두 시스템 모두 동일하지만 Output과 t의 관계에서 차이가 있다.

간단하게 생각해서 $x(t)=1$이라고 해보자 모든 $t$에대해서 인풋은 항상 1로 결정된다.

시스템1에서는 어떤 $t$를 집어넣어봐도 (=인풋을 언제 넣더라도) 아웃풋이 항상 동일하다

반면 시스템2에서는 $x(t)$의 값과는 상관없이 시간 $t$가 크거나 작아짐에 따라서 아웃풋이 변해버린다.

시스템 1을 TI 시스템2를 TV(time varying)이라고 한다.

더 직관적으로 이해하자면 자판기가 있다. 내가 오후 1시에 자판기에 1000원을 넣어도 음료수는 1개가 나오고 오후 4시 오후11시에 넣어도 음료수는 여전히 1개가 나올것이다. 오로지 인풋만 시간항에 관계하면 Ti 이다.

그렇지만 택시는 어떤가? 낮에 택시를 타면 4800원이지만 밤 11시에 타면 5300원이 기본요금이다.

특정시간 $t=0$에만 $x(t)=1$ 이 되는 인풋이있다고 하자 ( $x(t)=1$일때 무언가를 5000원주고 해야지)

입력을 시간지연 시켜서 $x(t-오후1시)$, $x(t-오후4시)$, $x(t-오후11시)$

시스템 $T( 자판기, 택시)$ 에 들어 갔더니

아웃풋 $y( 음료수 5개, 이동거리 다름)$ 일정하면 $TI$ 일정하지 않으면 $TV$

식으로 쓰면

$$y(t)=T[x(t)]이면\;\, T[x(t-t_{0})] = y(t-t_{0}) 이다\;\, for\;\, \forall \,t_{1},t_{2} \in t$$