segunda-feira, 27 de junho de 2016

Protocolo USB x Porta paralela dos anos 90 - CNC atuais


Antigamente (anos 90) era muito fácil fazer uma CNC. Hoje parece que virou um monstro. Um verdadeiro pé no saco.

As vantagens do USB são a facilidade de adicionarmos novos periféricos. Plug and Play. Muito bom para os usuários. Para os Usuários, apenas. Por que? Se você é desenvolvedor desde os anos 2000, onde podíamos pegar o sinal diretamente da placa mãe sem muitos problemas, vai confirmar: Apesar da limitação de no máximo 1000 pulsos por segundo, o que tornaria lenta a CNC em comparação as atuais, era algo que podia ser feito facilmente.

As CNCs deste tempo eram lentas, mas eram fáceis de se fazer e dar manutenção. Hoje, com a evolução da tecnologia e o surgimento de novos protocolos, tenho notado que estamos perdendo tempo de mais da conta estudando protocolos de comunicação, sendo que na verdade teríamos que saber mais matemática e física do que o protocolo de comunicação de um aparelho que podem mudar (evoluir?... sei não...) a qualquer momento. Hoje não encontramos mais portas paralelas. Temos que utilizar adaptadores se quisermos voltar a trabalhar com a porta paralela. Algo que nem sempre pode dar certo se o driver que tiver utilizando não for o apropriado. E por experiência própria digo que é uma verdadeira maratona encontrar o correto e se conformar com a lentidão, consequência da limitação de 1000 pulsos por segundo.

É verdade que poderia comprar um microcontrolador para USB, mas e daqui a 10 anos, terei que comprar outro se eu quiser ressuscitar o projeto? Não. Pra mim não. Basta! Como não posso aceitar gastar 20 vezes mais tempo estudando uma um protocolo novo a cada evolução, decidi recorrer a eletrônica analógica. Se já tenho um computador, PC comum, por que outro na forma de um microcontrolador? Se todo o funcionamento depende apenas de como saber lidar com sinais, sabendo um pouco de física, eletrônica e computação, já deveria ser mais do que suficiente um computador e o hardware da cnc. Desculpem, mas só um maluco perde mais que o dobro do tempo que deveria se debruçando em um protocolo de comunicação. A não ser que seja que esteja pensando em vender esse tipo de trabalho. Mas isso, na minha opinião, é uma falsa demanda. Pensem. Uma demanda criada artificialmente? A gente só faz algo assim pra aprender uma língua nova, que vai continuar viva por pelo menos uns 250 anos ou se for mesmo para vender o produto.

Alguns podem dizer que sou adepto da teoria da conspiração, mas deveria existir uma forma melhor de se pegar um bom sinal gerado pelo computador.

Diante da exaustão, vou apelar. É pra apelar? Então vamos apelar. Estou pensando em escapar da necessidade de atualizar as formas de comunicação com minha cnc de 10 em 10 anos utilizando sons. Gerar sons wav e através dos speakers pegar o sinal da forma que quero. Acredito que podemos gerar um bom sinal, com mais de 1000 pulsos por segundo, utilizando os speakers USB, e conhecimentos básicos de eletrônica (Demultiplexação). Se quiserem fabricar computadores, rádios com mp3, terão que respeitar a fidedignidade dos sons ou perder a atração do publico. Por agora creio que seja o mínimo que qualquer um possa conseguir sem grandes custos. É um começo. Para pensar em acelerar, mesmo que utilizando um microcontrolador. Se der merda, quanto vai perder se sua produção parar? quanto terá que pagar pela manutenção ou você sabe como tudo nos mínimos detalhes funciona e consegue fazer suas próprias peças sobressalentes?

Sobre linguagem C e C++ no Windows atualmente

Essa dica é pra quem tá utilizando Windows 8 ou 10:
Não perca seu tempo instalando Dev-Cpp nele. Procure no google por:
wxdev c++ download
Poupem seu tempo e seus cabelos.



Exemplo do código em C++ gerador de arquivo Wav de onde pretendo me basear pra fazer meus testes para acelerar a CNC:

