Calculadoras de valor do transformador de corrente (CT) OpenEnergyMonitor

Essas calculadoras são projetadas para ajudá-lo a determinar os valores dos componentes necessários para o (s) transformador (es) de corrente usado (s) no projeto Open Energy Monitor . Vá dar uma olhada!

Por favor, note que estas calculadoras não levam em consideração a permeabilidade do núcleo e o valor do core AL. Use por sua conta e risco.

Atualização de novembro de 2017: Fórmulas fixas exibidas abaixo de cada calculadora para reduzir pela metade a voltagem do sistema como foi originalmente planejado.


Tensão do sistema: Volts
Para monitores de energia baseados em arduinos de 5V (principalmente os mais antigos), digite 5 acima


Resistor de carga

Calcula o valor do resistor de sobrecarga a ser usado em uma corrente Max RMS do transformador de 
corrente:Amps
Relação atual da volta do sensor:: 1
valor do resistor calculado:Ohms
Fórmula:
burden_resistor = (system_voltage / 2.0) / ((I_RMS * 1.414) / ct_turns)


Corrente máxima

Calcula a corrente máxima que você pode razoavelmente esperar medir usando um transformador de corrente 
Valor do resistor de carga:Ohms
Relação atual da volta do sensor:: 1
corrente máxima calculada de RMS:Amps
Fórmula:
I_RMS = (((system_voltage / 2.0) / burden_resistor) * Turns) * 0.707


O sensor atual gira

Calcula uma estimativa do número de voltas que um transformador de corrente precisaria. 
Valor do resistor de carga:Ohms
Max RMS atual:Amps
O sensor atual gira:
Fórmula:
turns = (I_RMS * 1.414) / ((system_voltage / 2.0) / burden_resistor)

Cálculo Online de Cores de Resistores

Calculadora de código Da Cor Do Resistor

Entre com as cores das faixas do resistor e obtenha seu valor em Ohm�s ( Ω )

Preto
Marron
Vermelho
Laranja
Amarelo
Verde
Azul
Violeta
Cinza
Branco

Preto
Marron
Vermelho
Laranja
Amarelo
Verde
Azul
Violeta
Cinza
Branco

Preto
Marron
Vermelho
Laranja
Amarelo
Verde
Azul
Violeta
Cinza
Branco
Dourado
Prateado

Dourado
Prateado
Nenhum


Valor Da Resist�ncia:

 

Valores padrão de resistores (comercial):

Tabela de resistores comerciais usado na eletrônica:

1 marrom preto dourado
1,2 marrom vermelho dourado
1,5 marrom verde dourado
1,8 marrom cinza dourado
2,2 vermelho vermelho Dourado
2,7 Vermelho Violeta dourado
3,3 laranja laranja dourado
3,9 laranja branco dourado
4,7 amarelo violeta dourado
5,6 verde azul dourado
6,8 azul cinza dourado
8,2 cinza vermelho dourado
9,1 branco marrom dourado
10 marrom preto preto
12 marrom vermelho preto
15 marrom verde preto
18 marrom cinza preto
22 vermelho vermelho preto
27 vermelho violeta preto
33 laranja laranja preto
39 laranja branco preto
47 amarelo violeta preto
56 verde azul preto
68 azul cinza preto
82 cinza vermelho preto
91 branco marrom preto
100 marrom preto marrom
120 Marrom Vermelho Marrom
150 Marrom Verde Marrom
180 Marrom Cinza Marrom
220 Vermelho Vermelho Marrom
270 Vermelho Violeta Marrom
330 Laranja Laranja Marrom
390 Laranja Branco marrom
470 Amarelo Violeta Marrom
560 Verde Azul Marrom
680 Azul Cinza Marrom
820 Cinza Vermelho Marrom
910 Branco Marrom Marrom
1000 ou 1K Marrom Preto Vermelho
1200 ou 1K2 Marrom Vermelho Vermelho
1500 ou 1K5 Marrom Verde Vermelho
1800 ou 1K8 Marrom Cinza Vermelho
2200 ou 2K2 Vermelho Vermelho Vermelho
2700 ou 2K7 Vermelho Violeta Vermelho
3300 ou 3K3 Laranja Laranja Vermelho
3900 ou 3K9 Laranja Branco Vermelho
4700 ou 4K7 Amarelo Violeta Vermelho
5600 ou 5K6 Verde Azul Vermelho
6800 ou 6K8 Azul Cinza Vermelho
8200 ou 8K2 Cinza Vermelho Vermelho
9100 ou 9K1 Branco Marrom Vermelho
10000 ou 10K Marrom Preto laranja
12000 ou 12K Marrom Vermelho Laranja
15000 ou 15K Marrom Verde Laranja
18000 ou 18K Marrom Cinza Laranja
22000 ou 22K Vermelho Vermelho Laranja
27000 ou 27K Vermelho Violeta Laranja
33000 ou 33K Laranja Laranja Laranja
39000 ou 39K Laranja branco Laranja
47000 ou 47K Amarelo Violeta Laranja
56000 ou 56K Verde Azul Laranja
68000 ou 68K Azul Cinza Laranja
82000 ou 82K Cinza Vermelho Laranja
91000 ou 91K Branco Marrom Laranja
100000 ou 100K Marrom Preto Amarelo
120000 ou 120K Marrom Vermelho Amarelo
150000 ou 150K Marrom Verde Amarelo
180000 ou 180K Marrom Cinza Amarelo
220000 ou 220K Vermelho Vermelho Amarelo
270000 ou 270K Vermelho Violeta Amarelo
330000 ou 330K Laranja Laranja Amarelo
390000 ou 390K Laranja Branco Amarelo
470000 ou 470K Amarelo Violeta Amarelo
560000 ou 560K Verde Azul Amarelo
680000 ou 680k Azul Cinza Amarelo
820000 ou 820K Cinza Vermelho Amarelo
910000 ou 910K Branco Marrom Amarelo
1000000 ou 1M Marrom Preto Verde
1200000 ou 1M2 Marrom Vermelho Verde
1500000 ou 1M5 Marrom Verde Verde
1800000 ou 1M8 Marrom Cinza Verde
2200000 ou 2M2 Vermelho Vermelho Verde
2700000 ou 2M7 Vermelho Violeta Verde
3300000 ou 3M3 Laranja Laranja Verde
3900000 ou 3M9 Laranja Branco Verde
4700000 ou 4M7 Amarelo Violeta Verde
5600000 ou 5M6 Verde Azul Verde
6800000 ou 6M8 Azul Cinza Verde
8200000 ou 8M2 Cinza Vermelho Verde
9100000 ou 9M1 Branco Marrom Verde
10000000 ou 10M Marrom Preto Azul
12000000 ou 12M Marrom Vermelho Azul
15000000 ou 15M Marrom Verde Azul
18000000 ou 18M Marrom Cinza Azul
22000000 ou 22M Vermelho Vermelho Azul
Calculadora online de c�digo de Cores de Resistor

Resistores em série


Um circuito de associação em série de resistores, é um circuito em que os resistores (resistências) estão dispostos em uma cadeia, de modo que a corrente tem apenas um caminho a seguir. A corrente é a mesma através de cada resistência. A resistência total do circuito é encontrado simplesmente somando os valores de resistência dos resistores:
Resistores em série: R = R 1 + R 2 + R 3 + …
Resistores em s�rie

Um circuito em s�rie � mostrado acima. A corrente passa atrav�s de cada resistor, por sua vez. Se os valores das tr�s resistências s�o os seguintes:
Com uma bateria de 10 V, por V = IR a corrente total no circuito � a seguinte:
I = V / I = 10/20 = 0,5 A. A corrente atrav�s de cada resist�ncia seria 0,5 A.

 

Resistores em paralelo

 

Em uma associa��o em paralelo de resistores � um circuito em que as resistências s�o dispostos lado a lado. Nesse caso a tens�o em todos os resistores � igual, mas a soma das correntes que atravessam os resistores � igual � resist�ncia do resistor. Ent�o a resistência equivalente de uma associação em paralelo � sempre menor que o resistor de menor resistência da associa��o.

A resistência total de um conjunto de resistores em paralelo � encontrado somando-se os rec�procos dos valores das resistências e, em seguida, tomar o recíproco do total:

resistência equivalente de resistores em paralelo: 1 / R = 1 / R 1 + 1 / R 2 + 1 / R 3 + …

Resistores em paralelo
Um circuito paralelo � mostrado acima. Neste caso, a corrente fornecida pela bateria divide-se, e a quantidade que passa por cada resistor depende da resist�ncia. Se os valores das três resistências s�o os seguintes:
Com uma bateria de 10 V, por V = IR a corrente total no circuito � a seguinte: I = V / I = 10/2 = 5 A.

As correntes individuais tamb�m pode ser encontrado usando I = V / R. A tens�o em cada resist�ncia � de 10 V, de modo que:
I 1 = 10/8 = 1,25 A
I 2 = 10/8 = 1,25 A
I 3 = 10/4 = 2,5 A

Sensor Transdutor de Pressão

TESTADO EM ARDUINO UNO R3

//Eu sou capaz de obter leituras precisas (+- 1-2 PSI) deste sensor com o seguinte código Arduino.

//Placa: Arduino UNO R3  IDE: Arduino IDE Version 1.8.5 ;  S O: Windows 10

//Conectando o sensor PSI no Arduino: Vermelho: +5V  Preto: GND (Ground)  Amarelo: Conecta-se ao pino analogico 0 (A0)

void setup()

{

 Serial.begin(9600);

}

void loop()

{

float sensorVoltage = analogRead(0);

//Lê os dados que chegam do sensor PSI em

//Arduino pin# A0.

int psi = ((sensorVoltage – 102 ) * 175 / ( 921 – 102 ));

//Matematica para converter dados analogicos em PSI.

Serial.print(“PSI “); //Imprime “PSI” no monitor serial.

Serial.println(psi); //Imprime “PSI” no monitor serial.

the serial monitor. delay (5000);//Pausas de 5 segundos entre as leituras.

}

 

Fonte: https://www.ebay.com/itm/G1-4-inch-5V-0-1-2-MPa-Pressure-Transducer-Sensor-Oil-Fuel-Diesel-Gas-Water-GL/112592366514?epid=16008939195&hash=item1a37072bb2:g:9vUAAOSwe2FZ2FZI&shqty=1&isGTR=1#shId

Linguagem ladder

A linguagem Ladder foi originalmente desenvolvida para construir e melhor documentar circuitos a relés, utilizados em processos de produção [1]. Todos os dispositivos dos circuitos elétricos como botões, válvulas e solenoides podem ser representados em símbolos nos Diagramas Ladder, incluindo suas conexões.

