Como o sinal Ativo Alto e Ativo Baixo funcionam em Sistemas Incorporados?

É sobre como os micro controladores funcionam em geral.

A programação que fazemos é convertida em 1 e 0 pelo compilador e esse código compreensível da máquina é carregado no microcontrolador.

Como o microcontrolador responde a isso? Quero dizer, esses 1 e 0 são convertidos na tensão lógica correspondente (5v e 0) pelo DAC? Se é assim, como esse pedacinho de silício decide o que fazer com essas várias combinações de 5v e 0v?

Entendo que cada CI é feito de portas lógicas e essas portas são compostas de transistores. Então, como esses transistores respondem a várias combinações de 5v e 0v?

O que os faz procurar essas lógicas. Quero dizer, como elas monitoram essas instruções quando são ligadas?

Então, certamente, deve haver um sistema operacional carregado no mcu que diz para ele processar e como processar essas instruções, não é?

A próxima coisa é ... considere um cronômetro ... é simplesmente um registro que aumenta em um após cada ciclo do relógio. Não é o SO novamente que instrui o MCU a incrementar após cada relógio? Estou certo? Nesse caso, em que idioma, todo o código de um sistema operacional está escrito?

Posso apenas continuar meu trabalho com a programação do mcu para tarefas diferentes, mas hoje eu estava interessado em saber como meu código é entendido por esta máquina.

Lamento que minha pergunta seja demorada para ler .. por favor me ajude a aprender essas coisas básicas ..

Desde já, obrigado..

Não há necessidade de usar um DAC. As tensões são usadas para representar 1 e 0 pela convenção de que qualquer coisa abaixo de 0,8V (AKA 'baixo') é zero e qualquer coisa acima de 2,4V (AKA 'alto') é um. É relativamente simples construir circuitos que executam lógica nessas tensões representativas.

Por exemplo, um circuito pode emitir algo na faixa de 2,4V a 5V para representar '1' se uma das entradas estiver acima de 2,4V ou algo abaixo de 0,8V, caso contrário, e você tiver uma porta OR. Se exigir as duas entradas que representam 1 para gerar 2,4V, você terá um portão AND. Um inversor apenas produz uma alta quando a entrada é baixa e vice-versa. Você pode construir portões simples como esses com apenas alguns transistores e executar lógica booleana combinatória. Usando grupos de bits para representar números, você pode até construir circuitos para adicionar números com lógica combinatória, sem necessidade de software.

Depois de trabalhar com portões, você pode construir chinelos e, a partir deles, registradores e contadores. Os flip-flops permitem armazenar 1 e 0 a partir de um ponto no tempo e usá-los posteriormente. Registradores e contadores são circuitos que executam funções em grupos de bits que representam números. Um registro mantém um número até você carregar um novo número nele. Um contador é como um registro, mas tem outra entrada que faz com que o número armazenado seja incrementado. (Decremento também é possível). Isso coloca você no domínio das máquinas de estado e da lógica seqüencial, ainda assim, nenhum software é necessário.

Os sistemas de memória são uma maneira de armazenar um grande número de bits. No nível de um componente, alguma memória é construída como uma enorme coleção de chinelos, mas mais comumente existe outra tecnologia (DRAM) que, embora não seja exatamente um chinelo, faz a mesma coisa.

Como uma etapa adicional, você pode criar um sistema de lógica sequencial e combinatória que possa executar operações dependendo dos bits armazenados em um sistema de memória, incluindo a gravação de novos valores nesse sistema de memória. Agora você chegou ao nível do processador e tudo o que o processador faz é apenas hardware executando muitas tarefas simples. (apesar dos núcleos microprogramados). Nesse ponto, as combinações específicas de bits que você coloca no sistema de memória podem ser consideradas software de linguagem de máquina.

Obtenha o livro "Code: The Hidden Language of Computer Hardware and Software", de Charles Petzold . É incrível, fácil de ler e responde a muitas dessas perguntas.

Se você não puder pagar pelo livro de Petzold, confira "How Computers Work", de Roger Young . Ele cobre praticamente o mesmo material, e as versões HTML e PDF são gratuitas.

Considere um NPN BJT; um transistor. Um dos primeiros descobertos.

Agora você o conecta de modo que o coletor esteja conectado a uma entrada lógica variável e o emissor esteja conectado a outra entrada lógica, com um resistor em série. Então, um resistor do emissor para o terra.

               logic
                 |
         10k   |/
