test man*~

Eita... esse estava na cara, eu devia ter ido ao help . Obrigado Paulo!

Existe alguma coisa para compilação condicional no BASCOM AVR? Algo do tipo (em C): #define DEBUG : : : while(1) { var = var + 1; delay_ms(250); #ifdef DEBUG printf("%d", var); // Só executa se DEBUG estiver definido -> "#define DEBUG" #endif }

HAHAHAHAHA @aphawk Eu não troquei... Eu uso os dois, para cada coisa eu uso um (No meu coração há espaço para os dois HAHAHAAHAHA.)... Os próximos serão MPU6050 > HCM5883L > PCF8574+LCD > PCA9685. Ainda quero montar um braço com 6 DOF, uma plataforma autoestabilizada e um rastreador automotivo... Variarei entre um e outro... Não subestime os PIC24F/dsPIC e os PIC32MX/MZ. O primeiro código que eu fiz estava assim, uma conta por linha... Quando peguei o driver no site da Bosch resolvi fazer igual para facilitar o Debug. KKKKKKKK . Eu gosto de pegar o componente, ler o datasheet e fazer o meu próprio código. Pensa bem, você pega o componente monta o circuito, usa o código que outra pessoa fez, vê ele funcionando, pensa: "legal..." e acabou ... Meio sem graça HEHEHE! __________ Testei para ver se o código estava correto... Fiz os parâmetros de calibração, temperatura não compensada e pressão não compensada serem iguais ao exemplo do Datasheet (tirei o BMP180 do circuito). Os resultados foram iguais aos do Datasheet (código escrito corretamente): A parte de medição de pressão do sensor está funcionando de forma incorreta . >>> EDIT: Edit: Acho que no código postado acima 2 variaveis estão em um lugar incorreto, fui alterando para tentar resolver o problema e acabei com tantos códigos que até me perdi...

É está meio confuso, mas tentei colocar o máximo de informações... O BMP180 está olhando pra minha cara e rindo de min LOL Sim rotacionar é mais fácil... No começo fiz dividindo pois o datasheet diz e ainda tipo: variavel_signed_int = -8 >> 2; // Não será igual a -2 por causa do complemento de 2, os bits que entram a esquerda são 0's 1111 1110 (-2)0111 1111 >>10011 1111 >>1 (63) Os nomes estão iguais ao do driver e do datasheet... Só adicionei algumas coisas para indicar se a variavel é signed ou unsigned e o seu tamanho. X1_S32 -> X1 SIGNED 32 bits o driver do site da bosch também faz isso...AC1_S16_P -> AC1_SIGNED 16 bits_DADO DE CALIBRAÇÃO Pensando bem... Será que pode ser o compilador? Ontem fiz um teste convertendo a biblioteca da adafruit (lady ada <3), que é usada no Arduíno, e o problema não foi resolvido... >>>> EDIT: Bizarro demais... Vou fazer o código no MikroC e ver se consigo fazer a compensação corretamente... Já vi algumas pessoas reclamarem do type cast (acho que é isso) do CCS, talvez esse é o problema...

Aquele Atmel ICE parece ser interessante, eles também dão desconto para estudantes... Só que o preço do dólar está quebrando as pernas !