Atualmente, a linguagem ladderdiagrama ladder ou diagrama de escada é um auxílio gráfico para programação de Controladores Lógicos Programáveis (CLPs), no qual as funções lógicas são representadas através de contatos e bobinas, de modo análogo a um esquema elétrico com os contatos dos transdutores e atuadores. A linguagem ladder está entre as cinco linguagens de programação de CLPs definidas pela IEC 61131-3 : FBD (Function Block DiagramDiagrama de Blocos), LD (Ladder diagram, Diagrama Ladder), ST (Structured text, Texto Estruturado), IL (Instruction listLista de Instruções) e SFC (Sequential function chartDiagrama de Funções Sequenciais[2] [3].

O nome (ladder, escada em inglês) provém do fato que a disposição dos contatos e bobinas é realizada, de maneira geral, na vertical, que lembra o formato de uma escada. A cada lógica de controle se dá o nome de rung (degrau), composta por linhas e colunas [4].

A verificação do código pode variar entre as marcas de CLPs, mas é comum que a atualização seja feita da esquerda para a direita e de cima para baixo.

Visão Geral

A linguagem Ladder é uma linguagem de baixo nível utilizada para programar CLPs, capaz de realizar o controle de sistemas críticos e/ou industriais, substituindo os antigos circuitos controladores a relés que eram caros e de difícil manutenção, além de menos seguros. A principal vantagem de representar as lógicas de controle por meio de diagramas Ladder é que permite à engenheiros e técnicos de campo desenvolver “códigos” sem conhecimento prévio de outras lógicas de programação como o FORTRAN ou o C, devido à familiaridade com a lógica a relés. [5]

Um dos principais problemas apresentados pela linguagem é a incompatibilidade entre CLPs, mesmo entre modelos diferentes da mesma família. Embora a IEC 61131-3 tenha diminuído as diferenças mais marcantes entre os diferente CLPs, transferir um código de um controlador para o outro ainda pode ser um trabalho custoso.

Devido ao fato de todos os processos do diagrama serem realizados pelo processador (CPU) do CLP de forma sequencial, é preciso de um uma estrutura de loop que executa um certa quantidade de vezes por segundo, fazendo com que os resultados na saída sejam quase imediatos. Para isso, o CLP utiliza um Ciclo de Varredura que consiste nos seguintes passos:

  • Leitura das entradas e atualização da memória, que podem ser tantos as entradas externas como sensores e chaves, como entradas internas como valores de bobinas e temporizadores.
  • Execução do programa, onde todos os passos da programação são realizados, da esquerda para a direita e de cima para baixo. Nenhum valor obtido nesse processo é utilizado nos cálculos, portanto se alguma bobina obter um novo valor e houver alguma chave associada a ela, esse valor não é alterado até a próxima execução do ciclo de varredura.
  • Escrita da memória e atualização das saídas, onde os novos valores obtidos no passo de Execução do programa são atualizados na memória e as saídas externas são alteradas.

Os componentes da linguagem

Existem 3 tipos de elementos na linguagem Ladder:

  • as entradas (ou contatos), que podem ler o valor de uma variável booleana;
  • as saídas (ou bobinas) que podem escrever o valor de uma variável booleana;
  • os blocos funcionais que permitem realizar funções avançadas.

Os elementos estão associados à variáveis internas que podem tanto ser virtuais como entradas e saídas físicas de um CLP.

As entradas (ou contatos)

Existem dois tipos de contatos:

  • O contato normalmente aberto (NA) (em inglês, NO normally open):
   X
--| |--  a instrução de LÓGICA DIRETA tem na programação o mesmo nível lógico vinculado ao endereçamento.

Tal contato está fechado quando a variável booleana associada (no nosso caso X) é verdadeira, caso contrário, ele está aberto.

  • O contato normalmente fechado (NF) (em inglês, NC normally closed):
   X
--|/|-- a instrução de LÓGICA INVERSA tem na programação o nível lógico inverso vinculado ao endereçamento.

Tal contato está aberto quando a variável booleana associada é verdadeira, caso contrário, ele está fechado.

As saídas (ou bobinas)

As saídas sempre são bobinas, relés contatores ou “de estado sólido” (óptico, PWM, DC, etc…). Tal saída está ativa quando a variável booleana associada é verdadeira, caso contrário, ela está inativa.

Assim como as entradas, há dois tipos de saídas (bobinas) principais:

  • A bobina normalmente aberta, energizada quando a variável booleana associada é verdadeira.
   X
--( )--  a instrução de SAÍDA LÓGICA tem na programação o resultado em nível lógico que à antecedi.

Tal contato está fechado quando a variável booleana associada (no nosso caso X) é verdadeira, caso contrário, ele está aberto.

  • A bobina normalmente fechada, energizada quando a variável booleana associada é falsa.
   X
--(/)-- a instrução de SAÍDA LÓGICA INVERTIDA tem na programação o resultado em nível lógico inverso que à antecedi.

Alguns tipos de bobinas especiais são chamadas Blocos Funcionais, por possuírem implementações mais complexas, como as bobinas de SET e RESET, que funcionam de forma semelhante a Latchs;

Os blocos funcionais

Os blocos funcionais permitem realizar operações mais complexas que a leitura ou escrita de variáveis. São exemplos de blocos funcionais os contadores, temporizadores, bobinas de set ou reset, etc. Utilizando Diagramas de Blocos, pode-se inclusive criar blocos personalizados (funções encapsuladas) definidas pelo usuário para facilitar a organização. Algumas IDEs fornecem outras opções de blocos funcionais como comparadores (maior que, menor que e igual a), operadores matemáticos (adição, subtração, multiplicação e divisão) e portas lógicas. Ainda há a opção de obter bibliotecas com blocos já prontos para uso. [6]

Temporizadores

Temporizadores são dispositivos utilizados para medir o tempo e atuar ao final do ciclo. Comumente os temporizadores são representados por dois símbolos, um indica um retardo na ativação e outro um retardo na desativação.

Na linguagem Ladder os temporizadores levam alguns argumentos para seu funcionamento, são eles:

  • Entrada para ativação;
  • Tempo a ser atingido (delay do sinal).

Para os temporizadores com delay na subida (TON), no momento que houver uma entrada verdadeira, o tempo programado começará a correr. Após o tempo determinado ser atingido, a saída do temporizador será verdadeira e permanecerá nesse estado enquanto a entrada for verdadeira. Quando o valor da entrada for falso o temporizador volta para o estado falso, sendo que caso outra entrada verdadeira seja aplica o processo ocorrerá novamente. Caso o sinal se torne falso antes de o temporizador atingir o valor máximo, sua contagem é resetada e a saída permanece falsa.

Para os temporizadores com delay na descida (TOF), no momento que aplicar-se uma entrada verdadeira, a saída do temporizador também será verdadeira. Quando o valor da entrada for de verdadeiro para falso, o temporizador contará o tempo programado e então sua saída se tornará falso quando o tempo pré-definido for atingido.

Os temporizadores tem uma grande importância na automatização de processos, devido ao fato de dar ao utilizador o controle do tempo de processos. Os temporizadores podem ser tanto digitais, sendo executados pelo processador, ou físicos, possuindo ligação com o CLP.

Contadores

Os contadores são usados para incrementar ou decrementar um valor até alcançar o número pré-determinado de um processo. As mudanças de estado de um sinal externo são acumuladas, não importando o tempo, apenas a transição. São normalmente conectados a sensores digitais e deste modo é possível controlar o número de pulsos no contador, e quando o valor desejado é alcançado a bobina ligada à saída é acionada. Contadores são retentivos e no caso de queda de energia o valor acumulado não será perdido.

Existem três tipos de contadores, os de contagem crescente (CTU), decrescente (CTD) e o crescente e decrescente (CTUD). Para usar um contador inicialmente é necessário definir uma tag do tipo COUNTER.

Os contadores crescentes (CTU, do inglês Count Up ou CTN,C,CTR) são representados pelo seguinte esquemático:

                CTU
            ╭┈┈┈┈┈┈┈┈┈┈┈╮                                                     
           ┈┃CU      Q  ┃┈┈
           ┈┃RESET      ┃
           ┈┃PV       CV┃┈┈ 
            ╰┈┈┈┈┈┈┈┈┈┈┈╯

Para o seu funcionamento, o sinal da entrada (associada com a variável CU, do tipo BOOL) deve variar de 0 a 1 fazendo com que o contador adicione um ao seu acumulador (CV, do tipo INT) até alcançar o seu valor limite (PV, do tipo INT) para tornar o valor da sua saída (Q, do tipo BOOL) verdadeira. Caso ocorrer o acionamento da variável do tipo BOOL- RESET, o valor do CV será resetado.

Exemplo de aplicação: contar o número de cerâmicas produzidas em uma olaria, ao atingir o valor limite a linha de produção é interrompida para a retirada do lote. Após é reiniciada a contagem.

Os contadores decrescentes (CTD, do inglês Count Down) são representados pelo seguinte esquemático:

                CTD
            ╭┈┈┈┈┈┈┈┈┈┈┈╮                                                     
           ┈┃CD      Q  ┃┈┈
           ┈┃LOAD       ┃
           ┈┃PV       CV┃┈┈ 
            ╰┈┈┈┈┈┈┈┈┈┈┈╯

O funcionamento do CTD é o contrário do CTU, o sinal da entrada (associada com a variável CD, do tipo BOOL) deve variar de 1 a 0 fazendo com que o contador decremente um ao seu acumulador (CV, do tipo INT) até alcançar o seu valor mínimo (PV, do tipo INT) para tornar o valor da sua saída (Q) verdadeira. Caso ocorrer o acionamento da variável –do tipo BOOL- LOAD, o valor do CV será resetado.

Exemplo de aplicação: um dispositivo de uma fábrica de doces capaz de trocar as embalagens de pacotes de balas é acionado quando o pacote que está sendo enchido, o qual comporta trinta unidades, estiver cheio.

Os contadores crescentes e decrescentes (CTUD, do inglês Count Up Down) são representados pelo esquemático:

                CTUD
            ╭┈┈┈┈┈┈┈┈┈┈┈╮                                                     
           ┈┃CU      QU ┃┈┈
           ┈┃CD      QD ┃┈┈    
           ┈┃RESET      ┃
           ┈┃LOAD       ┃
           ┈┃PV       CV┃┈┈ 
            ╰┈┈┈┈┈┈┈┈┈┈┈╯

O funcionamento do CTUD é a junção de ambos os contadores (CTU E CTD), no qual as variáveis do tipo BOOL QU e QD representam as saídas do contador crescente e do decrescente.

Exemplo de aplicação: cortar pedaços de madeira com determinados comprimentos.

Contadores em cascata: dependendo a aplicação se faz necessário contar eventos que excedem o máximo permitido pelo contador, sendo assim, é possível interconectar dois ou mais contadores usando em forma de cascata. A técnica consiste em acionar uma instrução de um contador a partir da saída de outro com instrução semelhante.

Exemplo de aplicação: monitoramento de hora usando três contadores, para representar horas, minutos e segundos. [7]

Bobinas SET/RESET

Representadas pela bobina padrão com uma letra S (Set) ou R (Reset), esse tipo de bobina armazena um estado (verdadeiro, se a bobina for SET e falso se a bobina for RESET) em uma variável booleana toda vez que uma borda de subida é identificada. O estado então será mantido mesmo com a desenergização da bobina, até que uma outra chamada futura altere seu valor. Esse tipo de bobina facilita a implementação de sistemas com memória.

Exemplos de Programação Ladder

A linguagem Ladder pode ser entendida como uma série de conexões de contatos e bobinas. O lado esquerdo do diagrama é energizado. Se um caminho puder ser traçado da esquerda para a direita e que conecte alguma bobina, então o valor dessa bobina será verdadeiro. Os contatos representam algum valor de entrada, enquanto o valor da “bobina” poderá ser revertido em uma saída física no CLP ou um bit que será usado em alguma outra parte do programa, utilizando-se o nome da bobina como contato.

 ------| |--------------------( )
      Chave                  Bobina

No diagrama acima, ao acionar a Chave, uma conexão é estabelecida entre o lado energizado e a Bobina, que portanto apresentará estado lógico verdadeiro. A maioria dos aparelhos apresentam algum tipo de lógica como esse para ligar e desligar. Note que é necessário que o botão/chave se mantenha pressionado para a bobina manter o estado lógico verdadeiro.

Portas Lógicas

Ver artigo principal: Porta Lógica

Os contatos e relés simples podem ser utilizados para construir portas lógicas, que servem para facilitar a resolução problemas devido ao fato de ser possível o uso de ferramentas para Álgebra Booleana como o Mapa de Karnaugh e Máquinas de Estados.

Porta Lógica AND

A porta lógica AND pode ser representada por dois contatos em série, já que os dois precisam estar ativos para a bobina ser ativada.

 ------| |--------------| |----------------( )
     Chave 1          Chave 2            Bobina

Porta lógica OR

A porta lógica OR pode ser representada por dois contatos em paralelo, já apenas um estando ativo permite a energização de toda a linha.

 --+-------| |-------+--------------------( )
   |     Chave 1     |                   Bobina
   |                 |
   +-------| |-------+
         Chave 2

Porta Inversora NOT

A porta inversora NOT pode ser representada por um contato ou uma bobina invertida (não ambos).

 ------|/|--------------------( )
      Chave                  Bobina

Porta XOR

Com o auxílio de outras portas lógicas, pode-se criar modelos mais complexos, como a porta XOR (OU exclusivo).

 ------|/|--------------| |--------+-------( )
     Chave 1          Chave 2      |     Bobina
                                   |
                                   |
 ------| |--------------|/|--------+
     Chave 1          Chave 2      

Contato de Selo (Trinco)

O contato de selo (ou trinco), também conhecido como Latch, está geralmente associado à botões de INICIAR e PARAR e possui a característica de se manter ativo mesmo quando a chave de início não está mais pressionada, sendo parado somente quando o botão PARAR (ou alguma outra interrupção) for pressionado.

Ao ativar a chave INICIAR, a Bobina é energizada, que por sua vez fecha a chave Bobina, que representa o estado da Bobina. Desse ponto em diante, o circuito só pode ser parado fechando a chave PARAR, que abre o circuito desenergizando a Bobina e voltando o estado lógico da chave Bobina para falso.

 ------| |---------+----|/|-------------( )
     INICIAR       |   PARAR          Bobina
                   |              
                   |              
 ------| |---------+
      Bobina              

Por medidas de segurança, é comum adicionar um contato de Parada de Emergência (P/E) que poderá ser ativada em alguma outra parte do programa.

 ------| |---------+----|/|------|/|-----( )
     INICIAR       |   PARAR     P/E    Bobina
                   |              
                   |              
 ------| |---------+
      Bobina              

Referências

  1.  All About Circuits. «”Ladder” Diagrams». Consultado em 17 de nov. de 2015
  2.  Rockwell Automation. «What is IEC 1131?». Consultado em 17 de nov. de 2015. Arquivado do original em 20 de novembro de 2015
  3.  Frank D. Petruzella (2014). Controladores Lógicos Programáveis. [S.l.]: AMGH. ISBN: 978850552829
  4.  Marcelo Georgini (2007). Descrição e Implementação de Sistemas Sequenciais com CLP. [S.l.]: Érica. ISBN: 9788571947245
  5.  W. Bolton (2006). Programmable Logic Controllers. [S.l.: s.n.] ISBN: 9780750681124
  6.  «Ladder Elements»http://www.unitronics.com. Consultado em 18 de novembro de 2015. Arquivado do original em 4 de março de 2016
  7.  INDUSTRIAL SYSTEMS. XGK/XGB Instructions and Programming. Disponível em: <http://htmmuh.com/Uploads/Dosyalar/506d4f4d-e026-4eba-aec6-b034d9280125.pdf#page=74>. Acesso em: 19 nov. 2016. PAREDE, Ismael Moura; GOMES, Luiz Eduardo Lemes. Contadores. Eletrônica: automação industrial. São Paulo: Fundação Padre Anchieta: 2011, p. 94-100. PETRUZELLA, Frank D. Programação de contadores. Controladores lógicos programáveis. 4. ed. Porto Alegre: AMGH: 2014, p. 347-351. SILVEIRA, Cristiano Bertulucci. A Função dos Contadores na Lógica LADDER. Disponível em: <https://www.citisystems.com.br/contadores-logica-ladder-clp/>. Acesso em: 19 nov. 2016.

Ligações externas

 

 

Fonte: https://pt.wikipedia.org/wiki/Linguagem_ladder

GERADOR DE TONS

gerador-de-tom

gerador-de-tom

 

Para que posso usar este gerador de tons?

Instrumentos de sintonia, experimentos científicos ( qual é a freqüência de ressonância deste copo de vinho? ), Teste de equipamento de áudio ( quão baixo o meu subwoofer vai? ), Testando sua audição ( qual a freqüência mais alta que você pode ouvir? Há freqüências que você pode ouvir em apenas uma ouvido? ).

Correspondência de frequência do zumbido. Se você tem zumbido de tom puro , esse gerador de frequência on-line pode ajudá-lo a determinar sua frequência. Conhecer a frequência do zumbido pode permitir que você direcione melhor os sons de mascaramento e o treinamento de discriminação de frequência . Quando você encontrar uma frequência que pareça corresponder ao seu zumbido, certifique-se de verificar as frequências uma oitava acima (frequência × 2) e uma oitava abaixo (frequência × ½), pois é fácil confundir tons separados por uma oitava.

Doença de Alzheimer. Há alguma evidência científica inicial de que ouvir um tom de 40 Hz pode reverter algumas das mudanças moleculares nos cérebros dos pacientes de Alzheimer. Essa é uma dessas coisas que parece boa demais para ser verdade, mas os primeiros resultados são muito promissores. Aqui está um resumo da pesquisa até agora e um relatório de um usuário que tentou terapia de 40 Hz em sua esposa. ( Observe que este gerador de tom não é um dispositivo médico – não garanto nada! )

https://www.szynalski.com/tone-generator/

COMO SE COMPORTA O GRAFENO

  Ao nano revestir o cobre, os impulsos elétricos não passam mais pela superfície do material e sim pelos tubos magnéticos que são criados dentro das nano camadas, pois oferecem menor ou nenhuma resistência. Em contraponto o exterior dessas camadas é um isolante perfeito, pois ao medir a condutividade com o auxílio do multímetro na superfície do cobre, nada é detectado.

 

 

 

 

 

 

 

 

 

 

 

Plataforma UiPath

A plataforma RPA possui três produtos principais:

  • UiPath Studio – uma ferramenta avançada que permite projetar processos de automação de maneira visual, através de diagramas.
  • UiPath Robot – executa os processos construídos no Studio, como um humano faria. Os robôs podem trabalhar sem supervisão (executar sem supervisão humana em qualquer ambiente, seja ele virtual ou não) ou como assistentes (um ser humano aciona o processo).
  • UiPath Orchestrator – um aplicativo da web que permite implantar, agendar, monitorar e gerenciar robôs e processos, enquanto o tratamento de exceções de negócios está disponível por meio de filas de trabalho centralizadas.

Neste tutorial, você aprenderá muitas informações básicas sobre os três aplicativos apresentados acima e as palavras-chave usadas com eles.

Tipos de fluxo de trabalho e atividades

Vários tipos de fluxos de trabalho estão disponíveis no Studio (sequências, fluxogramas e processos de negócios transacionais) que ajudam a criar seu fluxo de trabalho de automação de acordo com suas necessidades.

Para criar esses fluxos de trabalho, você precisa de atividades (ações que você usa para automatizar aplicativos, como clicar e digitar). Cerca de 300 dessas atividades existem e permitem que você interaja com navegadores da Web, aplicativos de área de trabalho, PDFs, imagens, bancos de dados, terminais, planilhas do Excel, contas de e-mail e muitos outros, além de criar facilmente solicitações HTTP e SOAP.

Funcionalidade do Gravador

A maneira mais fácil de criar fluxos de trabalho é usando o recurso de registro. Quatro tipos de gravações estão disponíveis: Basic , Desktop , Web e Citrix . Os dois primeiros podem ajudá-lo a automatizar os aplicativos de desktop, enquanto os outros permitem que você lide adequadamente com aplicativos da Web e ambientes virtuais.

Variáveis ​​e Funções .Net

Uma variável permite que você armazene um valor, mas apenas de um determinado tipo. Além destes, as funções Net também pode ser usado para melhorar a sua automação, como .trim que remove os espaços do início e final de uma string, ou .ToStringque transforma um certo tipo de variável em uma string.

Robôs e orquestrador

Os robôs, os executores do UiPath, podem interagir com uma grande quantidade de aplicativos ao mesmo tempo. Um exemplo é fornecido no vídeo.

O orquestrador, a peça final do quebra-cabeça, é usado para gerenciar vários robôs implantados. Esse tipo de ambiente geralmente é encontrado em grandes empresas, que precisam automatizar muitos processos de negócios. A primeira coisa que você precisa fazer neste aplicativo da Web é registrar seu (s) robô (s). Depois disso, você precisa agrupá-los em um ambiente.

Os fluxos de trabalho publicados nessa plataforma precisam estar vinculados a um ambiente e, a partir daí, você começa a executar: seja agora ou com base em um agendamento definido de maneira personalizada. 
Você pode executar um processo em um ou vários robôs, um número específico deles ou em todos os robôs agrupados em um ambiente.

Ativos e Filas

Como os robôs podem precisar compartilhar informações, um tipo especial de variáveis ​​é introduzido no orquestrador, ativos. Eles permitem que você armazene informações (incluindo credenciais) no banco de dados do aplicativo da Web, para que seja fácil alterar um valor que é usado em vários processos, e vários robôs podem ter acesso a ele.

O UiPath também faz uso de filas de trabalho para distribuir a carga de um processo transacional entre vários robôs. Eles podem ser programados para começar antes ou depois de uma determinada data, e informações detalhadas contidas em cada item da fila podem ser visualizadas.

Logs, Auditoria, Alertas e Outros 

Na guia Registros, você pode ver facilmente como os Robôs foram executados, quais tarefas foram concluídas ou se falharam. Além disso, todas as etapas realizadas pelo usuário podem ser auditadas e os alertas são enviados por e-mail para todos aqueles que possuem as permissões necessárias.

Finalmente, o gerenciamento de funções está disponível, juntamente com outros recursos interessantes, como a importação de usuários de um grupo do Active Directory, a divisão de processos de automação entre equipes por meio de vários inquilinos e a exibição de informações em gráficos precisos.

 

 

Fonte:  https://www.uipath.com/developers/video-tutorials/introduction-to-uipath

CENTRAL TELEFÔNICA CONECTA+

Os softwares programador e bilhetador são compatíveis com as versões de Windows 7, 8 e 10. Para a utilização desses softwares nas
centrais Conecta Mais e Modulare Mais é necessário que a versão de firmware da central seja igual ou superior a versão 2.0.0. Você pode
consultar a versão do firmware digitando o comando *1000 em qualquer ramal da central, de preferência com identificador de
chamadas. Para maiores informações consulte a seção 7.1 do manual do usuário disponível no site. Se a versão do sistema operacional e firmware da sua central atendem estes requisitos, realize o download do software programador e bilhetador clicando no link abaixo:

 

http://www.intelbras.com.br/sites/default/files/downloads/comunicado_programador_conecta_mais_e_modulare_mais.pdf

 

 

 

http://www.intelbras.com.br/empresarial/telefonia/pabx/analogica/conecta-mais

 

ABB lança software de otimização de ativos para suportar transformação digital

ABB lança software de otimização de ativos para suportar transformação digital

A ABB lançou seu pacote de soluções de software Ability Ellipse na DistribuTECH US, para ajudar os utilitários a maximizar o desempenho dos ativos e acelerar sua rota para a digitalização. 

ABB Ability Ellipse tem como objetivo oferecer uma abordagem entre empresas para gerenciamento de ciclo de vida de ativos conectado. O conjunto de software foi projetado para permitir que os utilitários de energia elétrica otimizem a utilização de ativos, reduzam os custos de manutenção e reduzam as falhas de equipamentos e as quedas do sistema. O número de novos ativos que entram na grade está explodindo – desde contadores inteligentes e switches, até fontes de energia distribuídas, como energia solar e eólica, para estações de carregamento de veículos elétricos.

A nova solução ABB Ability Ellipse oferece aos serviços públicos uma abordagem pró-ativa para manutenção preditiva que combina um sistema de gerenciamento de ativos com coleta e análise de dados de desempenho e uma solução de gerenciamento de força de trabalho para despachar equipes e manter ativos críticos. Especificamente, a solução unifica a funcionalidade das soluções da ABB para gerenciamento de ativos corporativos (EAM), WFM e Asset Performance Management (APM).

“Entendemos os desafios que as empresas de serviços elétricos enfrentam ao gerar maiores níveis de desempenho em uma rede cada vez mais complexa”, disse Massimo Danieli, diretor do negócio de Grid Automation da ABB na divisão Power Grids da empresa. “Com a ABB Ability Ellipse, os utilitários agora podem usar uma solução única e simplificada para gerenciamento, manutenção e monitoramento de ativos que permitem uma rede mais forte, mais inteligente e mais verde”.

Como o Gerenciamento de desempenho de ativos torna-se um ponto focal para transformar a grade moderna, é de vital importância que os serviços públicos gerenciem seus ativos e mão de obra com uma estratégia coesa.

Para informações adicionais:

ABB

Fonte:  https://www.renewableenergymagazine.com/energy_saving/abb-launches-asset-optimisation-software-to-support-20180124

Padrão de interface de software do microcontrolador Cortex

Padrão de interface de software do microcontrolador Cortex

O CMSIS permite um suporte de dispositivo consistente e interfaces de software simples para o processador e seus periféricos, simplificando a reutilização de software, reduzindo a curva de aprendizado para desenvolvedores de microcontroladores e reduzindo o tempo de mercado para novos dispositivos.


Visão geral

A partir do CMSIS-CORE, uma camada de abstração de hardware independente do fornecedor para os processadores Cortex-M, o CMSIS expandiu-se para áreas como o gerenciamento de componentes de software e as interfaces de depurador de referência. A criação de software é um fator de custo importante na indústria incorporada. A padronização das interfaces de software em todos os produtos do fornecedor de silício Cortex-M, especialmente ao criar novos projetos ou a migrar o software existente para um novo dispositivo, significa redução significativa de custos.

O CMSIS é definido em estreita cooperação com vários fornecedores de silício e software e fornece uma abordagem comum para a interface para periféricos, sistemas operacionais em tempo real e componentes de middleware. Isso simplifica a reutilização de software, reduzindo a curva de aprendizado para novos desenvolvedores de microcontroladores e reduzindo o tempo de colocação no mercado para dispositivos.


Componentes do CMSIS

CMSIS-CORE: inicialização consistente do sistema e acesso periférico

A inicialização do sistema, o acesso ao núcleo do processador e as definições periféricas são essenciais para cada aplicativo incorporado. O CMSIS-CORE padronizado é implementado para mais de 3900 dispositivos diferentes e facilita a introdução de um novo dispositivo ou migra software em microcontroladores.

CMSIS versão 5

O CMSIS é desenvolvido publicamente no GitHub. A última versão pode ser baixada aqui:

CMSIS-RTOS: Execução determinista de software em tempo real

Um conceito de super-loop só é adequado para aplicativos embutidos simples. Os microcontroladores Cortex-M são projetados para sistemas operacionais em tempo real que oferecem controle de recursos e tempo.

O CMSIS-RTOS é uma API que permite camadas de software consistentes com componentes de middleware e biblioteca. O CMSIS-RTOS RTX é executado em todos os dispositivos Cortex-M e é a implementação de referência comprovada que é fácil de aprender e usar.

CMSIS-DSP: implementação rápida de processamento de sinal digital

O desenvolvimento de um sistema de processamento de sinais digitais em tempo real (DSP) não é trivial, já que os algoritmos DSP dependem fortemente de operações matemáticas complexas que são mesmo críticos para o tempo.

A biblioteca CMSIS-DSP é uma rica coleção de funções DSP que o Arm optimizou para os vários núcleos de processadores Cortex-M. O CMSIS-DSP é amplamente utilizado na indústria e também permite a geração de código C otimizada a partir de várias ferramentas de terceiros.

CMSIS-Driver: interfaces periféricas genéricas para middleware e código de aplicativo

Interfacing microcontroller periféricos com middleware ou código genérico de aplicação pode ser um desafio, pois cada dispositivo é diferente. As interfaces CMSIS-Driver prontas para usar estão disponíveis para muitas famílias de microcontroladores e evitam a portabilidade do driver pesada e demorada.

CMSIS-Pack: acesso fácil a componentes de software reutilizáveis

Anteriormente, os módulos de software eram difíceis de integrar, pois os arquivos de origem e de cabeçalho tinham requisitos pouco claros, documentação inconsistente ou informações de licença perdidas.

Como o CMSIS-Pack define a estrutura de um pacote de software que contém componentes de software, esses problemas são abordados. Os componentes de software são facilmente selecionáveis ​​e todas as dependências de outros softwares são destacadas.

CMSIS-SVD: visão consistente para dispositivos e periféricos

Para cada microcontrolador suportado, os depuradores podem fornecer visualizações detalhadas aos periféricos do dispositivo que exibem o estado do registro atual.

Os arquivos CMSIS-SVD permitem essas visualizações e garantem que a exibição do depurador coincida com a implementação real dos periféricos do dispositivo.

CMSIS-DAP: conectividade para hardware de avaliação de baixo custo

Planos de desenvolvimento baratos estão disponíveis em muitos fornecedores de microcontroladores. Freqüentemente, uma unidade de depuração de baixo custo está incluída, mas interfaces diferentes precisam de uma configuração de ferramenta específica.

O CMSIS-DAP é uma interface padronizada para a Porta de Acesso de Depuração Cortex (DAP) e é usado por muitos kits de inicialização e é suportado por vários depuradores.

CMSIS-NN: kernels de rede neural eficiente

As soluções baseadas em rede neural estão se tornando cada vez mais populares para aplicações de aprendizado de máquinas incorporadas.

O CMSIS-NN é uma coleção de kernels de redes neurais eficientes desenvolvidos para maximizar o desempenho e minimizar a pegada de memória de redes neurais nos núcleos de processadores Cortex-M.

 

Fonte:  https://developer.arm.com/embedded/cmsis

https://developer.arm.com/products/system-design/development-boards

https://developer.arm.com/products/system-design/development-boards/logictile-express

https://community.arm.com/b/carlosdelfino/posts/facilitando-o-desenvolvimento-para-a-proxima-geracao-de-embarcados-inteligentes-e-conectados

Sistema de correção de postura sentada em tempo real com base em sensores de pressão têxteis eletrônicos altamente duráveis ​​e laváveis

 

Destaques

•  Foi desenvolvido um sistema de correção de postura assente em tempo real com base em sensores de pressão têxtil altamente duráveis ​​e laváveis.
• A condução de fibras de liga Ni-Ti revestidas com elastômero de poliuretano resultou em sensores de pressão têxtil altamente duráveis ​​e laváveis.
• Ao analisar a pressão detectada nas diferentes posições sob o quadril, coxa e costas, sete tipos de posturas de sessão foram classificadas com sucesso.
• A exibição em tempo real em um monitor de mudanças na postura sentada, que faz os usuários reconhecer e corrigir o equilíbrio corporal, foi simulada.

 

 

Abstract

Foi demonstrado um sistema de correção de postura sentada em tempo real com base em sensores de pressão têxtil altamente durável e laváveis. Os sensores de pressão têxtil consistiram na condução de fibras de liga de Ni-Ti com uma excelente resistência à fadiga e um elastômero de poliuretano sensível à pressão resultou em mudança de capacitância confiável por uma pressão aplicada em uma faixa de 10 a 180 kPa com uma sensibilidade de 2,39 kPa -1. O desempenho sensitivo foi mantido em 100%, mesmo após a repetida ação de sentar mais de 1000 vezes e a dura lavagem na solução detergente. Ao analisar a pressão detectada nas diferentes posições sob o quadril, coxa e costas, sete tipos de posturas sentadas, incluindo a sessão vertical, sentado com uma perna cruzada, e sentado com as duas pernas levantadas foram classificadas com sucesso. Finalmente, a exibição em tempo real em um monitor das mudanças na postura sentada foi simulada para permitir aos usuários reconhecer e corrigir o equilíbrio corporal.

Palavras-chave

  • Sensor de pressão têxtil lavável ;
  • Fibras de liga Ni-Ti revestidas com poliuretano;
  • Sensor do tipo capacitância ;
  • Correção de postura sentada

 

Fonte: https://www.sciencedirect.com/science/article/pii/S0924424717312815 

Edge Computing – A Nova Fronteira da Web

Aprenda os conceitos básicos da computação de borda e como ela está transformando a paisagem em tempo real

A beira

A “borda” refere-se à infra-estrutura de computação que existe perto das fontes de origem dos dados. É distribuída a arquitetura de TI e a infra-estrutura onde os dados são processados ​​na periferia da rede, o mais próximo possível da fonte.

Edge computing é um método de otimização de sistemas de computação em nuvem , executando o processamento de dados na borda da rede, perto da fonte dos dados.

OEA

Internet industrial das coisas (IIoT)

  • Turbinas eólicas
  • Scanner de ressonância magnética (MR)
  • Preventistas de explosão submarina
  • Controladores industriais, como sistemas SCADA
  • Máquinas industriais automatizadas
  • Tecnologia inteligente de rede elétrica
  • Iluminação pública

Internet das coisas (IoT)

  • Veículos a motor (Automóveis e caminhões)
  • Dispositivos móveis
  • Luzes de trânsito
  • Termostatos
  • Eletrodomésticos
TechTarget

                                                                                  TechTarget

Benefícios de computação de borda

A computação de borda permite o escopo claro de recursos de computação para processamento ótimo.

  1. Os dados sensíveis ao tempo podem ser processados ​​no ponto de origem por um processador localizado (um dispositivo que possui sua própria capacidade de computação).
  2. Os servidores intermediários podem ser usados ​​para processar dados em proximidade geográfica próxima da fonte (isso pressupõe que a latência intermediária está correta, embora as decisões em tempo real sejam feitas o mais próximo possível da origem).
  3. Servidores em nuvem podem ser usados ​​para processar menos dados sensíveis ao tempo ou para armazenar dados para o longo prazo. Com o IoT, você verá isso manifestado em painéis analíticos.
  4. Os serviços de aplicativos de borda diminuem significativamente os volumes de dados que devem ser movidos, o tráfego conseqüente ea distância que os dados devem percorrer, reduzindo assim os custos de transmissão, latência encolhida e melhorando a qualidade do serviço (QoS) ( fonte ).
  5. A computação de borda remove um grande estrangulamento e potencial ponto de falha ao enfatizar a dependência do ambiente de computação principal.
  6. A segurança melhora à medida que os dados criptografados são verificados por meio de firewalls protegidos e outros pontos de segurança, onde vírus, dados comprometidos e hackers ativos podem ser capturados no início ( fonte ).
  7. A borda aumenta a escalabilidade ao agrupar logicamente as capacidades da CPU, conforme necessário, economizando custos na transmissão de dados em tempo real.

Por que o Edge

Transmitir quantidades maciças de dados é caro e tributo em recursos de rede. A computação de borda permite que você processe dados perto da fonte e apenas envie dados relevantes pela rede para um processador de dados intermediário.

Por exemplo, um refrigerador inteligente não precisa enviar continuamente dados de temperatura interna de volta para um painel de análise da nuvem. Em vez disso, ele pode ser configurado para enviar apenas dados quando a temperatura mudou para além de um ponto particular; ou, pode ser consultado para enviar dados somente quando o painel de controle é carregado. Da mesma forma, uma câmera de segurança IoT só pode enviar dados para o seu dispositivo quando ele detecta movimento ou quando alterna explicitamente um feed de dados ao vivo.

Device Relationship Management (DRM)

Para gerenciar dispositivos de ponta, o gerenciamento de relacionamento com dispositivos (DRM) refere-se ao monitoramento e manutenção de equipamentos complexos, inteligentes e interconectados pela internet. O DRM é projetado especificamente para interagir com os microprocessadores e software local em dispositivos IoT.

O gerenciamento de relacionamento com dispositivos (DRM) é um software corporativo que permite o monitoramento, gerenciamento e manutenção de dispositivos inteligentes pela Internet.

– TechTarget

A névoa

Entre a borda ea nuvem está a camada de nevoeiro , que ajuda a unir as conexões entre dispositivos de borda e centros de dados da nuvem. De acordo com Matt Newton da Opto 22 :

A computação do nevoeiro empurra a inteligência para o nível de rede da área local da arquitetura da rede, processando dados em um nó de neblina ou gateway IoT.

A computação de borda empurra a inteligência, o poder de processamento e as capacidades de comunicação de um gateway de borda ou dispositivo diretamente em dispositivos como controladores de automação programáveis ​​(PACs).

Edge e Realtime

Sensores e dispositivos implantados remotamente exigem processamento em tempo real. Um sistema centralizado de nuvem geralmente é muito lento para isso, especialmente quando as decisões precisam ser feitas em microssegundos. Isto é especialmente verdadeiro para dispositivos IoT em regiões ou locais com pouca conectividade.

No entanto, às vezes, as capacidades em tempo real exigem o processamento da nuvem. Por exemplo, digamos que os dados consumidos por monitores de tempo de tornados remotos devem ser enviados em tempo real para supercomputadores maciços.

É aí que a infra-estrutura em tempo real entra em jogo para ajudar a habilitar essas transações de dados.

 

Fontehttps://hackernoon.com/edge-computing-a-beginners-guide-8976b6886481

Tatuagens eletrônicas de grafeno podem ser aplicadas à pele com água

 

Os pesquisadores criaram uma tatuagem à base de grafeno que pode ser laminada diretamente sobre a pele com água, semelhante a uma tatuagem temporária. Mas em vez de apresentar desenhos artísticos ou coloridos, a nova tatuagem é quase transparente. Sua principal atração é que as propriedades eletrônicas únicas do grafeno permitem que a tatuagem funcione como um dispositivo eletrônico portátil, com aplicações potenciais, incluindo usos biométricos (como medir a atividade elétrica do coração, cérebro e músculos), bem como interações homem-máquina .

Os pesquisadores, liderados por Deji Akinwande e Nanshu Lu na Universidade do Texas em Austin, publicaram um artigo sobre a nova  eletrônica de grafeno em uma edição recente da ACS Nano .

De certa forma, a tatuagem eletrônica de grafeno é semelhante aos dispositivos eletrônicos comercialmente disponíveis para rastreamento de saúde e fitness: ambos os tipos de dispositivos são capazes de monitorar a freqüência cardíaca e bioimpedância (uma medida da resposta do corpo a uma corrente elétrica). Mas porque as tatuagens de grafeno ultrafinas podem ser totalmente compatíveis com a  , elas oferecem qualidade de dados de qualidade médica, em contraste com o menor desempenho dos sensores de eletrodos rígidos montados em bandas e amarrados ao pulso ou ao peito. Devido à percepção de alta qualidade, os pesquisadores esperam que as tatuagens de grafeno possam oferecer substituições promissoras para sensores médicos existentes, que normalmente são gravados na pele e requerem gel ou pasta para permitir que os eletrodos funcionem.

“A tatuagem de grafeno é um sensor fisiológico seco que, devido à sua magreza, forma um contato ultra-conformal para a pele, resultando em maior fidelidade de sinal”, disse o co-autor Shideh Kabiri Ameri na Universidade do Texas em Austin. “A conformidade resulta em menos susceptibilidade aos artefatos de movimento, que é uma das maiores desvantagens dos sensores e eletrodos secos convencionais para medições fisiológicas”.

As novas tatuagens são feitas de grafeno que é revestido com uma camada de suporte ultrafinas de polímero transparente poli (metacrilato de metilo) (PMMA). Durante a fabricação, a bicamada de grafeno / PMMA é transferida para um pedaço de papel de tatuagem comum, e a bicamada é então esculpida em diferentes padrões de fitas serpentinas para fazer diferentes tipos de sensores. A tatuagem acabada é então transferida para qualquer parte do corpo, trazendo o lado do grafeno em contato com a pele e aplicando água na parte de trás do papel da tatuagem para liberar a tatuagem. As tatuagens mantêm sua função completa por cerca de dois dias ou mais, mas podem ser removidas por um pedaço de fita adesiva se desejado.

Uma vez que os pesquisadores mostraram anteriormente que, teoricamente, uma tatuagem de grafeno deve ter menos de 510 nm de espessura para se adequar totalmente à pele humana e exibir um desempenho ótimo, a tatuagem que fabricou aqui é de apenas 460 nm de espessura. Combinado com a transparência óptica bicamada de grafeno / PMMA de aproximadamente 85% e o fato de que as tatuagens são mais esticáveis ​​do que a pele humana, as tatuagens de grafeno resultantes são praticamente perceptíveis, tanto mecânicas como opticamente.

Os testes mostraram que as tatuagens eletrônicas de grafeno podem ser usadas com sucesso para medir uma variedade de sinais eletrofisiológicos, incluindo temperatura da pele e hidratação da pele, e podem funcionar como eletrocardiograma (ECG), eletromiograma (EMG) e eletroencefalograma (EEG) para medir o elétron atividade do coração, músculos e cérebro, respectivamente.

“As tatuagens eletrônicas Graphene são mais promissoras para aplicações potenciais em saúde móvel, tecnologias assistidas e  “, disse Kabiri Ameri. “Na área de interfaces de máquinas humanas, os sinais eletrofisiológicos registrados no cérebro e nos músculos podem ser classificados e atribuídos para ação específica em uma máquina. Esta área de pesquisa pode ter aplicações para a internet de coisas, casas inteligentes e cidades, interação humana com computadores , cadeiras de rodas inteligentes, tecnologia de assistência de fala, monitoramento de condução distraída e controle de humano-robô. Recentemente, demonstramos a aplicação de tatuagens para detectar sinais humanos para controle sem fio de objetos voadores. Essa demonstração será relatada no futuro próximo “.

Read more at: https://phys.org/news/2017-08-graphene-electronic-tattoos-skin.html#jCp

Aquecimento por indução – Induction Heater – Monte um!

Aquecimento por indução – Induction Heater. Apresentação do efeito, funcionamento e circuito para montar um aquecedor por indução! Veja aqui a versão 2.0 desse circuito: https://www.youtube.com/watch?v=wqp0C…

Inscreva-se no canal aqui: https://www.youtube.com/c/electrolab-…

Seja um apoiador do Electrolab na página no apoia-se! https://apoia.se/electrolab

Seja um patrono do Electrolab:

Página do Electrolab no Patreon: https://www.patreon.com/electrolab?ty=h

 

Lista de Material do projeto:

02 MOSFETs canal N IRF540, 640, etc
02 Diodos 1N5819
Choque de RF (12 espiras – entre 40 e 100uH)
Resistor 220R x 1W
01 LM7812
Cap – 470nF a 1uF – 1600V MKP
Indutor 10 espiras com CT – Fio 4mm, com 2cm de diâmetro

 

Treinamentos recomendados pelo Electrolab:

Curso de reparos de Celular: http://bit.ly/2oUM0fa

Guia para reparo de Celular: http://bit.ly/2okqSM3

Curso de reparo de Eletrodomésticos e eletrônica básica: http://bit.ly/2oINxEs

Guia de reparo em placa mãe (PC): http://bit.ly/2okoSDB

Curso de reparo de Notebook: http://bit.ly/2oIDOhE e http://bit.ly/2oJr36m

Curso de instalador de sistema de energia solar: http://bit.ly/2oQWrxB

Curso de Inglês do zero: http://bit.ly/2oZaJgm

Curso técnico de CFTV (Câmeras de segurança): http://bit.ly/2qmBw9B

Arduino Based Home Automation Usando TV Remote

A Arduino Based Home Automation usando TV Remote é um projeto simples, onde um controle remoto de TV antigo é usado para controlar diferentes aparelhos.

Home Automation é um conceito em que um único dispositivo é usado para controlar muitos aspectos de uma casa, como ligar ou desligar aparelhos diferentes, monitoramento de temperatura, alarmes de incêndio, portas de garagem etc. Neste projeto, um controle remoto é usado para controlar (simplesmente ON e OFF) vários aparelhos ou dispositivos, conseguindo assim um sistema de automação residencial simples.

Os controles remotos são um dos dispositivos comumente encontrados em quase todas as casas. Eles nos ajudam a operar um aparelho como TV, Ar-condicionado, VCR, etc. A principal característica de um controle remoto é que ele é específico para um dispositivo. Por exemplo, uma unidade de controle remoto de TV só pode ser usada para essa TV correspondente.

Mas neste projeto, nós criamos uma automação doméstica baseada em Arduino usando TV Remote, onde um único controle remoto é usado para controlar 4 dispositivos diferentes (possível controlar mais dispositivos). O projeto é baseado no Arduino UNO e mais detalhes do projeto são mencionados abaixo.

Diagrama de circuito

Componentes necessários

  • Arduino UNO board
  • TSOP 1738 IR Remote Control Receiver
  • 1 KΩ Resistor X 4
  • 2N2222 NPN Transistor X 4
  • 1N4007 Diodo X 4
  • 12 V Relé X 4
  • Controle remoto
  • Placa de prototipagem (Painel de pão)
  • Fios de conexão
  • 12 V Fonte de alimentação

Descrição do Componente

Arduino UNO

Arduino UNO forma a principal parte controladora do circuito. A UNO tem 13 pinos de E / S digitais e, portanto, é possível controlar 13 dispositivos diferentes ao mesmo tempo. Se o requisito é controlar mais número de dispositivos, placas como Arduino Mega podem ser usadas.

TSOP1738

TSOP1738 é um módulo receptor para controles remotos IR com uma freqüência portadora de 38 KHz. Consiste em um detector de foto e demodulador de sinal em uma única embalagem e a saída pode ser usada diretamente por um microcontrolador.

Placa de relé de 4 canais

Um relé ajuda a controlar um aparelho grande com a ajuda de um microcontrolador. Neste projeto, uma placa de relé de 4 canais é usada para controlar quatro cargas.

Os componentes necessários, como o LED de alimentação, o transistor de comutação, o resistor de limitação de corrente de base, o relé no LED, o diodo flyback e os cabeçalhos macho para conexões de alimentação e entrada já estão incorporados na placa.

 

Cuidado : devemos ter muito cuidado ao usar um relé com alimentação de rede CA.

Controle remoto

Um mini controle remoto padrão é usado neste projeto para fornecer as várias entradas de chave. O controle remoto possui todas as teclas numéricas, volume para cima, baixo, canal para baixo, menu e algumas teclas adicionais.

 

Como projetar a automação residencial baseada em Arduino usando o circuito remoto da TV?

A partir do diagrama de circuito, é claro que o design do circuito é muito simples e requer muita conexão. O design do circuito é explicado abaixo.

O componente principal do projeto é o receptor TSOP1738. É um dispositivo de três pinos, onde os três pinos são GND, VS e OUTPUT. O pino VS está conectado à fonte de 5V. O pino de saída está conectado ao Pino 11 (ou a qualquer outro pino digital) do Arduino UNO.

Estamos usando um módulo de retransmissão de 4 canais neste projeto para controlar 4 cargas diferentes. Uma vez que a placa possui todos os componentes necessários, como transistores, LEDs, etc., tudo o que precisamos fazer é conectar as 4 entradas na placa de relé a 4 pinos de E / S digitais da Arduino. Uma conexão mais detalhada pode ser encontrada no diagrama de circuito.

Trabalho da Arduino baseado em automação residencial usando TV Remote

A automação residencial é um conceito de demanda onde um único dispositivo controlará diferentes aparelhos de uma casa. Além disso, diferentes aspectos como temperatura, umidade, segurança etc. também podem ser monitorados usando esse dispositivo.

Neste projeto, um sistema de automação residencial simples, no qual o sistema controla 4 aparelhos diferentes com a ajuda de um controle remoto de TV. O trabalho do projeto é explicado aqui.

O principal componente do projeto é TSOP1738 IR Receiver Module. Este módulo possui um receptor de foto incorporado, filtro de passagem de banda e desmodulador e a saída do módulo pode ser prontamente lida por um microcontrolador.

TSOP1738 suporta uma freqüência portadora de 38 KHz. Assim, a freqüência portadora da fonte, ou seja, o controle remoto deve estar na faixa de 38 KHz para que ele se desmodule.

Primeiro, descodificaremos os dados do controle remoto usando TSOP1738 e Arduino UNO. Para isso, precisamos usar uma biblioteca especial chamada “IRremote”. Precisamos baixar esta biblioteca em https://github.com/z3t0/Arduino-IRremote e colocá-la na pasta bibliotecas do Arduino.

O próximo passo é decodificar os dados de cada tecla do controle remoto. Para isso, vamos usar algumas funções na biblioteca “IRremote”. O programa a seguir nos ajudará a decodificar os dados de cada chave do controle remoto. NOTA: O seguinte programa é um esboço de exemplo da biblioteca “IRremote”.

#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup() {
Serial.begin(9600);
irrecv.enableIRIn();
}
void loop() {
if (irrecv.decode(&results)) {
Serial.println(results.value, HEX);
irrecv.resume();
}
delay(100);
}

