Latch NAND

Como mostra a Figura 11(a) o latch NAND é composto por duas portas lógicas NAND, com isso foi criado uma função contendo as funções da operação NAND já citadas, assim:

Código 09 – Função Latch NAND

Flip_Flop latch_NAND(int set, int reset,Flip_Flop flip){ flip.Q=NAND(2,set,flip.Q_);

flip.Q_=NAND(2,reset,flip.Q); return flip;

}

Os parâmetros são as entradas comuns do latch, o SET como primeiro parâmetro, o RESET como segundo, e o terceiro é o próprio registro do FF, pois ele será alterado e será o retorno da função com saídas modificadas. Após declarar uma variável do tipo Flip_Flop, esta função em void loop() ficará:

FF1= latch_NAND (A,B,FF1); digitalWrite(ledout1,FF1.Q); digitalWrite(ledout2,FF1.Q_);

A entrada ‘A’ representar o SET, e a ‘B’ o RESET, como a função é do tipo Flip_Flop, a variável declarada anteriormente receberá a função, o ideal é que após a execução da mesma, em seguida seja executado o comando de representar as saídas (digitalWrite();) como já foi mencionado.

3.1.2.2 Latch NOR

O latch NOR foi representado com o mesmo procedimento, seguindo a base de sua representação, composto por duas portas NOR, sua função ficou:

Código 10.1 – Função Latch NOR