// fonte:
//http://www.cplusplus.com/forum/beginner/166954/
#include <cmath>
#include <fstream>
#include <iostream>

using namespace std;

#define Do  261.63
#define Do2 277.18
#define Re 293.66
#define Re2 311.13
#define Mi 329.63
#define Fa 349.23
#define Fa2 369.99
#define Sol 392
#define Sol2 415.3
#define La 440
#define La2 466.16
#define Si 493.88

namespace little_endian_io
{
  template <typename Word>
  std::ostream& write_word( std::ostream& outs, Word value, unsigned size = sizeof( Word ) )
  {
    for (; size; --size, value >>= 8)
      outs.put( static_cast <char> (value & 0xFF) );
    return outs;
  }
}

using namespace little_endian_io;

int main()
{
  ofstream f( "example.wav", ios::binary );

  // Write the file headers
  f << "RIFF----WAVEfmt ";     // (chunk size to be filled in later)
  write_word( f,     16, 4 );  // no extension data
  write_word( f,      1, 2 );  // PCM - integer samples
  write_word( f,      2, 2 );  // two channels (stereo file)
  write_word( f,  44100, 4 );  // samples per second (Hz)
  write_word( f, 176400, 4 );  // (Sample Rate * BitsPerSample * Channels) / 8
  write_word( f,      4, 2 );  // data block size (size of two integer samples, one for each channel, in bytes)
  write_word( f,     16, 2 );  // number of bits per sample (use a multiple of 8)

  // Write the data chunk header
  size_t data_chunk_pos = f.tellp();
  f << "data----";  // (chunk size to be filled in later)
 
  double hz        = 44100;    // samples per second
 
  // Write the audio samples
  // (We'll generate a single C4 note with a sine wave, fading from left to right)
  double two_pi = 6.283185307179586476925286766559;
  double max_amplitude = 32760;  // "volume"



    double seconds   = 0.4;      // time

    double notas[18] = {Do, Re, Do, Re, Re, Re, Do, Sol, Fa, Mi, Mi, Mi, Do, Re, Mi, Fa, Fa, Fa};

    for(int i=0; i<sizeof(notas)/sizeof(notas[0]); i++)
    {
           
            //for (int hh = 0; hh < 10; hh++) {

        int N = hz * seconds ;  // total number of samples
        for (int n = 0; n < N; n++)
        {          
                //double amplitude = (double)n / N * max_amplitude;
                double amplitude = max_amplitude;
                double value     = sin( (two_pi * n * notas[i])/hz);
                write_word( f, (int)(                 amplitude  * value), 2 );
                write_word( f, (int)(                 amplitude  * value), 2 );
                //write_word( f, (int)((max_amplitude - amplitude) * value), 2 );           
        }
    }
 
    // (We'll need the final file size to fix the chunk sizes above)
    size_t file_length = f.tellp();

    // Fix the data chunk header to contain the data size
    f.seekp( data_chunk_pos + 4 );
    write_word( f, file_length - data_chunk_pos + 8 );

    // Fix the file header to contain the proper RIFF chunk size, which is (file size - 8) bytes
    f.seekp( 0 + 4 );
    write_word( f, file_length - 8, 4 );
 
    //    printf("Press Any Key to Continue\n"); 
    //getchar();
    return 0;
 
}

Esquema - Exemplo de demultiplexador e as frequências de passagem





Valeu Wagner Rambo e Wr Kits!

https://www.youtube.com/watch?v=WOD0tkk7zPQ 




Após a demultiplexação, e retificação do sinal, a intensidade do sinal poderá atuar em um controle de PWM nos motores.

Continuando:



Evoluindo um pouco para usar como controle direto das bobinas do motor de passo - OBS: Este não é aplicável PWM



Outro modelo
Evoluindo um pouco e reduzindo circuitos:







Schmitt Trigger.

Evoluindo um pouquinho mais, tomei conhecimento do Schmitt Trigger: quem quiser saber mais:
http://www.clubedohardware.com.br/forums/topic/1243774-ruido-em-sinal-apos-filtragem/

Resistores