https://gist.githubusercontent.com/elktros/59298a69a71bb16cac9c879d08677e9b/raw/9513ce93ca53c42f0b31d98b260c3d0123f0c3f3/Arduino%20based%20Home%20Automation%20using%20TV%20Remote%20

Quando este esboço é executado no Arduino, podemos monitorar os dados no terminal serial para cada tecla pressionada no controle remoto. A seguinte imagem mostra os valores de HEX descodificados das teclas 1 a 9, 0 e a tecla de energia, respectivamente.

 

Quando este esboço é executado no Arduino, podemos monitorar os dados no terminal serial para cada tecla pressionada no controle remoto. A seguinte imagem mostra os valores de HEX descodificados das teclas 1 a 9, 0 e a tecla de energia, respectivamente.

 

#include <IRremote.h>
const int RECV_PIN=11;
IRrecv irrecv(RECV_PIN);
decode_results results;
#define IN1 3
#define IN2 4
#define IN3 5
#define IN4 6
bool i=false;
bool j=false;
bool k=false;
bool l=false;
bool m=false;
void setup()
{
Serial.begin(9600);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
irrecv.enableIRIn();
irrecv.blink13(true);

}
void loop()
{
if (irrecv.decode(&results))
{
Serial.println(results.value,HEX);
delay(100);
/////////////////////////
if(results.value==0x40BD00FF)
{
i=!i;
digitalWrite(IN1, i);

}
////////////////////////
if(results.value==0x40BD807F)
{
j=!j;
digitalWrite(IN2, j);

// delay(200);
}
if(results.value==0x40BD40BF)
{
k=!k;
digitalWrite(IN3, k);

// delay(200);
}
//////////////////////////////
if(results.value==0x40BDC03F)
{
l=!l;
digitalWrite(IN4, l);

// delay(200);
}
//////////////////////
if(results.value==0x40BD28D7)
{
m=!m;
digitalWrite(IN1, m);
digitalWrite(IN2, m);
digitalWrite(IN3, m);
digitalWrite(IN4, m);

// delay(200);
}
irrecv.resume(); // Receive the next value
//delay(100);
}
}

 