Estou usando um BMP180 consigo ler a temperatura não compensada e também a pressão não compensada. Consigo fazer a compensação da temperatura mas a da pressão (somente a da pressão) não está dando certo... Primeiro fiz um código como diz o Datasheet: (usando divisão em vez de rotação). Não funcionou então resolvi seguir o que o driver do site da bosch diz: https://github.com/BoschSensortec/BMP180_driver/commit/cc63ef49b8487d95b70a51122f5e5ffe2379581a (usando >>15 para /2^15 por exemplo) também não funcionou... Desconfio que seja mal funcionamento do sensor, dados de calibração incorretos ou eu estou cometendo um erro no código (já refiz ele 3 vezes ) Código (apenas a parte que faz compensação da pressão): /**** CALCULANDO A TEMPERATURA COMPENSADA ****/ X1_S32 = (((signed int32) UT_U32 - (signed int32) AC6_U16_P) * (signed int32) AC5_U16_P) >> 15; X2_S32 = ((signed int32) MC_S16_P << 11) / (X1_S32 + MD_S16_P); B5_S32 = X1_S32 + X2_S32; T_COMP_S16 = ((B5_S32 + 8) >> 4); /**** CALCULANDO A PRESSÃO COMPENSADA ****/ B6_S32 = B5_S32 - 4000; X1_S32 = (B6_S32 * B6_S32) / (signed int32)4096;//X1_S32 = (B6_S32 * B6_S32) >> 12; X1_S32 *= B2_S16_P; X1_S32 /= (signed int32)2048;//X1_S32 >>= 11; X2_S32 = (AC3_S16_P * B6_S32); X2_S32 /= (signed int32) 2048;//X2_S32 >>= 11; X3_S32 = X1_S32 + X2_S32; B3_S32 = (((((signed int32)AC1_S16_P) * 4 + X3_S32) << OSS) + 2) / 4;//B3_S32 = (((((signed int32)AC1_S16_P) * 4 + X3_S32) << OSS) + 2) >> 2; X1_S32 = (AC3_S16_P * B6_S32) / (signed int32)8192;//X1_S32 = (AC3_S16_P * B6_S32) >> 13; X2_S32 = (B1_S16_P * ((B6_S32 * B6_S32) / (signed int32)4096)) / (signed int32)65536;//X2_S32 = (B1_S16_P * ((B6_S32 * B6_S32) >> 12)) >> 16; X3_S32 = ((X1_S32 + X2_S32) + 2) / 4;//X3_S32 = ((X1_S32 + X2_S32) + 2) >> 2; B4_U32 = (AC4_U16_P * (unsigned int32) (X3_S32 + 32768)) / (signed int32)32768;//B4_U32 = (AC4_U16_P * (unsigned int32) (X3_S32 + 32768)) >> 15; B7_U32 = ((unsigned int32)(UT_U32 - B3_S32) * (50000 >> OSS)); if (B7_U32 < 0x80000000) { P_COMP_S32 = (B7_U32 * 2) / B4_U32;//P_COMP_S32 = (B7_U32 << 1) / B4_U32; } else { P_COMP_S32 = (B7_U32 / B4_U32) * 2;//P_COMP_S32 = (B7_U32 / B4_U32) << 1; } X1_S32 = P_COMP_S32 / (signed int32)256;//X1_S32 = P_COMP_S32 >> 8; X1_S32 *= X1_S32; X1_S32 = (X1_S32 * 3038) / (signed int32)65536;//X1_S32 = (X1_S32 * 3038) >> 16; X2_S32 = (P_COMP_S32 * -7357) / (signed int32)65536;//X2_S32 = (P_COMP_S32 * -7357) >> 16; /*pressure in Pa*/ P_COMP_S32 += (X1_S32 + X2_S32 + (signed int32) 3791) / (signed int32)16;//P_COMP_S32 += (X1_S32 + X2_S32 + 3791) >> 4; Pressão (P_COMP_S32) em PA (pressão muito baixa correspondendo a ~1670m 'acima do nível do mar' sendo que deveria ser ~920m)... A temperatura está ok 243 > 24,3°C: Dados de calibração: Circuito: - O que vocês acham que pode ser?

Quando fui usar o Processing me perguntei o porquê do plano cartesiano dele ser assim... Dai fui usar aqueles displays 128x64 e o plano também é assim HEHE... Será que eles fazem assim para facilitar na hora da construção? Paulo, existe um programmer & debguger oficial low cost ($40) para os AVRs? Sem um debugger fica complicado dependendo da coisa e o Proteus não possui boa parte dos componentes...

