Felipe Electronic

Acho que para um leigo o set de instruções deve ser explicado sem tantos detalhes, uma vez que o tutorial tem por objetivo iniciar quem quer aprender. Já detalhes da arquitetura (ex.: o que são os Bus I-CODE e D-Code, instruções SIMD, e outros) podem ser consultados em bons livros, uma vez que o iniciado tera um conhecimento maior do que aquele que entrou. Os Wait States podem ser perceptíveis ou não, mais um detalhe que vale a pena ser buscado em um livro e nao num tutorial, pois a maioria dos fabricantes ja possuem instruction caches customizados para compensar a penalidade de memória Flash mais lenta que o clock do processador (por exemplo o ART usado nos micros da ST). O Keil e o IAR ainda são referências na geração de código eficiente e limpo, por outro lado, se o objetivo é focar em gente que quer aprender e nao tem como investir na ferramenta (e convenhamos 32K de código limitado é muito pouco) valeria a pena cobrir tanto o desenvolvimento em uma ferramenta proprietária como em ferramenta aberta baseada no combo Eclipse + GCC. Fora que a interface do keil e do IAR é feia que dói e pouco intuitiva (mas isso é mais questão de opinião)

@Projetos_afg, Muito legal seu tutorial, acho muito importante levar pras massas os ARM, principalmente os M0 que são concorrentes diretos aos processadores clássicos utilizados (AVR, PIC, 8051). Conte comigo no que precisar de ajuda a respeito da arquitetura, a propósito em qual fabricante de processador você pretende focar? Além de qual ferramenta de desenvolvimento? Fechada? Open baseada em Eclipse + GCC? Permita - me fazer algumas considerações Esses processadores : ARM7, ARM7TDMI, ARM9TDMI, ARM11 , nada mais são do que subfamílias de uma arquitetura comum, conhecida por ARMv6, eles essencialmente são igual só que possuem aditivos no set de instruções bem como no tratamento das exceções e periféricos internos. De forma similar os processadores Cortex-M e Cortex-A são da mesma arquitetura a ARMv7 e v7M, essencialmente é o mesmo processador mas que sofre aditivos no set de instruções, no caso dos Cortex-A temos a unidade NEON para calculo vetorial em ponto flutuante via HW, a familia Cortex possui diferenciais como os modos low power, instruções SIMD e DSP extensions (M4) e a unidade de ponto flutuante, nos CM, ainda possuem o diferencial das interrupções que nao tem nos Cortex - A, o NVIC um belo controlador de interrupção deterministico. Sobre processadores 64bits (aarch64) esses derivam da nova arquitetura a ARMv8 e seus processadores se nao me engano ja são usados no IPHONE 5s e 5C, nao devemos esquecer de citar os Cortex - R4 que são voltados para aplicações de missão crítica. Sobre as instruções Thumb, nem sempre se ganha em densidade de código sobre a penalidade de perca de desempenho de execução, inclusive pode melhorar e muito o desempenho, algumas das instruções SIMD por exemplo que executam mais de uma operação em 1 ciclo de máquina fazem parte do set thumb. Processadores RISC que possuem arquitetura Load/Store não fazem milagres ja que a instruções possuem tamanhos fixos, podendo inclusive causar efeitos indesejáveis de desalinhamento na memória de programa... Nisso processadores Harvard - CISC dão um show combinando desempenho e instruções de tamanhos variáveis, dando um ganho de densidade de código incrível (Procesadores RX600 fazem isso). Seria interessante explicar ao pessoal o que significa DMIPS, se precisar de uma mão estamos ai No mais, parabéns pela iniciativa. Abs.