Aplicação

  • Um projeto simples, onde uma automação residencial baseada em Arduino usando TV Remote é projetada aqui, que usa o Arduino UNO, o Relay e o antigo Remote TV.
  • O projeto é demonstrado com 4 cargas, mas pode ser aumentado para ainda mais cargas.
  • Como o dispositivo de controle é um controle remoto de TV, o projeto do projeto é muito simples e a aplicação também é muito fácil.

Vídeo de construção e saída

 

Link: http://www.electronicshub.org/arduino-based-home-automation-using-tv-remote/

Firewall para sua rede doméstica com Raspberry Pi

Embora o Raspberry Pi 3 tenha sido anunciado recentemente , o Raspberry Pi 2 ainda tem muita vida e é mais do que adequado para muitas tarefas interessantes e úteis.

Eu tenho algumas poucas framboesas sentadas ao redor que eu tenho explorado para outros projetos interessantes, um dos quais é a possibilidade de substituir um servidor de rack Intel de núcleo único de 64 bits muito antigo que eu uso para o firewall primário e o roteador no borda da minha rede. Mas antes de interromper o firewall principal e o gateway da minha rede, queria testar o Pi um pouco e ver exatamente o que seria necessário para que isso acontecesse.

 

Substituindo uma torre

 

 

Eu também tenho uma torre Intel de núcleo duplo que uso como firewall e porta lateral para minha rede. Este computador é um exagero extremo para essa tarefa, e eu definitivamente posso usá-lo em um papel mais apropriado. Como este computador fornece acesso não crítico à minha rede, decidi substituí-lo por um Raspberry Pi 2 Model B como teste.

 