É meio OFF mas lembrei de um momento quando li este trecho que vocês, @Isadora e Ferraz @aphawk, escreveram: Eu estava estudando sobre medidores de vazão ultrassônicos e na época vi que existiam medidores não intrusivos, que são encaixados fora da tubulação (sem buraco algum) e o ultrassom passa através da parede da tubulação... Na época fiquei meio encucado com essa informação (pensando mais ou menos o que vocês disseram) depois acabei entendo,quer dizer, pelo menos achei que estava entendendo e segui com a vida HEHEHA. Olha só (1 minuto): https://youtu.be/Bx2RnrfLkQg?t=2m59s

Mexer com essas paradas de tempo é muito bom (quando se sabe assembly HEHE)... Muito bacana! Eu acho que consegui entender, um timer conta os pulsos enquanto outro timer conta o tempo, não estava entendendo a parte: 'Agora vamos incrementar a variável BLoadadr B , XLD R24,XSUBI R24,$FFST X,R24 mas agora entendi: O frequencímetro e o analisador estarão em um único ATmega? Só poderá ser usado um de cada vez né? Recebi um PIC32MX com ele da pra combinar 2 timers de 16 e criar o de 32... Recebi mas não posso usá-lo até comprar o PICKIT 3, pelo menos a microchip dá um desconto bacana e não cobra frete HEHE! Vou aproveitar e arrumar um PIC32MZ... São overkill para hobby mas fazer o que né HEHE! Show de bola!

Entendi... O Timer faz a parte de verificar se o buffer encheu... Na interrupção você altera o endereço de retorno, assim o programa sai da "pode_ler:"...

@aphawk 300MHz?!?! What the what? HAHAHAHA Estou esperando um PIC32MX que opera a 50MHz e estou todo feliz HAHAHA... O Bom mesmo seria se o pessoal do BASCOM adicionasse os ARM's, não curti o C do Atmel Studio... Além disso, o BASCOM explica até o que não precisa explicar no help, dá para saber exatamente o que o compilador está fazendo e isso é muito show! @alexandre.mbm Eu creio que sim, neste vídeo o cara faz uma comparação de uma única sketch operando no mega2560 e no DUE: Edit: É a mesma interface, no fim do vídeo dá para ver...

Hmm ai seria massa em!? Há um tempo atrás quando vi a placa do Arduíno Due pensei em aprender a usar o Atmel Studio para mexer com o ARM mas ai vi que o USBASP não grava os ARMs. Quais gravadores gravam os ARMs? Uma outra dúvida, o Atmel Studio C é gratuito até para os ARMs não é? Outra, é possível usar a interface do Arduíno para escrever um código (em C) igual ao que seria escrito no Atmel Studio?

@aphawk Consegui fazer, muito bacana... Adicionei a linha: {INVERT=1,2,3,4,5,6,7,8} Daí pude tirar as NOTs... Simulação rodou mais limpa! Show de bola... Eu acho que você deveria escrever um livro Paulo, não existe o "Desbravando o microcontrolador PIC16F628A"? Você deveria lançar o "Desbravando o microcontrolador ATmega32A" com dois volumes o primeiro em ASM e o segundo em BASIC... Aqui no Brasil faltam livros para os AVR's... Aliás você conhece um bom? Valeu!