@fabiano aladin, Se o problema da amplitude foi resolvido, vamos aos problemas das frequencias... veja, voce pode utilizar um timer de base, e configurar ele para uma interrupção periodica, nessa interrupção, aloque 3 contadores cada qual com seu limite de contagem que corresponderá a frequencia... a cada interrupção incremente esses contadores e compare com o limite, caso seu valor fique igual ou maior que o limite, voce complementa o estado do pino correspondente ao seu GPIO. Veja um exemplo GENERICO de como fazer isso: /***************************************************************** EXEMPLO DE TOOGLE DE 3 GPIOS EM FREQUENCIAS DIFERENTES By: FSN *******************************************************************/#include <stdint.h> //default caso nao haja tipo padrao//coloque seus includes e fuses abaixo dessa linha://estrutura de um gerador de onda quadrada:typedef struct{ //contador atual do gerador uint8_t ContadorFreq_ ; //limite de contagem atual: uint16_t LimiteFreq_ ; //GPIO acessado: uint16_t GPIO;}Gerador_t;//cria 3 estruturas de geradores:Gerador_t Freq1;Gerador_t Freq2;Gerador_t Freq3;//prototipos das funcoes usadas:void IniciaSistema(void);void ModificaFrequencia(Gerador_t *This, uint16_t Freq);void InicializaGerador(Gerador_t *This, uint16_t GPIO);void RodaGerador(Gerador_t *This);//Inicia hardware do microcontrolador:void IniciaSistema(void){ //configura aqui o Timer0 e suas interrupcoes}//Modifica a frequencia do contador:void ModificaFrequencia(Gerador_t *This, uint16_t Freq){ //checa parametros: //estrutura nao existe if(This == (Gerador_t *) 0) return; //valor de frequencia fora do range permitido if(Freq > 0xFFFF) return; //senao, altera a frequencia: This->LimiteFreq_ = Freq;}//Inicializa o gerador:void InicializaGerador(Gerador_t *This, uint16_t GPIO){ //Checa parametros: //ponteiro nulo: if(This == (Gerador_t *) 0) return; //se o ponteiro é valido, entao inicia: //Zera contador: This->ContadorFreq_ = 0; //Frequencia inicial a mais baixa possivel: This->LimiteFreq_ = 0xFFFF; //aponta o GPIO desejado: This->GPIO = GPIO;}//Roda Gerador(chamado somente na interrupcao):void RodaGerador(Gerador_t *This){ //temporario: uint8_t Temp = 0; //Checa se o ponteiro é nulo: if(This == (Gerador_t*) 0) return; //checa se houve overflow do contador: if(This->ContadorFreq_ >= This->LimiteFreq_) { //le o GPIO(no caso do CCS): Temp = Input(This->GPIO); //complementa seu valor: Temp = ((~Temp) & 0xFF); //checa estado e escreve o bit: Temp != 0 ? OutputHigh(This->GPIO) : OutputLow(This->GPIO); //Zera contador se entrou nesse if: This->ContadorFreq_ = 0; } else { //caso contrario nao faz nada }}//Rotina principalvoid main (void){ // inicializa os geradores alocados: InicializaGerador(&Freq1, pin_b0); InicializaGerador(&Freq2, pin_b1); InicializaGerador(&Freq3, pin_b2); //Inicializa seu hardware: IniciaSistema(); //faz uma pre-carga com tres frequencias diferentes: ModificaFrequencia(&Freq1, 100); ModificaFrequencia(&Freq2, 250); ModificaFrequencia(&Freq3, 340); //habilita as interrupcoes: //nao lembro como faz no CCS //loop infinito: while(1) { }}//Sua rotina e interrupcao:void InterrpcaoTimer(void){ //Faca a recarga do timer, como manda o CCS //Aqui voce chama a funcao dos seus geradores: //sao 3 entao chamamos para Fre1,2 e 3: RodaGerador(&Freq1); RodaGerador(&Freq2); RodaGerador(&Freq3); //simples e portavel para outros pics e processadores...} Veja que é um exemplo que falta preencher com informações do PIC, mas isso executa exatamente o que voce quer, e pode ser usado em qualquer microcontrolador. Em caso de duvidas, pergunte! Abs. Felipe

@aphawk, Correto! Como a resolução vertical de um gerador de sinais raramente ultrapassa os 8bits, acho o PWM uma solução que oferece alguma qualidade, além de ser mais barato e fácil de montar do que D/A baseada em string de resistores (sem contar que precisa daquele seguidor de tensão na saída pra não sobrecarregar o D/A). Obviamente ele precisa ser bem projetado, senão o resultado não fica legal, mas pelo que entendi do tópico o que o @fabiano aladin quer é uma simples saida de tensão variável do terminal do PIC, agora pergunto o que esse sinal vai alimentar? Abs.