Flip_Flop latch_NOR(int set, int reset,Flip_Flop flip){ flip.Q=NOR(2,reset,flip.Q_);

flip.Q_=NOR(2,set,flip.Q); return flip;

Com a mesma ordem de parâmetros da função “latch_NAND”, e será similar sua representação no void loop();:

FF1= latch_NOR (A,B,FF1); digitalWrite(ledout1,FF1.Q); digitalWrite(ledout2,FF1.Q_);

Foi criado outra alternativa de função, com base na tabela-verdade, onde usam comandos de condições para gerar as saídas:

Código 10.2 – Função Latch NOR

Flip_Flop latch_NOR (int set,int reset,Flip_Flop flip){ if(!set && reset){

flip.Q=LOW;

flip.Q_=HIGH;

}else if(set && !reset){

flip.Q=HIGH;

flip.Q_=LOW;

}else if(set && reset){

flip.Q=LOW;

flip.Q_=LOW;

}

return flip; }

Esta alternativa contém os mesmo parâmetros e a mesma saída, porém não é formada com portas lógicas.

3.1.2.3 Clock

O clock foi representado por uma variável do tipo inteiro, “int clock=0” que inicialmente foi declarado e atribuído o valor zero, e para representar o sinal como todo, foi declarada outra variável e atribuída o valor zero, “int tempo=0”. O sinal de clock no void loop() ficou:

Código 11 – Representação do Clock delay(10); tempo+=10; if(tempo>CLK){ tempo=0; } if(tempo==CLK/2){ clock=1; }else{ clock=0; }

Inicialmente, a linguagem de programação do Arduino tem uma função delay() que pausa sua execução em um determinado tempo em milissegundos, no exemplo foi pausado 10 milissegundos, logo após a variável tempo será incrementado de 10, consequentemente, estará acumulando o tempo da pausa, em seguida, terá um comando de condição, caso o tempo seja maior que a constante CLK (o tempo do período do clock em milissegundos) ele será zerado. Se o tempo for igual à metade do período, o clock será atribuído de 1, se não, 0, isso representará a borda de descida ou subida quando clock=1.

3.1.2.4 Flip-flop S-R

O FF S-R foi representado com portas lógicas, mas diferente das funções anteriores, os FFs precisam de um parâmetro a mais, que será o clock, e foi elaborado conforme a Figura 20. Assim:

Código 12 – Função Flip-flop S-R

Flip_Flop FF_SR(int S,int R,Flip_Flop flip,int clock){ flip.Q=NAND(2,NAND(2,S,clock),flip.Q_); flip.Q_=NAND(2,NAND(2,R,clock),flip.Q); return flip;

Figura 20 – Circuito interno do Flip-flop S-R

Fonte: TOCCI; WIDMER; MOSS (2011)

A função retornará a saída de acordo com as entradas que foram mostradas na tabela- verdade. Pode-se representar com comando de repetições como foi citado, porém o código fica menor representado somente com a combinação de portas lógicas. A função será chamada como:

FF1= FF_SR (A,B,FF1,clock); digitalWrite(ledout1,FF1.Q); digitalWrite(ledout2,FF1.Q_);

Quando o clock=1 representará a borda de subida ou descida, assim irá satisfazer a tabela-verdade.

3.1.2.5 Flip-flop J-K

A função do FF J-K foi construída similar à função “FF_SR” com as funções das portas lógicas, e com seus parâmetros com entradas respectivamente, e foi desenvolvida como apresenta na Figura 21, com isso terá:

Código 13 – Função Flip-flop J-K

Flip_Flop FF_JK (int J,int K,Flip_Flop flip,int clock){ int a=NAND(3,J,flip.Q_,clock);

int b=NAND(3,K,flip.Q,clock); flip.Q=NAND(2,a,flip.Q_);

flip.Q_=NAND(2,b,flip.Q); return flip;

}

Figura 21 – Circuito interno do Flip-flop J-K

Fonte: TOCCI; WIDMER; MOSS (2011)

3.1.2.6 Flip-flop D

Esta função terá o mesmo corpo da função do Flip-flop J-K, porem com apenas uma entrada síncrona:

Código 14 – Função Flip-flop D

Flip_Flop FF_D(int D,Flip_Flop flip,int clock){ int a=NAND(3,D,flip.Q_,clock); int b=NAND(3,!D,flip.Q,clock); flip.Q=NAND(2,a,flip.Q_); flip.Q_=NAND(2,b,flip.Q); return flip; }

3.1.2.7 Flip-flop T

Análogo ao FF D, terá somente uma entrada síncrona, e a mesma quantidade de parâmetros, sendo o primeiro a entrada “T”.

Código 15.1 – Função Flip-flop T

Flip_Flop FF_T(int T,Flip_Flop flip,int clock){ int a=NAND(3,T,flip.Q_,clock); int b=NAND(3,T,flip.Q,clock); flip.Q=NAND(2,a,flip.Q_); flip.Q_=NAND(2,b,flip.Q); return flip; }

Como já foi dito, o valor da entrada “T” equivale à entrada “J” e “K” simultâneo em um FF J-K. O FF T também pode ser representado por comandos de condições, e ficará bem simples:

Código 15.2 – Função Flip-flop T

Flip_Flop FF_T(int T,Flip_Flop flip,int clock){ if(clock==1){ if(T==1){ flip.Q_=flip.Q; flip.Q=!flip.Q; } } return flip; }

E como todos os FFs citados, sua representação no void loop() é: FF1= FF_T(A,FF1,clock);

digitalWrite(ledout1,FF1.Q); digitalWrite(ledout2,FF1.Q_);

3.1.2.8 Flip-flop J-K com entradas assíncronas

Como FFs com entradas assíncronas têm mais entradas do que o normal, consequentemente têm mais parâmetros. Foram adicionados mais dois parâmetros para

representações das entradas CLEAR e PRESET e o corpo da função foi representado por comandos de condições.

Código 16 – Função Flip-flop J-K com entradas assincronas

Flip_Flop FF_JKassincrono(int J,int K,int CLR,int PRE,Flip_Flop flip,int clock){ if(CLR==1 && PRE==1){

if(clock==1){ if(!J && K){

flip.Q=LOW;

flip.Q_=HIGH;

}else if(J && !K){

flip.Q=HIGH;

flip.Q_=LOW;

}else if(J && K){

flip.Q=!flip.Q;

flip.Q_=!flip.Q_;

}

}

}else if(CLR==1 && PRE==0){

flip.Q=HIGH;

flip.Q_=LOW;

}else if(CLR==0 && PRE==1){

flip.Q=LOW; flip.Q_=HIGH; }else{ flip.Q=LOW; flip.Q_=LOW; } return flip; }

O primeiro comando de condição irá verificar se as entradas assíncronas são iguais a 1, com isso o flip-flop comportará como síncrono, se não vai mudar os valores de saída sem verificar o valor do clock. Sua “chamada” no corpo da função void loop() ficou:

FF1=FF_JKassincrono(A,B,!C,!D,FF1,clock); digitalWrite(ledout1,FF1.Q);

digitalWrite(ledout2,FF1.Q_);

Como as entradas assíncronas são ativas em nível baixo, ficou mais viável usar o complemento dos valores dos push-buttons referentes às mesmas, ‘!C’ para o CLR e ‘!D’ para o PRE.