Ai está o projeto. Poderia ter adiciomnado algus efeitos e mais comandos serial mas acho que já estou satisfeito... Outra coisa, eu deveria ter usado variáveis locais pois ficaria bem mais organizado e talvez gastaria menos memória. - Para funcionar os bytes das letras devem estar carregados na EEPROM (posição 1 até 570); - Para alterar a quantidade de max7219 é só alterar a constante "qtde_max7219 = X" podem ser usados até 15; - A resolução da velocidade de rolagem é de ~20mS se for enviado via serial "4" cada passo de rolagem terá 4*20=80mS, a resolução pode ser alterada para ~10mS comentando a linha 12 e tirando o comentário a 13; - Tirar o SPI debugger faz a simulação rodar de forma mais rapida. Comandos serial: .--------+------------------------------------+-------------. |Comando | Dados |Fim do envio | |--------|------------------------------------|-------------| | 1 | Mensagem a ser mostrada no display | CR (ENTER) | --> Máximo 200 Caractéres | 2 | Velocidade de rolagem (0-255) | CR (ENTER) | --> 0 = vel. máxima | 255 = Vel. mínima | 3 | Intensidade dos Leds (0-15) | CR (ENTER) | --> 0 = mínimo | 15 = máximo '--------+------------------------------------+-------------' Ex: Enviar: 1Forum Clube do Hardware (ENTER) -> Esta mensagem será mostrada no display 23(ENTER) -> Com velocidade de 60mS por passo (3*20mS) 38(ENTER) -> Brilho dos leds mais ou menos 50% As portas NOT são para deixar as matrizes como as que seriam usadas na montagem prática (que eu não realizei). Sobrou uma eternidade de memória flash, dá para colocar muuuuuiiiiiitos efeitos hehe!!! Estava até pensando em fazer uma interface, usando o Visual Studio, para enviar frases, ajustar velocidade e intensidade... Mas vou ficar por aqui mesmo... Agora vou ver se uso o TWI (i2c). Download programa (BASCOM) e simulação (Proteus 8.2), painel de leds final: http://www.4shared.com/rar/3-qjEbHbce/Painel_de_Leds_Final.html? Valeu pelo Tutorial Paulo @aphawk!!!

Sim =D o tutorial fez ficar fácil... O mais bacana foi que eu pude fazer "Dim mensagem(1265) as byte" 1265 NUSSSSSSSSSS... Esses circuitos matriciais que você possui são assim: Agora o painel já aceita envio de uma frase via serial mas ela ainda não fica rodando. para mostrar algo escrever "1 + frase + 'APERTAR ENTER'"... Esse "1" é o comando pois estou pensando em outros 2 http://www.4shared.com/rar/-Sa1VTbgba/Recebendo_Dados_Serial.html?

É eu vi esse esquema da EEPROM mas o que causou o trabalho foi "iniciar o vetor com os valores". Eu até criei o arquivo .bin com o BASCOM AVR mas o proteus não o reconheceu ... O Correios está fazendo pirraça com as importações por isso estou somente na simulação. Sim ler a EEPROM é um processo lento mas ela será lida apenas quando o usuário enviar a frase via serial, quando isso acontecer o AVR lerá a EEPROM e atualizará um vetor que será lido toda hora (este ficará na SRAM). Olhei o esquema dos arquivos .FON isso certamente seria a forma "certa" de fazer a coisa... Mas como já fiz vou ficar com aquela monstruosidade mesmo HEHE. Montei circuito completo, e fiz um teste para ver se os MAX mostrariam as letras corretamente: AphaUk com "U" Estou tentando fazer de uma forma que fique fácil aumentar ou diminuir a quantidade de MAX/Matriz (alterando apenas 2 linhas). Aqui está o arquivo: http://www.4shared.com/rar/WusLRub1ce/6_MAX_7219.html? Dei uma parada para entender como usar o USART com o BASCOM AVR e é bem interessante... Aquela coisa do buffer e tal _RS_HEAD_PTRW0, byte that stores the head of the buffer _RS_TAIL_PTRW0, byte that stores the tail of the buffer _RS232OUTBUF0, array of bytes for the ring buffer that stores the printed data. _RS_BUFCOUNTW0, a byte that holds the number of bytes in the buffer. Obrigado novamente @aphawk, um dia fica pronto .