Fonte de energia

Eu usei o Raspberry Pi 2 Model B, mas um Raspberry Pi 3 também deveria funcionar. Eu instalei o Pi a partir de um bloco de energia USB de 5V 1.8 A de reposição em um cabo de extensão doméstico padrão que liguei um no-break para fornecer energia consistente. Eu usei um cabo USB muito pequeno para micro-USB do bloco de energia para o conector de alimentação no Pi.

Interruptor KVM

Eu tenho vários dos meus hosts de infraestrutura conectados a um switch KVM de 16 portas com entradas VGA e PS / 2. Eu queria usar o KVM para o Pi também. Liguei a entrada do teclado e do mouse do KVM ao Pi com um cabo adaptador USB / PS / 2. A extremidade USB se conecta ao Pi e aos conectores do plugue do cabo do comutador KVM nos conectores PS / 2 do adaptador. Eu encontrei no passado que algumas marcas do adaptador USB para PS / 2 não funcionam bem.

Para a conexão de vídeo, inicialmente usei um adaptador HDMI para VGA que é uma unidade única e sólida. Este dispositivo produziu muito calor, grande parte do qual foi transmitida para o Pi através do conector HDMI. Posteriormente, substituí a unidade única por um adaptador que tenha um curto comprimento de cabo entre o conector HDMI e o conversor VGA, além de uma unidade de conector que produz e transmite significativamente menos calor.