Peguei o tópico por cima mas vamos, lá conversor D/A de 1bit não compensaria ai senhores? PWM + filtro ativo? é um hardware mais barato e mais fácil de montar, o único problema mesmo são os parâmetros da portadora do PWM do PIC (que não é lá grandes coisas) mas dependendo da largura de banda da pra implementar qualquer forma de onda atraves de uma tabela mapeada em memoria com a forma da função desejada. Irem ler melhor e qualquer coisa edito meu post. Abs.

Método PLL, fácil integração e nao precisa "rezar" para o bicho oscilar... Veja alguma coisa usando o 4046: http://portal.unimap.edu.my:7778/portal/page/portal30/Lecturer%20Notes/KEJURUTERAAN_KOMPUTER/SEM_1_2006_2007/ELECTRONIC_COMMUNICATIONS/PROJECT/PROJECT%201.PDF Abs

Tente com algum general purpose como: PIC18f4550, pic16f887 ou 877a são faceis de achar, e devem funcionar com o mesmo algoritmo. Abs!

Vamos la, pensei em algo assim: #define MAX_STEP 0x08 //constante interna para uso #define MOTOR PORTD //por exemplo motor em RD0 a RD3 //declarei como global para facilitar as coisas static unsigned char g_ucCurrStep = 0; //valor corrente do step void interrupt(void) //sua rotina de interrupçao o melhor resultado e quando ela ocorre a cada 10ms { static unsigned char s_ucStep = 0x01; //variavel de step unsigned char ucTemp = 0; //auxiliar //limpa flag de interrupcao: INTCON &= ~(1<<T0IF); //nao lembro os nomes dos bits é bom corrigir //avanca o motor em 1 step: ucTemp = MOTOR; //le o estado anterior do PORT ucTemp &= 0xF0; //mascara os 4 bits nao usado ucTemp |= s_ucStep; //coloca valor do passo atual em Temp MOTOR = ucTemp; //passa o valor para o PORTD e aciona a bobina sem interferir nos pinos do PORTD que nao sao usados //avanca step para proxima interrupcao: s_ucStep <<= 1; //rotaciona o bit para a proxima bobina if(s_ucStep > MAX_STEP) s_ucStep = 0x01; //checa se ja gerou pulso na ultima bobina, se sim volta para a primeira g_ucCurrStep++; //avanca step corrente TIMER0 = Recarga; //voce deve calcular para cada 1ms } //e aqui a rotina para avanço dos steps void stepGo(unsigned char ucStepDesired) { //habilita interrupção do timer 0 INTCON |= (1<<T0IE); while(ucStepDesired < ucCurrStep); //fica travado ate que o Step desejado seja no minimo igual ao corrente //desliga interrupcao do timer 0 INTCON &= ~(1<<T0IE); } Esse codigo é so pra ida, falta fazer a parte da volta bem como criar os flags de direção e precisa modificar conforme o compilador apesar de ser compativel com o C18 e o MikroC pois sao ANSI... Duvidas, pergunte. Abs

Formigoni, excelente trabalho. Os trancos, são provenientes da falta do micropasso, da pra fazer por software. Leia bem o primeiro algoritmo que te passei, ele simula de forma bem interessante um micropasso e nao da trancos no motor. Mas o caminho é esse...existem métodos mais complexos para geração de micropassos... Veja essa app note: http://www.ti.com/general/docs/lit/getliterature.tsp?baseLiteratureNumber=slva416 Duvidas, va perguntando. Abs.

Driver para LCD 16x2 ou 20x4? Para qual micro? Abs.

Formigoni, a pessoa está certa. Porém a estrutura interna de um pino de I/O de um microcontrolador, ja possui internamente dois push-pull que se combinado em dois I/Os vira uma ponte H com nenhum HW externo, porém so consegue acionar cargas de ate 20mA (com o PIC) e como o motor de cluster drena em torno de 18mA da pra pendurar ele tranquilo no PIC. Quanto ao programa eu acredito que sim pois a sequencia de acionamento vai a ser a mesma no fim das contas. Boa sorte ai, e qualquer duvida va perguntando. Abs

