Tarcisio Zewe Duarte

Bom dia Eu tenho um celular Samsung J1 Mini, o qual eu troquei o display em junho deste ano, pois o mesmo havia quebrado. O display é de boa qualidade, comprei numa loja especializada, e até então ele esta funcionando bem, mas de uns tempos pra cá ele começou com um problema esquisito, a imagem no canto direito as vezes fica distorcida / tremida, chegando a tomar quase metade da tela, algo como se fosse um problema de sincronismo no display. Este defeito é bem intermitente, as vezes ele aparece, chega ficar um ou dois dias, depois a tela volta por mais de uma semana, e novamente o defeito aparece. Alguém poderia me dar a respeito desse problema?

Estou querendo gravar alguns caracteres matriciais no formato 5X7, num circuito integrado EEPROM, utilizando um gravador K150, para posteriormente fazer a leitura deste conteúdo gravado com um PIC, u ma vez que o modelo que eu tenho aqui, a sua memória RAM não suporta estes caracteres, devido a baixa capacidade da mesma, e por isso gostaria de saber se isto é possível?

@Andreas Karl Obrigado por sua resposta!

O que é um amplificador com terra suspenso, e porque ele reduz os ruídos nele?

@Shaman93 Muito obrigado pela resposta!

Percebi que na década de 90, alguns PC's vinham com um com um display de 7 segmentos de LEDs, no painel frontal do gabinete, e sempre tive a curiosidade de saber qual era a sua finalidade, e por que ele não é mais utilizado hoje em dia.

@aphawk Eu normalmente faço na JLCPCB. Só pra você ter uma ideia, enquanto lá eu faço 5 placas de 4cm x 27cm por 90,00 reais, aqui no Brasil as empresas me cobraram 500, 700 ou até mesmo 1000,00 reais para fazer apenas uma única placa dessa.

Se a placa for pequena e simples, até da pra encarar um roreamento manual, mas numa complexa, por exemplo com circuitos integrados com mais de 40 pinos, é loucura. Demora demais, além da grande chance de se cometer erros. Você manda fazer tuas placas aqui no Brasil, ou na China? adicionado 1 minuto depois @aphawk Se a placa for pequena e simples, até da pra encarar um roreamento manual, mas numa complexa, por exemplo com circuitos integrados com mais de 40 pinos, é loucura. Demora demais, além da grande chance de se cometer erros. Você manda fazer tuas placas aqui no Brasil, ou na China?

@aphawk A faculdade te ensina muito pouco pra falar bem a verdade, eu tenho formação superior em Design Pleno, e sei bem como isto funciona. Você costumava fazer as trilhas das tuas placas maualmente, ou usava o roteamento automático?

@aphawk O Proteus é um baita programa para fazer placas, nunca vi outro melhor. A quem não goste dele, mas ele é melhor que o EASY EDA e o Altium. Além dele, tem outro que gosto bastante também, e também tenho um demo aqui, que é é o Microwind, o qual é um software para projetar circuitos integrados, mas por ser somente um demo, tem um monte de recursos dele que não d pra utilizar. Tenho formação em Elétrotécnica e Eletrônica, mas atualmente este não é meu "ganha pão", mesmo assim, nunca abandonei esta área, sempre estou fazendo alguma coisa nela, sou um autodidata.

@aphawk Entendo adicionado 3 minutos depois @aphawk Você é a primeira pessoa que vejo defender, ou pelo menos sugerir "pagar para utilizar um software", enquanto todo mundo está preocupado em 'crackear' e utilizar os programas livremente e de forma gratuita... hahaha

@aphawk Pois é, eu pesquisei sobre isto ontem na internet, e li algo semelhante á isto. Mas o fato é que fiz um teste aqui, abri um programa que ja havia feito há um tempo, que era bem maior do que este, e ele compilou tranquilo, mas este que eu fiz estes dias não.