Instalando o CentOS

Eu uso o CentOS em meus outros servidores de infra-estrutura, então eu queria usá-lo no Pi também. Usando minha principal estação de trabalho Linux, baixei a distribuição ARM de 32 bits do CentOS Userland 7 para o Pi 2 do site do Wiki CentOS , que também contém imagens para outros computadores de placa pequena. Se você estiver usando o Raspberry Pi 3, você deve usar essa imagem em vez disso.

Observe que o nome da imagem pode mudar à medida que as imagens mais recentes são disponibilizadas. Você sempre deve usar a imagem mais recente. Descompusei o arquivo de imagem xz baixado (usando unxz) e usei o comando dd para instalar a imagem em um cartão microSD de 8GB.

dd if=CentOS-Userland-7-armv7hl-Minimal-1511-RaspberryPi2.img of=/dev/sdx

Certifique-se de especificar a localização correta da unidade microSD na sua máquina.

Não são necessárias etapas adicionais para que o cartão microSD seja inicializável. Eu inseri o cartão no slot do cartão microSD na placa Pi. Em seguida, liguei o conector micro-USB da fonte de alimentação ao conector de alimentação no Pi para inicializar até um prompt de login da interface de linha de comando.

Configuração inicial

Entrei como root usando a senha padrão de “centos” (sem as aspas) e alterei imediatamente a senha de root. Eu mudei o nome do host no / etc / hostname e segui as instruções em / root / README para expandir a partição raiz para preencher todo o espaço disponível no cartão microSD. Isso incluiu uma reinicialização.

Neste ponto, eu liguei o adaptador de rede de bordo à minha rede interna, então eu poderia instalar mais software e testar a funcionalidade da rede. Eu instalei vários utilitários que eu acho úteis, incluindo quais, tela, vim, rwhois, mlocate, Midnight Commander (mc), mailx, bind-utils, chrony e wget.

Alguns outros favoritos meus, como no topo e no htop, ainda não estão disponíveis no repositório do CentOS. Eu não instalei estes todos de uma só vez porque não sabia quais estavam faltando. Em vez disso, tive que enfrentar o problema de que uma ferramenta necessária não estava instalada e, em seguida, instalá-la à medida que progredi através das outras etapas desse processo. Felizmente, esta lista tornará as coisas um pouco mais fáceis para você. Claro, você pode usar algumas ferramentas que eu não faço, e eles também podem estar perdendo.

Eu uso chaves SSH para logins da minha rede, então copiei a chave pública SSH da minha estação de trabalho interna primária para o Pi usando ssh-copy-id .

Uma segunda interface de rede

Como este Pi deve ser usado como um firewall, eu precisava de outro adaptador de rede. Depois de tomar o eth0 down, adicionei um dumper ASIX AX88178 USB Gigabit Ethernet. Desconectei minha rede interna do adaptador de rede on-board e liguei-a ao dongle. Eu configurei o dongle como eth1 com um endereço estático na minha rede interna e configurei a Ethernet a bordo com um endereço externo estático e o conectei ao roteador do meu ISP. Certifique-se de usar a linha HWADDR = nos arquivos de configuração da interface para definir o endereço MAC ao qual o arquivo de configuração pertence. Eu também adicionei o endereço IP do gateway e pelo menos dois servidores de nomes para o arquivo de configuração da interface para o adaptador interno.

Eu trouxe ambos os adaptadores de rede e usou ifconfig e alguns comandos de ping para verificar se os adaptadores de rede estavam vinculados aos endereços IP corretos e funcionavam corretamente. Agora eu poderia entrar no Pi de uma sessão de terminal na minha estação de trabalho principal e continuar trabalhando a partir daí.

Atualizações e mais configuração

Agora era hora de instalar todas as atualizações e reiniciar – o que eu fiz. Eu acho interessante que ambas as versões atuais do CentOS para ARM usem coisas como firewalld e systemd, mas ainda usam yum em vez de dnf para gerenciamento de pacotes de alto nível.

Eu tenho alguns alias e comandos de inicialização que eu sempre adiciono ao meu ambiente quando eu instalar um novo host. Esses comandos podem ser adicionados ao / etc / bashrc , ou melhor ainda, como um arquivo separado, /etc/profile.d/mybash.sh . Qualquer arquivo em /etc/profile.d com uma extensão de nome de arquivo .sh é obtido por / etc / bashrc durante o login.

Data e hora

Esta versão do CentOS não possui nenhum tipo de sincronização de tempo instalada por padrão, então eu instalei chrony e configurei chrony.conf com o meu servidor de tempo local NTP. Eu comecei a cronograma e configure systemctl para iniciar o chronyd no arranque. Eu também configurei o link simétrico / etc / localtime para apontar para o arquivo de dados do fuso horário desejado.

Firewall

O novo  firewalld  é realmente exagerado para o meu ambiente, então instalei iptables-services e iptables-utils. Eu configurei um  arquivo padrão  / etc / sysconfig / iptables , então, depois de desativar a conexão de rede externa, parei firewalld e configure systemd para não iniciá-lo no arranque. Comecei o iptables e configure o systemd para iniciá-lo no arranque. Em seguida, eu trouxe a conexão de rede externa de volta.

Viola!

Uma vez que você alcança este ponto, o Pi é totalmente funcional como um firewall e porta lateral.

Seria fácil dar mais duas etapas e torná-lo num roteador. Primeiro, defina o conteúdo do arquivo / proc / sys / net / ipv4 / ip_forward para “1” e, em seguida, adicione ou defina a seguinte linha em /etc/sysctl.conf para “net.ipv4.ip_forward = 1” , o que torna seu computador um roteador. Em seguida, adicione linhas apropriadas para NATing de origem e encaminhamento para o firewall iptables.

Acabei de receber três novos computadores Raspberry Pi 3 ontem. Eu já tenho uma configuração com a imagem CentOS-Userland-7-armv7hl-Minimal-1602-RaspberryPi3.img e terminarei configurando-a nos próximos dias para me tornar meu principal firewall e roteador.

 

Regras IPTables

Uma pessoa perguntou nos comentários para ver as regras IPTables que eu usei para este projeto, e eu suspeito que outros também estão interessados, então aqui estão eles. É um conjunto mínimo bastante padrão que só permite entrada SSH.

 

# Gerado por iptables-save v1.4.16.2 on Thu Feb 21 14:51:28 2013 *filtro : INPUT ACCEPT [0: 0] : AVANÇAR ACEITAR [0: 0] : OUTPUT ACCEPT [0: 0] -A INPUT -m conntrack --ctstate RELACIONADO, ESTABELECIDO -j ACEITAR -A INPUT -p icmp -j ACEITAR -A INPUT -i lo -j ACEITE -A INPUT -i eth0 -j ACEITAR -A INPUT -p tcp -m conntrack --ctstate NOVO -m tcp --portado 22 -j ACEITAR -A INPUT -j REJECT --reject-with icmp-host-proibido -A FORWARD -j REJECT - rejeitar-com icmp-host-proibido COMMIT # Completado em Thu Feb 21 14:51:28 2013

Fonte:  https://opensource.com/life/16/3/firewall-your-home-network-raspberry-pi?utm_medium=Email&utm_campaign=weekly&sc_cid=701f2000000h39XAAQ

Jetson TX2 – Plaquinha da Nvidia voltada para inteligência artificial

Não é um drone, um robô pequeno ou uma câmera com reconhecimento facial. Mas pode ser: a Nvidia está lançando o Jetson TX2, um computadorzinho que lembra o Raspberry Pi, mas que oferece o grande diferencial de ser focado em inteligência artificial. O dispositivo pode ser empregado em diversos tipos de projetos que precisam de alguma sofisticação, portanto.

Para tanto, o Nvidia Jetson TX2 sai de fábrica uma combinação bastante respeitável de recursos que, por sinal, representa uma grande evolução em relação ao Jetson TX1 (anunciado no final de 2015): processador de 64 bits com dois núcleos Cortex-A57 e outros dois Nvidia Denver 2, GPU de 1,3 GHz com arquitetura Pascal de 256 núcleos, 8 GB de RAM e 32 GB para armazenamento interno.

No aspecto da conectividade, o dispositivo vem com Wi-Fi 802.11ac e Bluetooth 4.1, além de suportar portas USB 2.0, USB 3.0, HDMI 2.0, Gigabit Ethernet, entre outros padrões.

Segundo a Nvidia, o Jetson TX2 tem praticamente o dobro da potência do Jetson TX1. E isso tudo vem acompanhado de mais eficiência no consumo de energia: são 7,5 W contra 10 W da geração anterior.

Com tamanho poder de fogo, essa plaquinha de 50 x 87 mm pode ser empregada em projetos de automação industrial, câmeras inteligentes, drones para filmagens profissionais, sistemas de monitoramento auxiliados por sensores e por aí vai. A Nvidia destaca que o Jetson TX2 consegue, por exemplo, decodificar imagens de duas câmeras trabalhando com 4K e 60 frames por segundo.

Na apresentação do produto, a Nvidia ressaltou que o Jetson TX2 pode atingir a taxa de 1,5 teraflop. De modo geral, a ideia é permitir que o equipamento baseado na placa execute tarefas de inteligência artificial, redes neurais, reconhecimento de voz e afins in loco, ou seja, sem depender exclusivamente de servidores externos ou serviços nas nuvens.

Não é por acaso que a Nvidia também anunciou o JetPack 3.0, um SDK para desenvolvimento de aplicações de inteligência artificial que traz suporte aos drivers gráficos mais recentes e a APIs para redes neurais, como TensorRT 1.0 e cuDNN 5.1.

É lógico que tudo isso faz o Jetson TX2 ser bem mais caro que outras plaquinhas que encontramos por aí: o kit do dispositivo entrou em pré-venda nos Estados Unidos pelo preço de US$ 599. As entregas começam neste mês.

Sistemas Operacionais de Tempo Real – Timers

Introdução

Estava desenvolvendo algumas idéias para um novo artigo técnico, quando encontrei perdida, no fundo de uma gaveta virtual, uma biblioteca de rotinas em C que desenvolvi há algum tempo. É uma preciosidade!!! Eu mesmo já utilizei essas funções em vários projetos. Estou aqui disponibilizando esse material para você.

Vou contar um pouco a história dessa biblioteca. Houve uma época em que o meu trabalho era focado em projetos de desenvolvimento de sistemas dedicados baseados em processadores da família 8051. Desenvolvemos uma célula de carga digital, um sistema de monitoramento ambiental, um mini CLP, um sistema de monitoramento e controle de um processo químico, sistema de controle de elevadores etc. Daí surgiu a ideia de elaborar funções e rotinas padronizadas, pois quase todos esses sistemas tinham alguma coisa em comum, como por exemplo teclas, displays etc. e deveriam operar em tempo real. O objetivo foi diminuir o tempo gasto para o desenvolvimento de um novo projeto. Antes de prosseguir, recomendo a leitura do artigo Sistemas Operacionais de Tempo Real – Introdução, onde são abordados alguns conceitos que serão aplicados neste artigo.