A ideia é bem essa mesmo! Agora tente gerar a sequencia de pulsos que citei no algoritmo, e acredito que teras a melhor solução para comandar motores de passo usados em clusters. Abs.

Formigoni, fiz algo sim, mas utilizando micros ARM, a base do código é a mesma, voce teria apenas que reescrever a parte dos registradores. Ligue no PIC por exemplo Bobina1 A e /A em RB0 e RB1 e Bobina 2 B e /B em RB2 e RB3 Eu utilizo por base o seguinte algoritmo: - Configurar a interrupcao do timer0 para 10ms; - Escolher um port e usar um nibble, no caso escolherei de RB0 a RB3; - RB0 a RB3 --> Saidas; - Carregar em PORTB ou LATB(se for PIC18) inicial 0x01; Aqui termina a inicialização. Agora proceda assim na interrupcao - Limpe o flag de interrupcao - Rotacione o valor de portb, para esquerda (ou direta dependendo do sentido de rotação) - Veja se o mesmo chegou 0x08, se sim reinicie o PORTB escrevendo 0x01; - Repita enquanto quiser girar o motor. Abs.

Mulder, Descontinou, e na minha humilde opiniao mandou para o espaço um dos melhores simuladores de MCU que eu conhecia... O simulador do MPLABX é fraco, possui recursos de interação limitados...fora que a interface mesmo da release é cheia de bugs. E não suporta mais debug pelo ICD2 nem pelo PICKIT2... A unida coisa boa é que ela desenvolveu seus proprios compiladores, e agora prove arquivos startup do assembly para economia de tempo na programação dos fuses por exemplo. Abs

Motores de 4 fios, bipolares são um pouco mais simples. Veja, cada dois polos representam uma bobina, ou seja com um multimetro va medindo os pares usando a escala de resistencia (preferência a de 2K), o par de fios que der um valor de resistencia entre 80 e 200Ohms é uma bobina, separe os pares. Assim, para cada par irao dois sinais A e B, em uma bobina irão A em um fio e /A em outro fio (dois sinais defasados em 180 graus) o mesmo ocorre no B para outra bobina e /B no outro fio da mesma bobina(180 graus) e a defasagem entre os sinais quadrados A e B deve ser de 90 graus...com pulsos de 10ms( para painel de instrumentos tive bons resultados com esse valor). Quanto aos pinos do MCU, pode ligar sim, mas nao esqueça o capacitor de 100n em paralelo com cada bobina para proteger o micro. E veja se a resistencia da bobina esta entre 100 e 200 Ohms...e não teras problemas. Boa sorte. Duvidas, estamos ai

Esses motores bipolares que vem em clusters automotivos possuem uma resistencia de bobina elevadissima! da pra conectar diretamente aos pinos do microcontrolador (que por na tureza ja e uma ponte H) com isso cada lado da bobina vai em um I/O do PIC, ai basta acionar cada uma de forma sequencial, ou seja gerar os pulsos seguintes a cada 90 graus, para inverter o sentido basta inverter a sequencia de geração de pulsos. Fiz testes de acionamento direto com micros da Freescale, e com PIC das referecias 16F877A e 18F452 e funcionou bem legal...com o 629 voce so conseguira acionar um motor ja que ele tem poucos I/O. Duvidas estamos ai. Abs

Com certeza! Vou tentar deixar o mais flexivel possível, porém como quero usar o metodo: "keep simple, stupid!" vou simplificar o máximo possóvel também, ja vou inclusive aproveitar asrotinas de atualização de buffer do algoritmo de averaging que esta no topico de DSP. A butterfly é o núcleo da FFT sem ela fica impossível fazer ela, ai teriamos que usar a DFT que vai limitar pra car****lho a banda do sinal, mas ela não é difícil de compreender, estou simplificando tudo que for possivel e contas mais complexas estou usando uma boa lookup para computar os twiddles. Vou começar a testar no fim da semana e ja posto por aqui os resultados. Abs.

É nisso que estou pensando, quero fazer primeiro em ANSI-C e depois ir ajudando o pessoal a portar para suas linguagens favoritas, no caso do Basic fariamos em conjunto, no caso do CCS que muita gente (ainda) usa poderia fazer com o colega Matheus_LPS, ja para ASM convocar os ilustres vtrx e Mulder_Fox, assim teriamos as FFT simples e em multiplataforma. Vou continuar os estudos. Abs.