// =============================================================================== // --- Mapeamento de Hardware --- #define clockPin RB4_bit #define dataPin RB5_bit #define latchPin RB6_bit ///////////////////// #define MAX 20 // =============================================================================== // --- Variáveis Globais --- // --- Mapa de Caractéres --- const char DOIS_PONTOS[7][6] = {{0, 0, 0, 0, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 0, 0, 0, 0}}; const char ESP[7][6] = {{0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}}; const char ZERO[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 1, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 1, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}}; const char UM[7][6] = {{0, 0, 1, 0, 0, 0}, {0, 1, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 1, 1, 1, 0, 0}}; const char DOIS[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 1, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}}; const char TRES[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}, {0, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}}; const char QUATRO[7][6] = {{0, 0, 0, 1, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 1, 0, 1, 0, 0}, {1, 0, 0, 1, 0, 0}, {1, 1, 1, 1, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 0, 1, 0, 0}}; const char CINCO[7][6] = {{1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 0, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}}; const char SEIS[7][6] = {{0, 0, 1, 1, 0, 0}, {0, 1, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}}; const char SETE[7][6] = {{1, 1, 1, 1, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}}; const char OITO[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}}; const char NOVE[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 1, 1, 0, 0, 0}}; const char LETRA_A[7][6] = {{0, 0, 1, 0, 0, 0}, {0, 1 ,0, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}}; const char LETRA_B[7][6] = {{1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 0, 0}}; const char LETRA_C[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}}; const char LETRA_D[7][6] = {{1, 1, 1, 0, 0, 0}, {1, 0, 0, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 1, 0, 0}, {1, 1, 1, 0, 0, 0}}; const char LETRA_E[7][6] = {{1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}}; const char LETRA_F[7][6] = {{1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}}; const char LETRA_G[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 1, 1, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}}; const char LETRA_H[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}}; const char LETRA_I[7][6] = {{0, 1, 1, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 1, 1, 1, 0, 0}}; const char LETRA_J[7][6] = {{0, 0, 1, 1, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 0, 1, 0, 0}, {1, 0, 0, 1, 0, 0}, {0, 1, 1, 0, 0, 0}}; const char LETRA_K[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 1, 0, 0}, {1, 0, 1, 0, 0, 0}, {1, 1, 0, 0, 0, 0}, {1, 0, 1, 0, 0, 0}, {1, 0, 0, 1, 0, 0}, {1, 0, 0, 0, 1, 0}}; const char LETRA_L[7][6] = {{1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}}; const char LETRA_M[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 1, 0, 1, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}}; const char LETRA_N[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 0, 0, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 0, 0, 1, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}}; const char LETRA_O[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}}; const char LETRA_P[7][6] = {{1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}}; const char LETRA_Q[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 0, 0, 1, 0, 0}, {0, 1, 1, 0, 1, 0}}; const char LETRA_R[7][6] = {{1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 0, 0}, {1, 0, 1, 0, 0, 0}, {1, 0, 0, 1, 0, 0}, {1, 0, 0, 0, 1, 0}}; const char LETRA_S[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 0, 0}, {0, 1, 1, 1, 0, 0}, {0, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}}; const char LETRA_T[7][6] = {{1, 1, 1, 1, 1, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}}; const char LETRA_U[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}}; const char LETRA_V[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}}; const char LETRA_W[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 0, 1, 0, 1, 0}, {0, 1, 0, 1, 0, 0}}; const char LETRA_X[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 1, 0, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}}; const char LETRA_Y[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}}; const char LETRA_Z[7][6] = {{1, 1, 1, 1, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 1, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}}; // -------------------------- char mascara_2[80][7]; int k, l, m, o, lin, col, novacoluna, linha, coluna; void Caracteres(char frase[MAX+1]) { int t = 0; int i, j; int inicio = 0; int fim = 5; while(frase[t] != '\0') { switch(frase[t]) { case ' ': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = ESP[j][i - inicio]; } } break; case '0': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = ZERO[j][i - inicio]; } } break; case '1': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = UM[j][i - inicio]; } } case '2': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = DOIS[j][i - inicio]; } } break; case '3': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = TRES[j][i - inicio]; } } break; case '4': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = QUATRO[j][i - inicio]; } } break; case '5': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = CINCO[j][i - inicio]; } } break; case '6': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = SEIS[j][i - inicio]; } } break; case '7': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = SETE[j][i - inicio]; } } break; case '8': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = OITO[j][i - inicio]; } } break; case '9': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = NOVE[j][i - inicio]; } } break; case 'A': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_A[j][i - inicio]; } } break; case 'B': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_B[j][i - inicio]; } } break; case 'C': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_C[j][i - inicio]; } } break; case 'D': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_D[j][i - inicio]; } } break; case 'E': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_E[j][i - inicio]; } } break; case 'F': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_F[j][i - inicio]; } } break; case 'G': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_G[j][i - inicio]; } } break; case 'H': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_H[j][i - inicio]; } } break; case 'I': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_I[j][i - inicio]; } } break; case 'J': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_J[j][i - inicio]; } } break; case 'K': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_K[j][i - inicio]; } } break; case 'L': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_L[j][i - inicio]; } } break; case 'M': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_M[j][i - inicio]; } } break; case 'N': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_N[j][i - inicio]; } } break; case 'O': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_O[j][i - inicio]; } } break; case 'P': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_P[j][i - inicio]; } } break; case 'Q': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_Q[j][i - inicio]; } } break; case 'R': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_R[j][i - inicio]; } } break; case 'S': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_S[j][i - inicio]; } } break; case 'T': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_T[j][i - inicio]; } } break; case 'U': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_U[j][i - inicio]; } } break; case 'V': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_V[j][i - inicio]; } } break; case 'W': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_W[j][i - inicio]; } } case 'X': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_X[j][i - inicio]; } } break; case 'Y': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_Y[j][i - inicio]; } } break; case 'Z': for (j = 0; j <= 6; j++) { for (i = inicio; i <= fim; i++) { mascara_2[i][j] = LETRA_Z[j][i - inicio]; } } break; } inicio = inicio + 6; fim = fim + 6; ++t; } } void LimpaMatriz() { for (k = 0; k <= 6; k++) { for (l = 0; l <= 79; l++) { mascara_2[k][l] = 0; } } } void escreveMatriz() { bit pinState; char row = 0B1000000; for (linha = 0; linha <= 6; linha++) { latchPin = 0; for (coluna = 79; coluna >= 0; coluna--) { if (mascara_2[coluna][linha] == 1) { dataPin = 1; // Turn on this led } else { dataPin = 0; // Turn off this led } clockPin = 0; clockPin = 1; clockPin = 0; } for (o = 0; o <= 6; o++) { if ( row & (1 << o) ) { pinState = 0; } else { pinState = 1; } dataPin = pinState; clockPin = 0; clockPin = 1; clockPin = 0; } latchPin = 1; row = row >> 1; } } void interrupt() { //função reservada da interrupção if(TMR0IF_bit) //ocorreu overflow do Timer0? { //sim TMR0IF_bit = 0x00; //limpa flag TMR0IF escreveMatriz(); } } void main() { CMCON = 0x07; //desabilita os comparadores internos INTCON = 0xE0; //habilita interrupção global, por periférico, e do Timer0 T0CON = 0xC8; //prescaler 1:1 para o Timer0 TRISB = 0x00; //Configura o PORTB como saída PORTB = 0x00; //Inicializa o PORTB em 0 LimpaMatriz(); while(1) { Caracteres("OLA MUNDO"); } } Boa noite Estou tentando escrever um códico em C no Mikroc para um circuito integrado PIC 18F4550. Ao compilar o código, ele compila normalmente, quer dizer não aponta nenhum erro para nenhuma linha, mas no final aparece a fease "Demo Limit", e não é gerado o arquivo hexadecimal para gravação. Alguém sabe o que signica isso, e por que o compilador está agindo desta forma?