Sim o MAX7219 é muito bom... Ele faz todo o trabalho pesado, o primeiro painelzinho que eu fiz foi usando o 74HC595 (deu uma trabalheira danada hehe). Eu comecei o código e apanhei (MUITO) na inicialização do vetor, em C eu poderia fazer assim: PROGMEM prog_uchar CH[] = {3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 03, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 14, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 24, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 34, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 44, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 54, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 64, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 74, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 84, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 92, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~}; Tirei as letras daqui: https://brainy-bits.com/tutorials/scroll-text-using-the-max7219-led-dot-matrix/ No BASIC tive que fazer na raça: Dim E(570) As Byte , I As Word E(1) = 3E(2) = &B00000000E(3) = &B00000000E(4) = &B00000000E(5) = &B00000000E(6) = &B00000000 'SpaceE(7) = 1E(8) = &B01011111E(9) = &B00000000E(10) = &B00000000E(11) = &B00000000E(12) = &B00000000 ' !E(13) = 3E(14) = &B00000011E(15) = &B00000000E(16) = &B00000011E(17) = &B00000000E(18) = &B00000000 ' ""E(19) = 5E(20) = &B00010100E(21) = &B00111110E(22) = &B00010100E(23) = &B00111110E(24) = &B00010100 ' #:::E(559) = 3E(560) = &B01000001E(561) = &B00110110E(562) = &B00001000E(563) = &B00000000E(564) = &B00000000 ' }E(565) = 4E(566) = &B00001000E(567) = &B00000100E(568) = &B00001000E(569) = &B00000100E(570) = &B00000000 ' ~ For I = 1 To 570 Writeeeprom E(i) , INext Tentei coisas do tipo: https://msdn.microsoft.com/en-us/library/y13tek7e.aspx mas nada de funcionar (o compilador não reconhece o comando). Estou pensando em armazenar os bytes dos caracteres na EEPROM (570 bytes) assim sobra mais espaço na SRAM para a mensagem que rodará no painel... Este código apenas mostra todos os caracteres: http://www.4shared.com/rar/6PIKnnJ9ce/LED_MAT_Todos_Carcteres_MAX_AV.html? Agora vou para o painel com os 6 MAX7219. Valeu Paulo @aphawk

Eu queria criar um biblioteca... Até achei uma solução mas não resultaria em algo "limpo"... Então resolvi usar o MAX7219 e fazer um painelzinho de leds, já entendi o funcionamento do MAX agora estou lendo a parte sobre SPI do datasheet do Atmega, farei uns testes e então começarei o programa... Vou ser se faço um esquema para receber dados da serial e mostrar no painel (mensagem rolando). Quando o código ficar pronto eu posto aqui.. Obrigado @aphawk!