Paulo, Cade os sources? Estou modelando a FFT no matlab e gostaria de comparar os códigos, quero ver que mais otimizações sairam dai. A FFT é mais trabalhosa de entender do que de implementar, maaas logo logo solto a brincadeira aqui em C e vou dando o suporte pra gente migrar ela pro Basic. Abs.

edu, inclusive no arquivo main.c deve ser feito um main.h onde o proprio void main é um prototipo de função, estranho né? Mas é assim mesmo. No main.c você inclui sempre o .h também, o header file nada mais é do que o cabeçalho do teu arquivo .c contendo o prototipo das funções e constantes, porém é ele que será usado pelo linker para conectar os diversos modulos do programa. Em todo caso pode-se generalizar: - .C é o código em si e o que ele faz. - .H é o cabeçalho que contem os prototipos e constantes, também usado para proteção do código escondendo assim o .C, outro ponto de vista o .h é para você explicar a um terceiro como é usado o módulo que você escreveu sem ter de mostrar como funciona o algoritmo. Quando digo para compilar a pasta, me refiro a voce antes de dar um build all no seu projeto compile por diretorios, por exemplo no seu driver UART vai ter uma pastinha no seu projeto so dela, ai na IDE voce vai la e compila o .h da UART tendeu? duvidas manda bala. Abs.

Parabéns edu, sugiro a fixação do tópico. Posso dar uma sugestão? Afim de orgarnizar melhor seus códigos e facilitar a vida do compilador na hora de linkar os arquivos, sempre que criares uma biblioteca gere sempre os dois arquivos o .c e o .h No caso de sua UART separe o que é função do que é protótipo isso ajuda na portabilidade de código e na sua compreensão: veja só: no .C coloque: - Todos os includes, inclusive o do seu driver, por exemplo no seu UART.c voce deve incluir o UART.h e depois criar ele - Variaveis globais sim elas ficam no .C -As funções sem os prototipos; ja no .H inclua: - o #ifndef e define que voce fez certinho; - os defines e constantes; - structs e unions; - apenas os prototipos das funções - possíveis externs ao criar os dois arquivos crie uma pastinha so para eles dois e compile a pasta toda, com isso voce ja ativa a função do #ifndef e evita a recompilação desnecessária da biblioteca. dúvidas posta ai, vou acompanhar de perto o tópico, e quanto ao CCS o pessoal que ja viu meus tópicos conhece bem minha opinião sobre ele e porque penso isso. Abs.

Pra funcionar aquele controle de motores no CCS só vejo uma maneira...fazer todo o PID em ASM dentro dele rsrsrsrsr. Abs.

Se você não for preguiçoso, gostar de ler as notas de aplicação da microchip, e gostar de códigos otimizados e com a sua cara, e tiver vontade de escrever seus próprios drivers e bibliotecas e ainda quiser ter menores dificuldades para migrar de microcontrolador um dia (pois eles são ANSI-C, diferente das duas aberrações do mikroC e CCS) as duas opções são sem dúvida a melhor escolha. Mas lembre - se se escolher essas, você terá que ralar, parece meio frustrante no começo, mas pegando - se o jeito você vai sentir na prática a diferença de um compilador C de verdade e mais poderoso. Abs.

Não aguento mais ver gente pedindo esse circuito, como o do jorge ja nem esta mais aqui vou postar esse aqui para se basearem: http://www3.eletronica.org/projetos/interruptor-eletrônico-controlado-por-som é idêntico mas muito simples, usem esse para se basearem e projetem o vocês mesmos! Abs.

Matheus, até da, o ICL7107 é digamos um bombril para fazer medição de grandezas desde que seja corrertamente adaptado. Pra isso ai medir 10A é fácil, em sua entrada precisariamos de um amplificador operacional e uma resistencia shunt de baixo valor como esse circuito aqui: http://imageshack.us/photo/my-images/12/shunt.jpg/sr=1 Claro os resistores R2 e R3 terao de ser modificados para que a escala do amperimetro fique correta. Abs.