adicionado 1 minuto depois Exatamente, para que ocorra a realimentação não é necessário a presença de um elemento armazenador de energia, mas para as oscilções sim.

@aphawk Paulo no caso estávamos nos referindo há uma situação hipotética, simplesmente para ilustrar que emborara a realimentação positiva num circuito contribua, apenas a existência dela, não o faz o oscilar. Óbviamente ninguém quer um amplificador desta forma, e a realimentação positiva como você mesmo disse, a realimentação positiva deve ser evitada ao máximo, pois do contrário você terá uma histerése, e o circuito deirxará de ser um amplificador e se tornará um circuito lógico digital, como um shimitt trigger, flip flop ou até mesmo uma célula de memória RAM. Embora na prática, em alguns casos, por erro de projeto um amplificador possa vir se comportar de ral forma, produzindo distorções. adicionado 5 minutos depois @aphawk Sei que muitos poderão dizer "eles estão saindo do foco da pergunta" mas a vida é a assim mesmo, um assunto vai puxando o outro, e aqui é um fórum de discução, não uma palestra ou um texto formal. E acredito que ainda estejamos dentro do tema. kkkk

@MOR Sim, de fato a realimentação positiva contribui para aque as oscilações ocorram, mas apenas ela, sem a presença de um elemento que armazene energia no elo de realimentação, de forma a interrompe-la e reestabelece-la periódicamente, um circuito nunca irá produzir oscilações . No caso de um circuito analógico, como um amplificador por exemplo, onde não exista um elemento armazenador de energia, neste caso, a realimentação positiva, fará com que ele apenas tenha um caminho alternativo para os elétrons da base, o qual reforçará sua polarização, aumentando a corrente de coletor, e por consequência o seu ganho, saindo o mesmo do seu ponto quiescente, indo próximo à região de saturaçào, ou atingindo a mesma, mas sem a presença de um elemento que armazene energia neste elo de realimentação, ele ficará assim, preso neste estado, sem ter modificação no sinal de saída ao longo do tempo. Óbviente este circuito amplificador não irá prestar, pois estando próximo da saturação, ele irá promover distorçào harmônica em um sinal aplicado em sua entrada, haja vista que o transistor irá atigir a saturação antes do tempo, em relação à onda que for aplicada à entrada, ceifando-a.