logic --/\/\/--|  NPN
               |>
                 +-- output
                 |
                 /
                 \ 10k
                 /
                 |
                ---
                 -

Você acabou de construir um portão AND. A saída é alta apenas quando ambas as entradas são altas. Não é perfeito de forma alguma, pois depende da entrada do coletor e porque não se espalha bem, mas fornece uma idéia de como os transistores podem ser usados ​​para calcular uma função.

Então, você também pode construir um portão NOT;

                5V
                 |
                 /
                 \  10k
                 /
                 +-- output
                 |
         10k   |/
logic --/\/\/--|  NPN
               |>
                 |
                ---
                 -

Adicionar isso à saída do portão AND recém-construído nos fornece um portão NAND, e você pode saber que, com um portão NAND, você pode construir qualquer forma de lógica. Ele também tem a vantagem de que o sinal é armazenado em buffer, aumentando a capacidade de expansão e encadeamento.

Processadores reais raramente usam BJTs, mas a lógica CMOS, mas os mesmos princípios se aplicam.

Talvez você deva procurar em algumas referências de sistemas digitais ou em coisas como VHDL. Uma MCU é basicamente projetada com blocos de construção, que podem ser uma variedade de portas lógicas e blocos de construção (menores). Em última análise, tudo se resume a portas lógicas que são realmente compostas por transistores. Um MCU simples típico, como um PIC18F ou algo assim, não executa um sistema operacional. O programa que você carrega nele contém várias instruções da máquina que o PIC executa continuamente. Todo o processo é feito por hardware.

Um procurador geral geralmente possui uma ALU (calcula o resultado de uma determinada instrução) e mais blocos ao seu redor que carregam instruções, gerenciam a pilha e gerenciam a memória. O procurador possui alguns registros para trabalhar com ele próprio, principalmente para carregar entradas e armazenar resultados. Talvez você não veja muito disso em C ou em outro idioma, mas muito em assembly.

A ALU lida com instruções com certos códigos e entradas de operação. Por exemplo, uma instrução típica pode ser ADD 12 1, o que significa 12 + 1 = 13. O resultado é armazenado em um registro no próprio processador.

Dependendo da arquitetura, a ALU tem, por exemplo, 8 bits de largura. Um somador simples de 8 bits pode ser feito de somadores de 8 bits de 1 bit amarrados (usando blocos para criar um bloco maior). Um somador de 1 bit pode ser facilmente gravado em portas lógicas usando álgebra booleana. Escrever um adicionador de 8 bits manualmente manualmente usando apenas portas lógicas seria uma quantidade insana de trabalho. É como escrever um programa sem ter a capacidade de usar nenhuma função ou sub-rotina.

Para fazer com que os sistemas digitais funcionem corretamente, a maioria dos blocos é projetada para clock. Todo sistema digital tem uma certa quantidade de tempo necessária para atingir seu estado final. Isso ocorre devido a atrasos de comutação em transistores e estados que influenciam outros estados. O sinal do relógio é algo com o qual você deve estar familiarizado, a velocidade com que o procursor é executado. Um cronômetro pode ser um dispositivo realmente simples que possui um pequeno bloco somador e aumenta em 1 toda vez que obtém um relógio.

Este é um tópico importante e não posso dar uma resposta simples, mas ...

Você pode se aproximar um pouco mais dessa resposta dividindo e conquistando, e como a outra resposta tenta atacar esse problema do ponto de vista do hw, tentarei de um ponto de vista de alto nível do SW.

Se você escreve algum software no código digamos c (um nível muito alto de abstração), não vê realmente o que está acontecendo e não entende realmente todas as coisas que você está perguntando.

Mas vamos começar de qualquer maneira.

Um programa simples que apenas inclui uma variável.

int main(void)
{
    int i=0;
    while(1) {
        i++;
    }
}

Então precisamos pegar o código do assembler para entender o que está acontecendo. Esta etapa pode ser executada em qualquer plataforma que você usar, mas, para simplificar, eu uso o gcc em um PC (mas isso não importa ...)

gcc -O0 -S main.c -o main.lst

Então, acabamos com algo assim:

    .file   "main.c"
    .text
.globl main
    .type   main, @function
main:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $16, %esp
    movl    $0, -4(%ebp)
.L2:
    addl    $1, -4(%ebp)
    jmp .L2
    .size   main, .-main
    .ident  "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
    .section    .note.GNU-stack,"",@progbits

Então você tenta entender todas as linhas de código e o que elas fazem.

E então você começa a analisar como todas as instruções são implementadas ... Por exemplo, o subl

    subl    $16, %esp

