Ir ao conteúdo
  • Cadastre-se

Vicente Cesar

Membros Plenos
  • Total de itens

    128
  • Registro em

  • Última visita

  • Qualificações

    0%

Reputação

8

Informações gerais

  • Cidade e Estado
    Minas Gerais/MG
  • Sexo
    Masculino
  1. @MOR , desculpe a demora para responder. A primeira coisa que não entendi foi "Um impulso elétrico (na prática um pulso) possui infinito número de frequências possíveis (na teoria)". Nuca ouvi falar sobre isso, poderia me explicar o que quis dizer ou algum link sobre ? A segunda duvida que tenho é que a corrente, na teoria sairia do ponto positivo e iria para o negativo, então como funciona essa realimentação que faz o sinal voltar para entrada ? Talvez esteja esquecendo de algum conceito, mas não consigo entender como funciona esse fluxo da corrente elétrica nos osciladores. E o que são esses "pontos limites" que você citou ? Se forem muitas duvidas para responder já ajuda um link simples para que está começando a entender do assunto haha
  2. Tenho um Kit de desenvolvimento com um FPGA Altera da família Cyclone II modelo EP2C5 e olhando o datasheet do componente vi que este possui suporte a dois PLL. O kit trabalha com um cristal oscilador de 20 MHz e quero multiplicar este clock por 2 para usar em um gerador de vídeo VGA que trabalha a 40 MHz. porém não consigo achar informações de como usar este recurso do meu FPGA. Procurei na internet com gerar códigos em VHDL que usam esse recurso mas não encontrei algo que eu entendesse. Alguém saberia como me ajudar ? Obrigado.
  3. Estou começando a estudar circuitos RF e algo muito importante que tenho visto nesta área são os osciladores, porém não consigo entende-los direito. Já estudei sobre como fazer circuitos LC oscilarem, mas vi que essa oscilação vai diminuindo até parar e então seria necessário uma realimentação e amplificação do sinal. Eu não consegui entender bem como funciona isso, já li em alguns lugares sobre a teoria mas não consigo relaciona-la com a pratica. Se alguém puder me ajudar com uma maneira bem simples de entender a realimentação e como implementa-la agradeço. ~~ Vicente
  4. @vtrx, eu já comecei estudar a BIOS e suas interrupções, e já fiz o carregamento do 'kernel' do sistema que eu programei em assembly. Ele está em modo de 32 Bits. O que quero mesmo é só integrar uma linguagem de alto nível no sistema. Estou procurando algo como o @aphawk falou, um C sem dependências do ambiente em tempo de execução. Ouvi falar em algo chamado "Crosscompiler", que é um compilador para gerar o código para uma plataforma diferente da que ele está, mas não consegui fazer funcionar ainda. Obrigado.
  5. @aphawk, @vtrx, @victhor393. Fiquei um bom tempo sem responder o tópico , mas neste tempo continuei o estudo da linguagem Assembly (Principalmente para rodar em um computador sem um sistema operacional). Porém acabei me deparando com um problema que espero que possam me ajudar. Eu programei um BootLoader para carregar um programa em C, ao invés de um em Assembly, porém descobri que precisaria de um Biblioteca Runtime, pois quando compilo um programa em C ou C++ no windows, o programa em C ou C++ tem fortes dependências com o windows, mesmo não usando nenhuma biblioteca. Queria saber se vocês saberiam como eu posso desenvolver programas em C sem nenhuma dependência com o windows. Também quero saber se seria mais difícil desenvolver esse tipo de programa em C ou C++. Agradeceria se dessem preferência a materiais que não são desenvolvidos com o Microsoft Visual C++, pois a sintaxe que ele usa sempre gera erros nos compiladores que uso, e não consigo resolver estes problemas. Obrigado.
  6. Olá pessoa, eu queria criar uma janela no windows de maneira que fosse uma janela "Crua", onde eu pudesse preencher qualquer um de seus pixels, mas quero fazer as chamadas diretamente do sistema (Até onde eu sei faria isso através das DLL do windows) ao invés de usa algumas bibliotecas gráficas 2D. Alguem poderia me ajudar com isso ? Obrigadi.
  7. @vtrx, entendi, é que sou muito iniciante na programação de baixo nível, mas vou tentar. Procurei a saber e descobri que meu Notebook é x64 e pelo que eu pesquisei isso significa 64 bits e x 86 32 bits. Então, eu poderia rodar instruções x86 em um processador x64 ? @victhor393 Estarei tentando fazer um programa seguindo as dicas de você e ver se ele vai rodar dessa vez.
  8. @victhor393 Procurei sobre o que são as instruções SSE e MMX que são as que meu processador possui de acordo com umas paginas que encontrei na net, porém todos falam para procurar o manual do meu processador no site da AMD, mas não acho nada sobre o AMD E1-1500 APU. Meu problema estar em por onde começar. @vtrx O link que você sitou não serve para meu processador mais vou dar uma olhada.
  9. @victhor393 Você conhece algum site ou livro que trata sobre o assunto de programação em assembly com e sem o S.O ?
  10. @vtrx, em primeiro lugar estou programando em assembly para estudar mesmo, quero entender como uma linguagem de programação que conversa diretamente com o hardware funciona sendo que tem um sistema operacional dizendo o que você "pode ou não fazer". Quanto aos programas que ficaram lentos, um exemplo, é um visualizador de imagem que eu fiz em C que escondia mensagens na imagem (Esteganografia). Depois ele jogava as imagens na tela para mim comparar se a distorção ficou muito grande. Só para imprimir a imagem na tela levava quase um minuto dependendo do tamanho da imagem. No caso eu lia os valores hexadecimais da imagem para fazer isso, não usava uma biblioteca que manipulava imagens daquele formato. Então comecei a estudar mais C e também assembly para ver o que poderia fazer. Mas mesmo que tenha soluções mais simples ainda quero aprender mais sobre assembly no meu tempo livre.
  11. @pdanobre Já vi este sim. Seguindo esse não consegui criar o link do arquivo objeto. Apareceu os seguintes erros: 1: Error: Parser: instruction expected 2: Error: laberl or instruction expected at start of line Imagino que esses números sejam as linhas dos erros. Mas como nunca fim um programa em assembly para processadores não sei onde errei. O código esta exatamente igual. se souber como me ajudar agradeço. @vtrx Já programo em C e em java, mas essas linguagens tem funções "Lentas" para o programas que estou desenvolvendo. Então estou começando a estudar as de baixo nivel.
  12. Não sei se essa é a melhor área do fórum para minha duvida, mas acho que poderão me ajudar aqui. Estou querendo usar assembly para fazer programas que rodem no meu notebook. Ele possui um processador AMD E1, e na internet não estou conseguindo achar por onde começar. Queria saber se alguém pode me ajudar a descobrir por onde começar. O máximo que consegui fazer foi criar um arquivo objeto de um código que achei na internet. Obrigado.
  13. Como estou aprendendo assembly resolvi fazer todos meus códigos em assembly para treinar e deixa-los mais rápidos. Porém, como não tenho muita experiencia estou tendo algumas dificuldades. Alguns erros consegui identificar mas não consegui corrigi-los, então queria saber se poderiam me orientar. OBS1: o código se trata da comunicação de uma manete de playstation 2 com o pic (O código em C funciona perfeitamente, apenas o em assembly se encontra com problemas. Fonte do código em C : Robotizando.com) Observação2: Não é por preguiça que estou pedindo ajuda, já estou no terceiro dia agarrado nesse código, acho que é mais pela minha falta de experiencia. Primeiro, os problemas que identifiquei. "PRINCIPAL ;GOTO PRINCIPAL para voltar a esse ponto do programa CALL LER_CONTROLE BTFSC BEYTE2,2 CALL L_STATUS BTFSS BEYTE2,2 CALL L_ERRO GOTO PRINCIPAL L_STATUS BSF LED_STATUS BCF LED_ERRO RETURN L_ERRO BCF LED_STATUS BSF LED_ERRO RETURN" Chamei de led_status o led que acende quando um botão da manete é pressionado e led_erro o led que acende quando nada é pressionado. O depurador mostra que o código funciona, mas ao testar o codigo no Microcontrolador, apenas o led_status acendia, independente do que eu apertasse. (Aparentemente esta apresentando comportamento contrário ao que foi programado, pois o led_erro deveria acender quando nada fosse apertado). O BEYTE2,2 é onde esta salvo o valor 1 ou zero para o botão L1, se zero não foi pressionado se 1, foi pressionado. BCF BEYTE6,CONT_BIT ; Zero Cont_bit é um contador que conta de 0 a 7, o objetivo era gravar cada bit da variável Beyte6, porém apenas o bit 2 esta sendo alterado, independente do valor do contador (Vi isso através do depurado do MPLAB). Como o código em C funcionou, acho que o problema não seja no hardware. Agora os códigos completos: Em C: //----------------------------------------------------- // CONTROLE PLAYSTATION // Essa biblioteca possui funções para ler o estado do controle // de playstation // // Alterações em: // // 01/04/2007 23:30 - Preparação da versão 1.0 - somente funcionalidades básicas // 05/12/2007 02:45 - versão 1.0 - primeira versão funcional // 14/01/2009 01:10 - Adição de descrição de sinais //----------------------------------------------------- //----------------------------------------------------- // Descritivo das cores da fiação do controle PS // Clock = Azul // Data = Marrom - Atenção! Esse sinal precisa de Pull Up (1K) // Command = Laranja // Att = Amarelo // Vcc = Vermelho // Gnd = Preto // Force Feed Back = Cinza (não implementado ainda) //----------------------------------------------------- //Pinos onde o controle está conectado #define cmd PIN_B7 #define att PIN_B6 #define clk PIN_B5 #define dado PIN_B4 //Tempos em micro-segundos (us) #define tempoInicio 40 #define tempoClk 40 #define tempoEntreByte 40 #define tempoEntreCiclo 20 //ms int psxDado[6]; //Buffer do controle int psxDadoAnt[6]; //Buffer do controle int1 psxMudou; //Botões do Controle int1 btnSelect = 0; int1 btnJoyE = 0; int1 btnJoyD = 0; int1 btnStart = 0; int1 btnUp = 0; int1 btnDown = 0; int1 btnLeft = 0; int1 btnRight = 0; int1 btnL1 = 0; int1 btnL2 = 0; int1 btnR1 = 0; int1 btnR2 = 0; int1 btnTriangulo = 0; int1 btnBola = 0; int1 btnQuadrado = 0; int1 btnXis = 0; int X_Left=0; int Y_Left=0; int X_Right=0; int Y_Right=0; int centro_x_right = 0; int centro_y_right = 0; int centro_x_left = 0; int centro_y_left = 0; int psxCont; //contador genérico // ---------------------------------------------------- // psxLeByte - Captura um byte, enviado pelo controle através do pino DADO // ---------------------------------------------------- int psxLeByte() { int aux=0; int c; for(c=0;c<=7;c++) //Passa por todos os bits da variável psxByte { output_bit(clk,false); //baixa o clock, isso faz com que o controle disponibilize o dado no pino "dado" delay_us(tempoClk); //invertido para representar a realidade do controle if(INPUT(dado)==1) bit_clear(aux, c); else bit_set(aux, c); output_bit(clk,true); //Sobe o clock } delay_us(tempoEntreByte); return (aux); } // ---------------------------------------------------- // psxGravaByte - Escreve um byte, enviado pelo controle através do pino CMD // ---------------------------------------------------- void psxGravaByte(int byteDado) { int c; for(c=0;c<=7;c++) //Passa por todos os bits da variável psxByte { //Sobe ou desce o pino de acordo com cada bit da variável psByte //significa que estamos enviando o comando 0x01h para o controle if(bit_test(byteDado,c)) output_bit(cmd,true); else output_bit(cmd,false); output_bit(clk,false); //depois de setar o pino, manda clock para o controle delay_us(tempoClk); //aguarda um tempinho... output_bit(clk,true); //sobe clock... NOTA: clock sensível a borda de descida } output_bit(cmd,true); //sobe comando para sinalizar delay_us(tempoEntreByte); //espera um tempinho entre um byte e outro } // --------------------------------------------------------------------------- // psxCopiaDado - copia buffer atual para anterior // --------------------------------------------------------------------------- void psxCopiaDado() { int i; for(i=0;i<6;i++) psxDadoAnt = psxDado; } // --------------------------------------------------------------------------- // psxComparaDado - Compara leitura anterior com a atual // --------------------------------------------------------------------------- boolean psxComparaDado() { int j; for(j=0;j<6;j++) { if(psxDadoAnt[j]!=psxDado[j]) return (1); } return (0); } // --------------------------------------------------------------------------- // psxAtualizaVariaveis - converte buffer de leitura para variaveis discretas // --------------------------------------------------------------------------- void psxAtualizaVariaveis() { if((psxDado[0] & 1) == 1) btnSelect = 1; else btnSelect = 0; if((psxDado[0] & 2) == 2) btnJoyE = 1; else btnJoyE = 0; if((psxDado[0] & 4) == 4) btnJoyD = 1; else btnJoyD = 0; if((psxDado[0] & 8) == 8) btnStart = 1; else btnStart = 0; if((psxDado[0] & 16) == 16) btnUp = 1; else btnUp = 0; if((psxDado[0] & 32) == 32) btnRight = 1; else btnRight = 0; if((psxDado[0] & 64) == 64) btnDown = 1; else btnDown = 0; if((psxDado[0] & 128) == 128) btnLeft = 1; else btnLeft = 0; if((psxDado[1] & 1) == 1) btnL2 = 1; else btnL2 = 0; if((psxDado[1] & 2) == 2) btnR2 = 1; else btnR2 = 0; if((psxDado[1] & 4) == 4) btnL1 = 1; else btnL1 = 0; if((psxDado[1] & 8) == 8) btnR1 = 1; else btnR1 = 0; if((psxDado[1] & 16) == 16) btnTriangulo = 1; else btnTriangulo = 0; if((psxDado[1] & 32) == 32) btnQuadrado = 1; else btnQuadrado = 0; if((psxDado[1] & 64) == 64) btnXis = 1; else btnXis = 0; if((psxDado[1] & 128) == 128) btnBola = 1; else btnBola = 0; x_right = psxDado[2]; y_right = psxDado[3]; x_Left = psxDado[4]; y_Left = psxDado[5]; } // ---------------------------------------------------- // psxLeControle - Executa a leitura do controle de playstation // ---------------------------------------------------- void psxLeControle() { int psxByte = 0; output_bit(cmd,true); //sobe comando output_bit(clk,true); //sobe clock output_bit(att,false); //att em low - habilita o joystick delay_us(tempoInicio); //aguarda o controle entender o att em low //Envia o primeiro byte para o controle - 0x01 psxByte = 1; psxGravaByte(psxByte); //Envia o segundo byte para o controle - 0x42h psxByte = 66; psxGravaByte(psxByte); //Envia o terceiro byte para o controle - 0x00 psxByte = 0; psxGravaByte(psxByte); //Recupera os 6 próximo bytes for(psxCont=0; psxCont<6; psxCont++) psxDado[psxCont] = psxLeByte(); //Volta o att para alto... libera o controle indicando que ele pode parar de enviar dados output_bit(att,true); //Compara com a variável anterior e verifica se será //necessário atualizar as variaveis discretas if(psxComparaDado()==1) { psxAtualizaVariaveis(); psxMudou = true; } else psxMudou = false; psxCopiaDado(); } Minha versão em assembly: #INCLUDE <P16F628A.INC> __CONFIG _HS_OSC & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _BOREN_OFF & _LVP_OFF & _CP_OFF & DATA_CP_OFF ;Paginação de mesmoria #DEFINE BANCO_0 BCF STATUS,RP0 ; BCF deixa um bit igual a 0 #DEFINE BANCO_1 BSF STATUS,RP0 ; BSF deixa um bit igual a 1 #DEFINE LED_STATUS PORTA,2 ;Led associado ao Port A Pino 0 #DEFINE LED_ERRO PORTA,3 ;Led associado ao Port A Pino 0 #DEFINE _DATA PORTB,4 #DEFINE _CLOCK PORTB,5 #DEFINE _ATT PORTB,6 #DEFINE _CMD PORTB,7 CBLOCK 0X20 ; Endereço inicial da memoria do banco a ser usada BYTE_DADO CONT CONT_BIT C_US BEYTE1 BEYTE2 BEYTE3 BEYTE4 BEYTE5 BEYTE6 ENDC ORG 0X00 ;Onde a proxima proxima instrução sera gravada GOTO INICIO ;Devia para inicio ORG 0x04 RETFIE ;Se ocorrer alguma interrupção, o programa retona onde ouve a interrupção INICIO ; 1 - Entrada 0 - Saida BANCO_1 MOVLW B'11110011' MOVWF TRISA MOVLW B'00011111' MOVWF TRISB BANCO_0 MOVLW B'00000111' MOVWF CMCON MOVLW B'00000000' MOVWF CONT_BIT MOVLW B'00000000' MOVWF BYTE_DADO MOVLW B'00000000' MOVWF PORTA MOVLW B'00000000' MOVWF PORTB MOVLW B'00000000' MOVWF BEYTE1 MOVLW B'00000000' MOVWF BEYTE2 MOVLW B'00000000' MOVWF BEYTE3 MOVLW B'00000000' MOVWF BEYTE4 MOVLW B'00000000' MOVWF BEYTE5 MOVLW B'00000000' MOVWF BEYTE6 PRINCIPAL ;GOTO PRINCIPAL para voltar a esse ponto do programa CALL LER_CONTROLE BTFSC BEYTE2,2 CALL L_STATUS BTFSS BEYTE2,2 CALL L_ERRO GOTO PRINCIPAL L_STATUS BSF LED_STATUS BCF LED_ERRO RETURN L_ERRO BCF LED_STATUS BSF LED_ERRO RETURN GRAVAR_BEYTE MOVLW B'00001001' MOVWF CONT MOVLW B'00000000' MOVWF CONT_BIT RETORNO_GRAVAR_BIT DECFSZ CONT GOTO GRAVAR_BIT BSF _CMD MOVLW .38 CALL TIMER RETURN GRAVAR_BIT BTFSS BYTE_DADO,CONT_BIT ;SE == 1 Pula linha abaixo BCF _CMD ; Zero BTFSC BYTE_DADO,CONT_BIT ;SE == 0 Pula linha abaixo BSF _CMD ; Um BCF _CLOCK MOVLW .38 CALL TIMER BSF _CLOCK MOVLW B'00000001' ADDWF CONT_BIT GOTO RETORNO_GRAVAR_BIT LER_BYTE MOVLW B'00001001' MOVWF CONT MOVLW B'00000000' MOVWF CONT_BIT RETORNO_LER_BIT DECFSZ CONT GOTO LER_BIT MOVLW .38 CALL TIMER RETURN ;BCF Zera um bit LER_BIT BCF _CLOCK MOVLW .38 CALL TIMER BTFSS _DATA ;SE == 1 Pula linha abaixo BCF BEYTE6,CONT_BIT ; Zero BTFSC _DATA ;SE == 0 Pula linha abaixo BSF BEYTE6,CONT_BIT ; Um BSF _CLOCK MOVLW B'00000001' ADDWF CONT_BIT GOTO RETORNO_LER_BIT LER_CONTROLE BSF _CMD BSF _CLOCK BCF _ATT MOVLW .38 CALL TIMER MOVLW .1 MOVWF BYTE_DADO CALL GRAVAR_BEYTE MOVLW .66 MOVWF BYTE_DADO CALL GRAVAR_BEYTE MOVLW .0 MOVWF BYTE_DADO CALL GRAVAR_BEYTE CALL LER_BYTE MOVFW BEYTE6 MOVWF BEYTE1 CALL LER_BYTE MOVFW BEYTE6 MOVWF BEYTE2 CALL LER_BYTE MOVFW BEYTE6 MOVWF BEYTE3 CALL LER_BYTE MOVFW BEYTE6 MOVWF BEYTE4 CALL LER_BYTE MOVFW BEYTE6 MOVWF BEYTE5 CALL LER_BYTE BSF _ATT RETURN TIMER NOP MOVWF C_US DECFSZ C_US GOTO $-1 RETURN END
  14. @MOR, eu ainda não entendo muito de Assembly, o que são macros ? E o que a instrução endm faz ? @vtrx Obrigado pela ajuda. Agora uma duvida, quais são as funcionalidades do registrador STATUS ? Eu o vi nos códigos que vocês passaram, mas ainda não entendi bem como ele funciona.
  15. Existe alguma instrução que compare dois bytes no PIC e alguma que compare dois bits ? Esses bytes e bits estão armazenados em variáveis diferente. Estou usando o PIC16F628A. Tentei olhar o set de instruções desse PIC, mas não consegui entende-lo muito bem, então não achei o que queria. Alguém poderia me ajudar ? OBS: Quero algo que me diga se esse dois bytes ou bits são iguais ou diferentes.

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×