@aphawk Isto é verdade, ao longo da minha vida tentei fazer na louca alguns osciladores só por brincadeira, com o resistor de polarização de base de 1M, e em paralelo com um capacitor, com o mesmo ligado ao coletor, em série com um led e um resistor de 560 , ele se tornou um ciruito oscilador meio que "temperamental", e funcionova quando ele queria, e meio "male má"... Da umas osciladas de vez em quando e em frequências aleatórias, ora o led piscava mais rápido, ora mais devagar. Uma outra vez tentei reproduzir oscoladores com portas lógicas cmos dos chips de circuitos integrados digitais, com transistores mosfets do canal N e P discretos, usei vários modelos, como os IRF e IRFP, o ZVN2106A e o ZVP2106A, e nécas, o circuito não ganhou vida. Em contra partida já montei diversos osciladores, que pegiei os esquemas na internet, livros, revistas, apostilas, inclusive o por desvio de fase que você falou, osciladores em anel, osciladores astáveis com transistores discretos tbj's e mosfet's, com chips 555, 40106, e 4011, onde funcionaram perfeitamente. Mas o que eu pude perceber em todos estes anos, o que as vezes pode parecer óbvio, é que todo oscilador precisa de um elemento que armazene energia, seja um indutor, capacitor, cristal ou combinação destes componentes, sem eles acho que seria impossivel um transistor tbj oscilar kkkkk. Mas o do tipo mosfet, por possuir a sua porta de entrada, isolada do semicondutor por uma camada de óxido, forma uma espécie de capacitor, e em alguns casos consegue oscilar sózinho, sem o uso de um elemento especifico para armazenar energia, pois sua própria porta faz isto, como em alguns projetos de osciladorez em anel cmos que já vi, mas na maioria são projetos experimentais, pois qualuer campo elétrico por perto, altera e desanda o funcionamento do circuito. adicionado 5 minutos depois Mas acredito que nos casos dos transistores bipolares de junção, a realimentação positiva, sem um elemento que armazene energia, não gera nenhuma oscilação, ela apenas regenera o circuito e produz no mesmo uma histerese, como num shimitt trigger ou flip flop, igual ocorre num diodo tiristor, triac, scr, que equivalem a dois transistores NPN e PNP se realimetando positivamente, mutuamente.