Dê uma olhada na Farnell (http://www.farnellnewark.com.br/) http://www.farnellnewark.com.br/circuitointegradomicrocontrolador8bit41667mhzpic18f87j60ipt56k7312,product,56K7312,0.aspx

Olhei lá... Entendi como funciona, aproveitei e olhei também a função FORMAT =D ficou tudo mais claro hehe. Estou querendo usar um PCF8574 (que o pessoal usa com o Arduíno) para enviar caracteres para o LCD. O CCS possui um esquema que é assim: printf(escrever_lcd_i2c,"Hello World"); Assim o printf chama a função "escrever_lcd_i2c" onde há o código para enviar cada caractere para o LCD via I2C. Pelo que eu entendi (ainda não fiz o código para o CCS) o printf cria o caractere "H" e chama a função "escrever_lcd_i2c" depois cria o "e" e chama a função "escrever_lcd_i2c" e assim por diante... Existe algo parecido no BASCOM? Obrigado Paulo!

Ao abrir o BASCOM ele mostra aquelas dicas ai apareceu falando da $lib "i2c_twi.lbx"... Dá até para ver o Erro após cada envio/recepção =D Sobre o projeto 7, não existe uma forma de fixar o número de casas que serão imprimidas após a vírgula com a função Lcd? Tipo assim (se fosse em C): printf("%.2f",single_var); Eu converti no código mesmo...

Típico "AVR Freak" HAHAHAHAHAHAHA... Você possui uma camisa desta: http://www.atmelbrandshop.com/ProductDetails.asp?ProductCode=0151-B HEHEHEHE Brincadeira... Eu até queria ter =) Estou indo com os projetos... No projeto 4 usei o DIDR0 para para desativar a entrada digital e assim consumir menos energia (característica bacana essa), no do relógio (Pj 5) achei interessante o esquema do 32,768KHz externo =D, ainda estou terminando ele falta programar o alarme! No fim vou fazer uma comunicação SPI entre um PIC e um AVR e uma I2C multimestre com dois PIC e dois AVR como mestres e escravos HAHAHAHAHAHAHHAHAHAHhUHAuhuahuhuaHUAH!!!!! Tutorial excelente... Uma coisa, eles pararam de atualizar o BASCOM?

Entendi @aphawk... É que tipo, Como entendo bem os PICs para entender os AVRs eu tento fazer um paralelo na minha mente HEHE... No PIC quando uma interrupção é gerada os registradores STATUS e W (WORD) também devem ser salvos (se alterados na ISR): ; Código ASM ISR PIC16F INTERRUPT movwf w_temp ; save off current W register contents movf status,w ; move status register into W register movwf status_temp ; save off contents of STATUS register movf pclath,w ; move pclath register into w register movwf pclath_temp ; save off contents of PCLATH register ; isr code can go here or be located as a call subroutine elsewhere movf pclath_temp,w ; retrieve copy of PCLATH register movwf pclath ; restore pre-isr PCLATH register contents movf status_temp,w ; retrieve copy of STATUS register movwf status ; restore pre-isr STATUS register contents swapf w_temp,f swapf w_temp,w ; restore pre-isr W register contents retfie ; return from interrupt Nos AVRs é a mesma coisa... Porém é possível salvar os 'WORKS' (R0 - R31) na pilha com as funções PUSH, nos PICs você salva em outro registrador. É claro... Se não houver alterações nos registradores durante o tratamento das interrupções, também não haverá necessidade de salvá-los... Um coisa muito interesante (tomara que eu esteja correto!! UHAuHAUhUah) é que não há limite para o tamanho da pilha dos AVRs, a única limitação é o tamanho da SRAM e o seu uso... Mesmo assim... Eu ainda amo os PICs !!! @alexandre.mbm, olha este link: https://www.youtube.com/watch?v=64vVI5kgbCo&list=PL4DE4A7AD9EE36E77 Não assisti aos vídeos mas pela quantidade de views eles devem ser bons... O cara usa o CCS nos tutoriais ele é extremamente simples, muito fácil... Ele possui um Project Wizard que te dá tudo na mão, você apenas escreve o código... Parece que o cara também ensina simular usando o Proteus... Quanto as bibliotecas, realmente são poucas se comparadas com a quantidade existente para o Arduíno, o CCS vem com várias mas mesmo assim são poucas... Mas ai que está o pulo do gato, é muito mais interessante você pegar o datasheet do componente, quebrar a cabeça e criar a sua própria biblioteca (que funcionará exatamente como você quer)... Dá uma olhada lá... Quem sabe você curti... Voltando para os projetos o Need For Speed Most Wanted 2005 me atrasou

Obrigado @aphawk e @Intrudera6... Agora estou entendendo, nos PICs no início da ISR é salvo o registrador WORK, dentre outros, porém, nos AVRs são vários 'WORKS' (R31 ao R0) daí é necessário salvar todos, não estou falando besteira né ? Ok Eu tenho que prestar mais atenção, antes de ontem olhei e não achei (apesar te ter passado pela informação)... Agora olhei e achei! Help > Index > Índice > ON INTERRUPT OBRIGADO!

O PROTEUS 8 resolveu o problema!! Eita... O projeto 3 foi mais complicadinho HEHE, o bom que é complicado só na primeira vez. Fiquei com algumas dúvidas se você puder me responder... 1 - Fiz um teste (deu certo) mas quero confirmar... Para escrever diretamente em um registrador qualquer basta escrever o nome dele igual ao valor desejado? 'Ex:TCNT0 = 61OCR2B = 254 2 - Para o timer0 foi usado: On -->> Timer0 <<-- Timer0_isr Save Dei uma procurado no help e não encontrei o nome a ser usado para insterrupções do módulo TWI: Qual seria o nome? 3 - O que as funções PUSH e POP fazem dentro da ISR? Tim0_isr:push r23::pop r23Return Estou chutando que está relacionado com STACK mas tirei elas do meu programa e ele funcionou corretamente, eu até procurei no help mas não encontrei coisa alguma. Obrigado Paulo!