É necessário apresentar aqui alguns esclarecimentos a respeito da filosofia usada na elaboração dessas rotinas. Eu parti do princípio de que os nossos sistemas são de tempo real e que realizam periodicamente algumas funções rotineiras, tais como verificar um teclado, atualizar displays, administrar LEDs de sinalização, realizar medidas, etc. Outras ações são tomadas por demanda, ou seja, apenas quando ocorrem. Essas demandas podem ser periódicas ou assíncronas (aleatórias). Daí já reconhecemos o primeiro elemento a ser implementado no nosso Sistema Operacional: um temporizador (Timer). Para quem não sabe, os processadores tradicionais da família 8051 têm apenas 2 temporizadores, enquanto outras versões oferecem pelo menos mais um. Antes de continuar, acho interessante recordarmos a arquitetura dos microcontroladores da família MCS-51 e os modos de operação dos seus temporizadores. Na parte final desse artigo será desenvolvido um pequeno exemplo prático, cujo código poderá ser compilado e simulado.

TIMERS da família MCS-51

Para ilustrar o que será abordado aqui, vamos nos referenciar aos microcontroladores de fabricação da ATMEL, com a arquitetura baseada no 8051, cujo documento completo você pode consultar aqui: ATMEL 8051 Microcontrollers Hardware Manual. Na Figura 1 podemos observar a arquitetura interna de um microcontrolador AT89S8253, que continua sendo produzido, mostrando em destaque o bloco dos temporizadores.

Timers - Diagrama em blocos da arquitetura interna de um microcontrolador
Figura 1: Diagrama em blocos da arquitetura interna de um microcontrolador AT89S8253

 

Sem entrar nos detalhes referentes aos contadores / temporizadores Timer 0 e Timer 1 dessa família de microcontroladores, basta dizer que eles podem ser programados para funcionarem em 4 modos distintos de operação:

  • Modo 0: O temporizador é configurado como um contador de 13 bits, que pode receber um valor inicial e conta para cima. Na transição do valor limite superior 0x1FFF para  0x0000, é acionado um flag de sinalização;
  • Modo 1: Similar ao modo 0, porém é configurado o contador para 16 bits;
  • Modo 2: O temporizador é configurado como um contador de 8 bits, com um registro de 8 bits associado para recarregar o valor inicial automaticamente. Na transição, é acionado um flag;
  • Modo 3: Nesse modo de operação, o Timer 0 opera como 2 contadores distintos de 8 bits, enquanto o Timer 1 nesse modo de operação permite que se congele a contagem.

Convenções para o uso dos Timers

Para o objetivo de projetar uma biblioteca com rotinas padronizadas, foi definido que o Timer 0 seria o temporizador padrão do sistema e o Timer 1 também poderia ser usado para isso, se acaso não fosse necessário usá-lo para gerar baud-rate da comunicação serial.

O período de interrupção do temporizador deve ser o maior possível e baixo o suficiente para atender às necessidades prioritárias do sistema. Para que se entenda o motivo disso, observe o seguinte exemplo:

Suponhamos que:

  • Um microcontrolador que, por restrições de sua arquitetura e do oscilador (clock) utilizado, possa executar no máximo 10.000 instruções por segundo;
  • Uma rotina de interrupção provocada pelo temporizador execute 20 instruções na média a cada interrupção.

Se numa hipótese absurda o temporizador for dimensionado para gerar 500 interrupções por segundo, a rotina de interrupção vai consumir todo o tempo disponível para executar as instruções do microcontrolador (500 x 20 = 10.000)! Se por exemplo esse número puder cair para 50 interrupções por segundo, sem prejudicar a operação do sistema, a rotina de interrupção vai consumir apenas 10% do total disponível (1.000), deixando os outros 90% para as demais atividades do microprocessador.

A compreensão do que foi ilustrado nesse exemplo é fundamental. As rotinas que são executadas com maior frequência devem ser otimizadas para serem executadas no menor tempo possível e na menor frequência possível também. Voltando ao exemplo das 500 interrupções, se acaso a rotina de interrupção executasse apenas 18 instruções ao invés das 20, já sobrariam 1.000 instruções por segundo que poderiam ser executadas por outras atividades. Em muitos casos isso é suficiente. Note que para esse exemplo em particular, só analisamos uma das soluções possíveis para viabilizar a operação do sistema. Poderia-se também lançar mão de outros recursos, como por exemplo aumentar a frequência do oscilador do microcontrolador.

Assim a frequência da interrupção do nosso timer deve ser dimensionada de modo que:

  • A função que deverá ser executada com maior frequência possa ser atendida pelas interrupções do timer no menor tempo necessário para isso (e maior possível), definindo assim as especificações do timer de referência do sistema;
  • Outras temporizações mais lentas sejam realizadas como múltiplos da interrupção do timer e implementadas por meio de temporizadores virtuais de software.

Um temporizador virtual de software é uma estrutura no programa em que a cada temporizador é associado um valor inicial, que se traduz num número inteiro de interrupções do Timer 0, e um flag de sinalização. A cada interrupção do Timer 0, o temporizador de software é decrementado e testado se zero. Se for zero, é ligado o flag para avisar que a contagem de software foi terminada e o temporizador é reinicializado para o seu valor inicial. O tratamento do final de contagem é realizado no programa principal, testando-se o flag e reinicializando-o depois.

O timer de referência deverá funcionar no modo 2 de operação. Observe que a programação do Timer 0 depende da frequência de clock do microcontrolador, do fator de divisão do clock, que nas CPUs tradicionais do MCS-51 é de 12 vezes, e da frequência requerida de interrupção. Um último limitante é que o valor inicial do Timer nessa configuração é de no máximo 255 (8 bits). Na biblioteca também foi desenvolvido um padrão para a programação do Timer 1, especialmente se não for usado para gerar baud-rate.

Detalhes da Biblioteca em C

O código em C a seguir foi desenvolvido para o compilador KEIL C51 μVision, na versão de avaliação. Se você quiser testar o programa exemplo que desenvolveremos no final deste artigo, recomendo que você baixe e instale esse programa.  O arquivo de biblioteca com os trechos de código em C para a utilização dos timers de forma padronizada está dividido em segmentos. O primeiro segmento define uma série de constantes, que podem ser ajustadas conforme as especificações do projeto. Veja o trecho do código a seguir.

Nesse código há alguns parâmetros que precisam ser alterados, conforme o projeto:

  • #define   FREQUENCIA_DO_CLOCK_DA_CPU 12.0e+6 // Hz —->  12 MHz, por exemplo.

Inicializar essa constante com o valor do clock do seu microcontrolador.

  • #define   FATOR_DE_ESCALA_CLOCK_TIMER    12.0f     // Divide o clock por 12

Valor do pre-scaler.

  • #define   FREQUENCIA_DE_INTERRUPCAO_TIMER_0 5e+3  // Hz —- > 5 kHz, por exemplo.

Define a frequência da interrupção do timer.

São apenas esses três parâmetros que devem ser inicializados. Não é necessário alterar outras partes do código!

O segundo segmento da biblioteca refere-se às inicializações dos timers, conforme o modo de operação, e os comandos para iniciar a operação do temporizador. Observe que nesse segmento é mostrada a rotina principal (void main(void)) e indicado onde devem ser inseridos os trechos do código.

O terceiro segmento mostra como são definidas as rotinas de interrupção.

EXEMPLO

A seguir vamos desenvolver o nosso programa de exemplo. Nesse programa, será programado o Timer 0 no modo 2 de operação, com o microcontrolador operando com um clock de 4 MHz e uma frequência de interrupção de 1,5 kHz. Confira o código no quadro abaixo.

Se você quiser simular o programa exemplo acima e explorá-lo um pouco mais, siga os seguintes passos:

  • Instale o KEIL C51 μVision;
  • Baixe o arquivo Testa_Timer.zip;
  • Instale os arquivos de Testa_Timer.zip num diretório para testes;
  • Navegue até o diretório de testes e acione o arquivo Testa_Timer.uvproj (2 “clickes”)  (Figura 2).

Timers - Arquivos no diretório de teste
Figura 2: Arquivos no diretório de teste

Nesse instante deverá abrir o programa Keil e a tela deverá ser a retratada na Figura 3. Esse painel permite navegar no código em C, editá-lo e compilá-lo. Não é necessário fazer isso para realizar a simulação, mas você poderá posteriormente alterar alguns parâmetros do código e testar o programa com as novas alterações.

Timers - Programa Keil pronto com o programa exemplo carregado
Figura 3: Programa Keil pronto com o programa exemplo carregado

A seguir coloque o programa no modo de Debug (Figura 4, Figura 5 e Figura 6) para que se possa iniciar a simulação.

timers - Selecionando o modo Debug do programa
Figura 4: Selecionando o modo Debug do programa

Antes de entrar no modo de depuração, aparece na tela a mensagem da Figura 4. “Clicke” no  “OK” para continuar.

Timers - Aviso de que no modo de avaliação, o código fica limitado a 2K
Figura 5: Aviso de que no modo de avaliação, o código fica limitado a 2K

timers - Modo Debug de operação
Figura 6: Modo Debug de operação

 

Observe que já estão destacados os painéis de monitoramento do Timer 0 e do Port 3, cujo bit 1 deverá ser alternado a cada término de contagem do temporizador de software. As duas variáveis principais (bFlagTimerDeSoftware e nTimerDeSoftware) poderão ser monitoradas na janela Watch 1 durante a simulação.

É possível utilizar as teclas de função F11 para executar o programa passo a passo ou F5 entrar em execução. Recomendo que você inicie a simulação utilizando o passo  a passo para poder observar detalhadamente como que funciona o mecanismo de operação desse programa.

Resumo

Neste artigo técnico foram apresentados alguns conceitos relativos à utilização de temporizadores de hardware de um microcontrolador associados a temporizadores de software para a implementação de arquiteturas de software típicas de  sistemas operacionais de tempo real. Também foi apresentada e explicada uma biblioteca padronizada para a utilização dos timers de microcontroladores da família MCS-51, codificada em C, para ser compilada no programa da Keil. Depois foi desenvolvido um programa exemplo para que você possa simular o que foi apresentado e observar os detalhes dessa implementação.

Este artigo é o segundo da série de artigos que abordam algumas funções comuns em projetos de sistemas embarcados de tempo real. Confira os demais artigos (em breve).

Sistemas Operacionais de Tempo Real

Bibliotecas de funções e rotinas padronizadas em linguagem C para MCS-51

  • Timers (este artigo) – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso dos Timers do MCS-51;
  • Displays de 7 segmentos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso em displays de 7 segmentos;
  • Teclados Matriciais – É apresentada uma biblioteca desenvolvida em linguagem C para varredura, leitura, debounce, identificação da tecla acionada e desvio para a rotina de tratamento. A forma como as rotinas foram escritas, permitem sua fácil reutilização em outros projetos;
  • Periféricos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso de alguns periféricos, tais como conversores A/D, sensor de temperatura e memórias seriais.

Fonte: https://www.embarcados.com.br/rtos-timers/

Sistemas Operacionais de Tempo Real – Introdução

 

Introdução

Quando se fala em projetos para microcontroladores, especialmente os de 8 ou 16 bits, sempre surgem dúvidas com relação ao sistema operacional. É melhor comprar um sistema operacional ou desenvolver o seu próprio? Como tudo na nossa vida, a resposta a essa pergunta depende sempre da relação custo / benefício da solução. Muitos projetistas se sentem intimidados em projetar o seu próprio sistema, muitas vezes apenas por falta de experiência ou de conhecimento sobre esse assunto. Por outro lado, aprender a usar um sistema operacional de terceiros pode ser um tanto quanto trabalhoso e demorado. Se o sistema não for de uso gratuito, ainda será necessário pagar royalties para cada CPU que executar esse programa.

Neste artigo vou desenvolver alguns raciocínios que mostrarão o fato de que desenvolver um sistema operacional próprio para microcontroladores de 8 ou 16 bits é bem mais simples do que possa parecer. Será apresentada uma estrutura bastante intuitiva e simples de como organizar o seu software de forma que ele opere em tempo real com segurança. Antes disso, precisamos conceituar alguns tópicos. Observe que o assunto sobre Sistemas Operacionais é abordado neste artigo de uma forma muito superficial. Sistemas Operacionais e Sistemas de Tempo Real são temas bastante extensos e complexos e são ensinados em cursos de graduação e pós-graduação. Neste artigo vamos apresentar somente o necessário para compreender a filosofia e preparar o terreno para apresentar em artigos futuros algumas soluções padronizadas para se implementar sistemas de tempo real.

O que é um Sistema Operacional?