Neste ponto, é diferente em arquiteturas diferentes e x86, arm, pic é meio diferente ... Mas desde que meu exemplo foi x86.

• http://en.wikipedia.org/wiki/X86_assembly_language

  subl $ 4,% esp / * aloca 4 bytes de espaço de pilha para as variáveis ​​locais dessa função * /

E nesse nível, quando você ler a cópia, a maioria das ações parecerá que você está apenas movendo os números e, de certa forma, é isso que está acontecendo. Temos um programa predefinido em que pisamos, esse programa é armazenado em algum tipo de memória flash que geralmente é algum tipo de lógica eletrônica que interceptará um nível lógico.

Se você vê algum tipo de " flip-flop " para cada parte, então você está perto, e então precisamos de muitas delas. Aqui começamos a encontrar os seus e zeros.

Então, para que alguma ação ocorra, adicionamos uma lógica interessante que pode transformar um número em outro (a própria CPU).

E então seguimos o programa um passo de cada vez, e para saber onde estamos, temos um contador de programas (PC). E mova os números para trás e para a quarta e armazene aqueles em outra memória que também é uma espécie de grade com flip-flops.

Mas vamos voltar a um exemplo específico novamente, para entender um pouco melhor a CPU, podemos dar uma olhada na ALU e nesta imagem simplificada . Onde você pode ver que, quando movermos dados para esse bloco lógico e selecionarmos alguma operação com os pinos OP, obteremos um novo resultado na saída. Que nós, por sua vez, podemos voltar para algum lugar na memória.

E amaldiçoar sua ULA na parte da CPU da sua UCP é muito mais complexa que essa, mas opera com o mesmo princípio básico.

Nesse ponto, podemos ver algum circuito lógico que faz o "trabalho" de um lado e algum armazenamento do outro lado. E o armazenamento tem duas partes, uma para o programa e outra para os dados. Mas como nós realmente "nos movemos", então, esses devem estar conectados de alguma maneira ...

E é aqui que conectamos essas peças a um ônibus.

Um barramento é apenas alguns fios que conectam as diferentes partes e, em seguida, a lógica de controle informa à memória quais dados enviar para esse barramento e qual parte da CPU que deve escutar esses dados enviados. E isso é feito com algumas linhas de controle paralelas que habilitarão / desabilitarão as diferentes partes.

...

Portanto, se você escolher seu mcu de escolha e dissecar um programa muito pequeno, e contanto que não entenda o que está acontecendo, você o dissecará ainda mais até ter um belo quebra-cabeça que pode ser usado para criar um "mcu".

E não se esqueça de ler a folha de dados do seu mcu e verificar com que tipo de peças ele foi feito, como que tipo de memória, alu, ônibus etc.

Espero que isto ajude um pouco ???

Boa sorte

Você realmente não precisa saber disso, a menos que esteja prestes a projetar CPUs, mas tudo se resume a uma enorme máquina de estado implementada em hardware.

O maior problema com esse tipo de pergunta é que a resposta é enorme e ocupa vários anos de cursos universitários; portanto, qualquer resposta que você obtém aqui apenas arranha a superfície.

Se você realmente quer saber o que ocorre em uma CPU, dê uma olhada no código-fonte vhdl / verilog em: http://opencores.org/projects

Apenas aprender vhdl e verilog será uma tarefa grande, por si só, para que você tenha uma longa leitura :)

Quero dizer, esses 1 e 0 são convertidos na tensão lógica correspondente (5v e 0) pelo DAC?

Não, não é um DAC. Os 1s e 0s nunca existem realmente. Eles são apenas uma abstração matemática que usamos para facilitar a programação. As tensões digitais reais podem ser 5 V, 3,3 V ou 1 V, dependendo do hardware. Em última análise, um computador é apenas lógica digital. A memória armazena os 1s e 0s como lógica digital, um circuito lógico digital os transfere da memória para o processador, o processador é um circuito lógico digital que pode adicionar, subtrair ou comparar números binários, etc.

como esse pedacinho de sílica

Silic a é vidro, uma mistura de silício e oxigênio. Chips são feitos a partir de silic pura em , com impurezas adicionadas em lugares específicos para fazer todos os transistores.

Eu entendo que cada CI é feito de portas lógicas

Os CIs digitais são feitos a partir de portas lógicas, e não de CIs analógicos.

Então, como esses transistores respondem a várias combinações de 5v e 0v?

Leia o exemplo mais simples, o inversor CMOS .