@aphawk Já vi um artigo numa revista de eletrônica bem antiga (se não me engano de 1972) que dizia à respeito da utilização de uma lâmpada incandescente para estabilizar o oscilador como você falou. Mas ela em si não era responsável pelas oscilações própriamente ditas do circuito, estava ali apenas para estabilizá-lo, o responsável pelas oscilações era um circuito tanque formado por uma rede RC em duplo T. Acho que para oscilações ocorrem, é nescessario um componente que mude a fase (o sentido do fluxo de elétrons) ou a amplitude do meso, tais componentes são o inditor, o capacitor e o cristal. Um transistor tbj, um diodo tunel ou tristor, ou ainda uma lâmpada neon não é capaz de oscilar sózinho sem a presença destes três componentes. Uma vez também li à respeito que resistores podem provocar oscilações parasitas, chamadas de "ruido térmico", pois em um dado momento ele pode aquecer pela passagem da corrente, o que provoca agitação térmica, afastando seus átomos entre si, e consequentemente aumentando sua resistência. Com isso, há um aumento na queda de tensão provocada por ele próprio, havendo uma redução na amplitude do sinal, e por consequência no fluxo de elétrons. Com a corrente diminuindo, a potência dissipada na forma de calor diminui, ele esfria um pouco, reduzindo novamente sua resistência, o que por consequência volta à aumentar a corrente, reiniciando o ciclo intermitente.

Como é que se diz por ai que a realimentação positiva faz um circuito oscilar, sendo que de fato, o que realmente o que da inicio nas oscilações e as mantém, é geralmente a carga e a descarga de um capacitor. A realimentação positiva por si só, apenas leva à saturação um elemento amplificador, por exemplo um transistor, e mantem ele neste estado infinitamente até que sua fonte de energia seja cortada, ou um pulso externo seja aplicado em sua entrada, e provoque uma mudança de estado. Como por exemplo , num multivibrador astável existe realimentação positiva, mas se forem retirados os capacitores, e as entradas dos transistores ligadas diretamente, o circuito deixa de oscilar e passa para um estado estável, tendo-se agora um multivibrador biestável ou latch, que é o circuito fundamental dos flip-flops e células de memória RAM. Além disso em alguns osciladores, a princípio, não se tem a realimentação positiva própriamente dita, muito pelo contrário, como no oscilador de resistência negativa, ou nos osciladores hartley, colptis e por desvio de fase, nestes três últimos se tem apenas um estágio amplificador, e como á saida esta defasada em relação à entrada, não parece ser muito correto utilizar o termo "realimentação positiva".