Segundo uma definição encontrada na Wikipedia, um Sistema Operacional  é um programa ou um conjunto de programas cuja função é gerenciar os recursos do sistema (definir qual programa recebe atenção do processador, gerenciar memória, criar um sistema de arquivos, etc.), fornecendo uma interface entre o computador e o usuário. Embora possa ser executado imediatamente após a máquina ser ligada, a maioria dos computadores pessoais de hoje o executa através de outro programa armazenado em uma memória não-volátil do tipo ROM (Read Only Memory) chamado BIOS (Basic Input Output System) num processo chamado bootstrapping, conceito em inglês usado para designar processos auto-sustentáveis, ou seja, capazes de prosseguirem sem ajuda externa. Após executar testes e iniciar os componentes da máquina (monitores, discos, etc), o BIOS procura pelo sistema operacional em alguma unidade de armazenamento, geralmente o Disco Rígido, e a partir daí, o sistema operacional toma o controle da máquina. O sistema operacional reveza sua execução com a de outros programas, como se estivesse vigiando, controlando e orquestrando todo o processo computacional.

Segundo alguns autores, existem dois modos distintos de conceituar um sistema operacional:

  • visão top-down pela perspectiva do usuário ou programador: é uma abstração do hardware, fazendo o papel de intermediário entre o software (programas) e os componentes físicos do computador, o (hardware); ou
  • numa visão bottom-up, de baixo para cima: é um gerenciador de recursos, i.e., que controla quais aplicações (processos) podem ser executadas, quando devem ser executadas e quais recursos (memória, disco, periféricos) podem ser utilizados.

 Alguns sistemas operacionais populares são: Windows, Linux, Mac OS, Android, etc.

O que é um Sistema Operacional de Tempo Real?

Sistemas operacionais de tempo real ou RTOS (Real Time Operating Systems) são uma categoria especial de sistemas operacionais. Eles são voltados para aplicações onde é essencial a confiabilidade e a execução de tarefas em prazos compatíveis com a ocorrência de eventos externos.

Por exemplo, se num paciente de UTI ocorrer uma variação importante nos batimentos cardíacos, o monitor cardíaco desse paciente deve ativar um alarme em poucos segundos.

 ID-100279454

Outro exemplo: se um avião em voo com o piloto automático desviar da rota, o controle do avião deve corrigir imediatamente essa rota retornando o avião à rota original.

ID-100177451

Tempo real é um termo que pode ter significados muito diferentes, dependendo da velocidade da ocorrência dos eventos de um sistema e dos tempos de resposta necessários para atender a esses eventos. Há sistemas que podem levar um tempo muito longo para modificar o seu estado. Em geral os processos térmicos de aquecimento são lentos. Pode levar dias ou até semanas para esses processos responderem a determinados estímulos. Nesse caso em particular, um sistema operacional comum serviria perfeitamente para realizar o controle do processo.

Particularidades de um Sistema Operacional de Tempo Real

Há muitos detalhes num Sistema Operacional de Tempo Real que merecem ser apresentados. O principal é que as rotinas de processamento em geral são bastante especializadas e curtas, pois devem executar a sua tarefa no menor tempo possível. Há um forte paralelismo na execução das atividades e um estabelecimento de prioridades, onde as atividades mais prioritárias interrompem as menos prioritárias e assumem o controle do processador. A divisão de tarefas em rotinas especializadas requer que haja alguma forma de sincronismo ou troca de informação entre elas, por exemplo, para que seja informado que tarefa já foi concluída ou não por outra rotina. Algumas estruturas comuns para a troca de informações:

  • Semáforos ou flags: são definidos bits ou palavras para a sinalização do tipo booleano ( binário 0 ou 1) para a troca de mensagens entre duas rotinas;
  • Áreas de troca de mensagens, filas  ou buffers: memórias temporárias que com auxílio dos semáforos permitem a transferência de estruturas de dados maiores entre as rotinas.

Exemplos

Para ilustrar as diversas arquiteturas de tempo real, serão apresentados dois exemplos bastante simplificados.

Exemplo 1

Suponhamos que um programa de computador deseje realizar a transmissão de uma mensagem pela USB. Num sistema comum, ilustrando de uma maneira simplificada, esse programa monta a mensagem e chama a rotina para a transmissão e só são retomadas as próximas atividades após o término da transmissão. Esse tipo de programação é conhecida como programação linear.

No caso de um sistema de tempo real (veja a Figura 1) a sequência de operações pode ser assim:

Transmissão-Serial_a

 Figura 1: Transmissão de caracteres em tempo real simplificada

     Para melhor entendimento ficará convencionado que:

  • flag buffer vazio” = 1,    significa que não há dados no buffer temporário;
  • flag buffer vazio” = 0,    significa que há dados novos no buffer temporário.

    Programa principal:

  • O programa principal inicialmente testa se o buffer temporário está disponível ou vazio (flag buffer vazio” = 1);
  • Se estiver vazio, monta a mensagem numa estrutura temporária (buffer);
  • Dispara a transmissão do conteúdo do buffer temporário alterando o flag “buffer vazio” para “não está vazio” (flag “buffer vazio” = 0);
  • Continua a execução das outras atividades enquanto é realizada a transmissão.

      Rotina de Transmissão:

  • Fica dormente ou então testa periodicamente o flag “buffer vazio”;
  • Se o flagbuffer vazio” indicar que há dados novos (flag “buffer vazio” = 0), transfere os dados do buffer temporário para o buffer de transmissão;
  • Altera o flag de “buffer vazio” sinalizando que o buffer está disponível para novos dados (flag “buffer vazio” = 1);
  • Transmite os caracteres, um de cada vez, até transmitir o último;
  • Sinaliza que “Terminou a transmissão” (flag).

Observe que em geral a rotina de transmissão é programada para ser ativada por interrupção, de forma que ela não gaste ciclos de máquina enquanto espera o término de transmissão de um caracter. Assim é aproveitado o hardware do microcontrolador para realizar tarefas em paralelo com o programa principal.

Exemplo 2

Esse exemplo é baseado num projeto real. Trata-se de uma placa mezanino cuja função é processar simultaneamente os dados referentes a 4 canais telefônicos em tempo real de forma a implementar as seguintes funções:

  • Cancelamento de resíduo de voz na linha de recepção resultante do eco da “fala” gerada pela placa mãe sem distorcer os sinais de origem externa;
  • Pré-processar os sinais de entrada identificando pulsos decádicos telefônicos através de filtragens e outros processamentos;
  • Implementação parcial de call-progress, focando na detecção do tom de “ocupado” e de “linha”.

O sistema operacional de tempo real para esse caso foi projetado em camadas, com prioridades atribuídas decrescentes nas camadas conforme vai crescendo o índice da camada. O fluxo de dados tem taxas decrescentes das camadas inferiores para as superiores. Veja na Figura 2. Observe que a comunicação entre as camadas é realizada através de filas ou buffers circulares, dimensionados de forma que num regime de atendimento simultâneo de quatro linhas telefônicas, o fluxo médio de dados nunca provoque o “estouro” dessas filas. A cada buffer estão associados ponteiros de início e final da fila (“primeira livre”) e uma variável indicando o número de dados que estão na fila. O mecanismo convencionado para a operação das filas circulares é o seguinte:

  • Quem transfere um dado para a fila, incrementa o número de elementos e o ponteiro para o final;
  • Quem retira da fila, decrementa o número de elementos e incrementa o ponteiro de início.

Mezanino_Original

Figura 2: Diagrama da arquitetura do programa em camadas

Uma descrição resumida do que ocorre em cada camada:

CAMADA 0

Trata basicamente dos eventos gerados externamente ao programa. Há eventos assíncronos gerados pela placa-mãe e outros síncronos gerados por temporizadores de hardware. Esses eventos são:

  • Chegada de mensagem enviada pela placa-mãe. Essa mensagem é inserida na fila de entrada de mensagens, que será tratada pela CAMADA 1;
  • Interrupção de hardware com frequência de 10 Hz para a atualização dos estados de cada linha telefônica;
  • Interrupção de hardware com frequência de 8 kHz onde são lidos os dados das 4 linhas telefônicas, e
    • é realizada a decodificação dos dados recebidos;
    • é aplicada uma rotina de cancelamento de eco com filtragem digital adaptativa;
    • o sinal filtrado segue por 3 caminhos:
      • é utilizado como sinal de erro para cálculo do ajuste dos coeficientes do filtro adaptativo;
      • é transferido para a fila que alimenta a CAMADA 1. (Taxa de 8.000 amostras/s);
      • é novamente codificado e retorna à placa-mãe.

CAMADA 1

Realiza o loop principal do programa com funções de pré-processamento dos sinais entregues pela CAMADA 0 na fila de dados e o tratamento das mensagens vindas e que são endereçadas à placa-mãe. A CAMADA 0 é composta pelo encadeamento das seguintes rotinas:

  •  Tratamento dos dados provenientes das linhas telefônicas:
    • Realiza o processamento e a análise de duas linhas por vez gerando uma saída para a CAMADA 2. A taxa máxima desses dados para a CAMADA 2 é de 170 amostras/s;
    • Realiza um pré-processamento de dados analisando simultaneamente as 4 linhas e gera para a CAMADA 2 um fluxo de dados de 400 amostras/s endereçada ao detetor de pulsos decádicos. Também repassa uma mensagem para a placa mãe quando a CAMADA 2 detectar um pulso;
    • Descarta dados das filas e atualiza os ponteiros.
  • Chamada das rotinas que compõem a CAMADA 2.

CAMADA 2

Realiza a análise dos dados gerados na CAMADA 1 e gera as saídas endereçadas à CAMADA 1 ou à placa-mãe. É composta pelas rotinas:

  • Realiza a análise dos dados para detecção de pulsos decádicos. Gera mensagens endereçadas à placa-mãe;
  • Realiza a identificação dos tons de “ocupado” e de linha e sinaliza por meio de mensagens à placa-mãe.

Nesse exemplo o software foi dividido em camadas com prioridades decrescentes para conseguir acomodar todas as funções previstas para o mezanino no curto tempo disponível para a sua execução. Esse projeto funcionou e ficou em operação por pelo menos 10 anos.

 O que é Firmware?

Para completar esse trabalho é interessante conceituar Firmware. Transcrevendo mais uma vez uma definição apresentada pela Wikipedia:

Em eletrônica e computação, firmware é o conjunto de instruções operacionais programadas diretamente no hardware de um equipamento eletrônico. É armazenado permanentemente num circuito integrado (chip) de memória de hardware, como uma ROM, PROM, EPROM ou ainda EEPROM e memória flash, no momento da fabricação do componente. Muitos aparelhos simples possuem firmware, entre eles: controles-remotos, calculadora de mão, algumas partes do computador, como disco rígido, teclado, cartão de memória, unidades USB’s muitos instrumentos científicos e robôs. Outros aparelhos mais complexos como celulares, câmeras digitais, sintetizadores, entre outros, também possuem um firmware para a execução de suas tarefas.

Não há fronteiras rígidas entre firmware e software, pois ambos são termos descritivos bastante livres. Contudo, o termo firmware foi originalmente inventado para contrastar com software de alto nível que poderia ser alterado sem a troca de um componente de hardware, e o firmware está normalmente envolvido com operações muito básicas de baixo nível das quais sem um dispositivo seria completamente não-funcional.

Nos próximos artigos serão apresentadas rotinas padronizadas para utilização em sistemas de tempo real. Nesses artigos serão utilizados diversos conceitos expostos aqui.

Resumo

Sistemas Operacionais de Tempo Real têm uma filosofia muito peculiar na sua arquitetura. Os programas são organizados de forma a poder responder a estímulos externos ou internos num tempo curto o suficiente e compatível com a importância ou urgência do evento que gerou esses estímulos. Frequentemente esses sistemas operacionais estão intimamente ligados ao hardware de um sistema.

Se você quiser se aprofundar um pouco mais sobre esse assunto:

Artigos relacionados

Sistemas Operacionais de Tempo Real

  • Sistemas Operacionais de Tempo Real – Introdução (este artigo) –  Apresentação introdutória do que é um sistema operacional e as características que o tornam um sistema de tempo real. Também são apresentadas algumas estruturas que facilitam o seu projeto.

Bibliotecas de funções e rotinas padronizadas em linguagem C para MCS-51

  • Timers  – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso dos Timers do MCS-51;
  • Displays de 7 segmentos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso em displays de 7 segmentos;
  • Teclados Matriciais – É apresentada uma biblioteca desenvolvida em linguagem C para varredura, leitura, debounce, identificação da tecla acionada e desvio para a rotina de tratamento. A forma como as rotinas foram escritas, permitem sua fácil reutilização em outros projetos;
  • Periféricos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso de alguns periféricos, tais como conversores A/D, sensor de temperatura e memórias seriais.
Fonte: https://www.embarcados.com.br/sistemas-operacionais-de-tempo-real-rtos/