Os resistores serem muito pequenos, é necessário pois preciso ter respostas muito rápidas. Isso, para o tamanho dos capacitores que estou utilizando, em combinação com o indutor que é o maior que posso colocar sem tornar o projeto pesado de mais. E também não queremos um indutor de meio kg, como quase cheguei a cogitar uns tempos atrás sem perceber que os cálculos são coisas bem diferentes de realidade.

Indutores

Para alguém que curte mais a matemática pode perder a referencia sobre realidade. Não ter preço pra trabalhar com matemática pode fazer isso. Nos leva a esquecer do resto. Lembrando as vezes o economista: "tendo dinheiro, dá pra fazer". Assim, para não ter que procurar vários tipos de indutores, e ter apenas um capacitor como referência, decidi aplicar uma ideia velha de um joguinho:
http://tivideotutoriais.blogspot.com.br/2016/09/multiplexacao-de-sinais.html
Obs: Esta escala que usaremos aqui não é a da solução do jogo. A forma como pretendo fazer aqui é o mesmo que deve ser utilizado lá.


As soluções, pelo que vi é:



Para a solução 1 e 2:

Comprar 2 tipos de indutores, com tamanhos correlacionados com a escala de 4. O numero de tipos reduzido foi escolhido para facilitar a montagem e termos bastante dos mesmos em caso de queima nos testes. isso vai acontecer.

Cada motor tem 4 canais. E nos 3 motores, todos os canais são diferentes.
Todos estes canais deverão ser separados, antes de injetarmos sinal nos motores e na minha opinião, devem seguir o mesmo principio para a solução do joguinho acima citado. É algo semelhante ao que fazemos com o decimal ou binário. Por isso, então, supondo que tenho este espaço, vou medir assim:
indutor 1 (i1) = o usado para a menor configuração possível. algo como o 1
indutor 2 (i2)= 4x o anterior

Estes indutores devem ser suficientes para a construção do que queremos, sendo que utilizaremos a associação de indutores.

solução 1:

Manter os capacitores e conseguir 18 do indutor 1 e 15 do indutor 2. Posso construir assim:

Motor 1
canal  1 = i1
canal  2 = i1+i1
canal  3 = i1+i1+i1
canal  4 = i2

Motor 2
canal  5 = i2+i1
canal  6 = i2+i1+i1
canal  7 = i2+i1+i1+i1
canal  8 = i2+i2

Motor 3
canal  9 = i2+i2+i1
canal 10 = i2+i2+i1+i1
canal 11 = i2+i2+i1+i1+i1
canal 12 = i2+i2+i2



Solução 2:
conseguir 3 capacitores diferentes e conseguir 18 do indutor 1 e 3 do indutor 2. A combinação de apenas o mostrado no primeiro motor, para cada um dos 3 capacitores, formará filtros diferentes.
Pode se ter, também, outra escala, a de 2 em combinação com os 3 capacitores:

Motor 1
canal  1 = i1
canal  2 = i2
canal  3 = i2+i1
canal  4 = i2+i2

Assim, seriam necessários,  3 capacitores diferentes, 6 indutores i1 e 12 indutores i2




Solução 3

Já com indutâncias resolvidas, podemos ter:
4 tipos de indutores x 3 e 3 tipos de capacitores x 4. 
Com mais uma afinação. Ao pegar um núcleo toroidal de 1cm de diâmetro com 32 voltas, aproximadamente, obtive 656mH. O que facilitaria muito a fabricação dos indutores dos testes.



Para este, um programa em JavaScript, facilmente rodável salvando-o com o final html:


<script>
    var array_capacitor=[0.00000001, 0.000000006, 0.0000000035];
    var array_indutor  =[0.024, 0.022, 0.020, 0.018];
    for(i=0; i<array_capacitor.length; i++)
    {
        document.write( "Motor " +(1+i)+ "<br>");
        for(j=0; j<array_indutor.length; j++)
        {
            value = 2*3.14041*Math.sqrt(array_indutor[j]*array_capacitor[i]);
            document.write( "frequência = " + (1/value) + " <br>");
        }
        document.write("<br>");
    }
</script>

Nenhum comentário:

Postar um comentário