@Eder Neumann Mas segundo eu li sobre isso também, é esta é uma configuração apenas de estudo, devendo ser evitada na prática, em projetos reais de osciladores astáveis de clock. Pois trata-de uma ligação flutuante das portas dos mosfets dos inversores. Com isso, quando o circuito é ligado, no seu estado transiente incial, ele depende do campo elétrico (positivo na grande maioria dos casos), da fonte de alimentação que se espalhe pela superfície onde encontra-se os mosfets, provocando um momento de atração de elétrons, por capacitância parasita, na porta porta do transistor do canal N do do primeiro estágio inversor, para levar o mesmo ao nivel negativo, "dando a partida no circuito, e invertendo a fase nos demais inversores, para iniciar a oscilação no circuito. Contudo ná prática, em alguns casos, este campo elétrico pode não acontecer, ou pelo menos não o suficente para polarizar os transistorez do primeiro estágio inversor, e o circuito não incia as oscilações ficando "travado" num estado sô. Ná prática utilizam capacitores ligados ao terra, muitas vezes acompanha de um cristal de quartzo, se a rede for externa, para inverter a fase do sinal realimentado, garantindo assim que o circuito sempre oscile e mantenha a frequência de oscilação constante. Além disso, esta forma de construção de oscilador em anel, com portas flutuantes, também necessita de muitos estágios inversores, para que a capacitância parasita dos transistores mosfets, seja suficientemente grande, para atrasar o sinal de saida que retorna à entrada, pois do contrário, se o número de inversores for insuciente, o sinal de saida retorna muito rapidamente à entrada, e os inversores ficam num estado de "meio termo" com polarização mediana tanto para os transistores do canal N e ao mesmo tempo também uma polarização mediana nos do canal P do inversor CMOS, de modo que ambos entrem num estado de condução média, não indo nem ao corte nem à saturação, e as oscilações também não acontecem.

@Eder Neumann Muito obrigado por este material, muito bom ele, me esclareceu aqui. Conforme o que diz la, como a porta dos mosfets dos inversores CMOS estão isoladas da região semicondutora por uma camada de óxido, eslas formam um capacitor com a região semicondutora, o qual precisa ser carregado primeiro para entrar em condução, o que provoca um atraso de propagação de um sinal, essencial para o funcionamento de um oscilador em anel. Diferente de um transistor bipolar de junção, que tem as três regiões semicondutoras internas elétricamente unidas, e qualquer carga acumulada, se redistribui rapidamente, internamente para as demais regiões semicondutoras, de modo que ele não tem uma capacitância tão acentuada, e um atraso de propagação tão grande como no mosfet.

@aphawk Renato.88 Acho vocês quem estão confundindo as coisas.. De fato todos os componentes possuem resistência, com os semicondutores, não ocorre de forma diferente o que determina a resistência, e a transcondutância, é o grau de dopagem dos semicondutores, sejam eles do tipo P ou do tipo N. Um semicondutor virgem possui uma alta resistência, de acordo com o nível de impureza que é adicionado no mesmo, sua resistência vai diminuindo. A resistência provoca queda de tensão, de modo que se resistência aumentar, aumenta a queda de tensão, e queda de tensão diminuindo, a corrente também diminui, pois é a queda de tensão que provoca redução na corrente, e ambas são provocadas pelo aumento da resistência, e são inversamente proporcionais lei de ohm básica). Eu não sei se vocês sabem, mas resistores de carbono utilizados em eletrônica, também podem ser considerados como semicondutores, pois se tem o carbono ou grafita, que é um material que apresenta uma resistência alta, e de acordo com a quantidade de deposição de impurezas no mesmo, diminui-se a resistência no material, e tem-se uma ampla gama de valores de resistores no mercado.

@aphawk De fato, de uma ou duas, ou a resistência dos LEDs azuis é mais baixa, neste caso passará muita corrente , ou no caso ela é mais alta. Eu não tenho tenho esta informação, é somente uma suposição, pois não encontrei o datasheet dos displays azuis que utilizei aqui. Mas uma coisa é certa, uma destas hipoteses é verdadeira. No caso que você falou que pode ser que a "tensão dos leds" for maior, significa que a segunda hipótese é verdadeira, ou seja, a resistência dos leds é mais alta, visto que estou alimentando os mesmos com 5V, igual aos verdes e os vermelhos.

@BloodCeltics Lopes Cara montei outro circuito numa placa que eu tinha, com displays e ci's novos, e funcionou perfeitamente conforme a foto em anexo. Provando que neste caso o problema era a falta de uma trilha mesmo. Somente com displays azuis, foi que o circuito permaneceu não funcionando. Neste caso, em relação aos displays verdes e vermelhos, deve ser a baixa resistência dos dos displays azuis mesmo, a causa do problema.