PIC Comunicação Serial entre PIC e Arduíno

6 de agosto de 2019

Olá:

Preciso de ajuda para fazer um PIC 16F628 se comunicar (comunicação Serial) com um Arduíno UNO.

Não sei programar em C (PIC), apenas em Assembly. Sei programar o Arduíno.

Eu consigo fazer um PIC se
comunicar com outro (USART), e conheço a comunicação serial do Arduíno.

Preciso de umas dicas para
fazer o PIC se comunicar com o Arduíno, de forma harmoniosa.

Se alguém souber, me ajude.

Surid

aphawk · 6 de agosto de 2019

@Surid ,

Não entendí a sua dúvida !

Se você sabe usar a serial em modo assíncrono, basta definir o modo igual nos dois processadores !

Por exemplo, o famoso 115k bauds, no formato 8N1 e ponto !

Agora, para te facilitar a vida, eu sugiro usar os pinos Rx, Tx, RTS e CTS , assim você faz a sinalização de quem quer iniciar uma conversa com quem, ok ?

Me lembra os saudosos tempos de comunicação via modem ....

Paulo

7 de agosto de 2019

Em 06/08/2019 às 01:11, Surid disse:

Olá:

Preciso de ajuda para fazer um PIC 16F628 se comunicar (comunicação Serial) com um Arduíno UNO.

Não sei programar em C (PIC), apenas em Assembly. Sei programar o Arduíno.

Eu consigo fazer um PIC se
comunicar com outro (USART), e conheço a comunicação serial do Arduíno.

Preciso de umas dicas para
fazer o PIC se comunicar com o Arduíno, de forma harmoniosa.

Se alguém souber, me ajude.

Surid

@Isadora Ferraz

Isadora:

Se você tiver condições, pode me ajudar a encontrar uma solução, por gentileza?

Surid

.if · 7 de agosto de 2019

Amigo agradeço pela consideraração.

O contato com o asm do pic que tive foi há bem tempo. Nele, num vai rolar ok?

Tentemos linguagem quasi humana. Pense em algo como tipo assim

um é master, outro slave
o slave fica trabalhando igual a um escravo mas fica de olho no que mestre quer (interrupt serial ligada)
este envia um comando pro slave no qual acende uma luz de alerta (alguns chamam flag)
dá uma olhada na caixa de entrada e ve o que o mestre quer
então executa a tarefa

É o extremo do minimalista.

O complexo é que pode ter hora que o escravo não entende nada. Ele pode ignorar até entender, perguntar pro mestre o que ele quer, confirmar se é isso mesmo e etc. Isto se chama "protocolo". Mas este não é seu momento. Tenta 1º enviar 1 byte de 1 pra outro com sucesso.

Ah e dá uma reagida na resposta do Paulão. Não é muito mas pode motivá-lo a te ajudar. Pelas suas letras, percebeu que ele é PHD no assunto, né?

7 de agosto de 2019

@Isadora Ferraz

Isadora:

Agradeço a disposição em me ajudar. Pelo teu post, deu para perceber que pensamos do mesmo jeito. Acha que eu devo colocar dois resistores nas linhas de transmissão/recepção ligados ao +5V para evitar ruídos? Será que precisa? A ideia é juntar PIC e Arduíno num mesmo projeto: Faço com o PIC o que eu não consigo fazer com o arduíno e faço com o arduíno o que eu não consigo fazer com o PIC. Parece confuso e ilógico mas acho que pode funcionar. Faria tudo com o pic se eu fosse muito bom em programar Pics, faria tudo com arduíno se eu fosse muito bom em programar arduínos (ainda tem a questão do código aberto). A solução que eu achei foi misturar tudo.

Surid

adicionado 17 minutos depois

@Isadora Ferraz

Outra coisa:

No programa do arduíno (escravo), pretendo usar begin.available para vigiar se tem alguma ordem do mestre (PIC). Usarei o arduíno para coletar dados de sensores e transmitir informações através de um display (é muito mais fácil fazer essas coisas com um arduíno) e usarei o pic para controlar tudo (pic asm é a minha praia), usando a comunicação serial do PIC para fazer o contato (usart). Espero que o arduíno reconheça a comunicação do pic, start bit, stop bit , etc., usarei taxa de 9600 e cristal 4mhz.

Surid

adicionado 50 minutos depois

@Isadora Ferraz

OBS: Onde se lê begin.available, entenda-se serial.available. Falha nossa.:D

aphawk · 8 de agosto de 2019

20 horas atrás, Isadora Ferraz disse:

Ah e dá uma reagida na resposta do Paulão. Não é muito mas pode motivá-lo a te ajudar. Pelas suas letras, percebeu que ele é PHD no assunto, né?

Olha .... não é PHD mas cheguei perto !

Quase virei PHD em “protocolos” !

Eu fiz um programa em Assembly do 6502 que permitia acessar o Videotexto no Apple ][ . Um ano de briga técnica com a antiga Telesp e no final desisti porque descobri que lá existiam “forças ocultas” , como dizia o Jânio Quadros.... um tal de SCN dominava ...

Depois, portei o programa para

rodar na placa Videx ( CPM sob o Z-80 ) dentro de um Apple ][ .

Isso era na velocidade fantástica de 1200/75 bauds kkkkk .

Logo a seguir descobri como fazer os Modens da época fazer 75/1200 e aí inventei a comunicação rápida ( quase 1200/1200 ) usando esses modens kkkk

Antes disso fiz um programa no CP/M do saudoso Gepeto usando protocolo Y-modem com CRC para trocar arquivos com nosso sistema de controle de processos industriais instalados em

clientes.

Finalmente em 1987 fiz de novo um monte de programas de comunicação com X-modem, Y-modem e até o Kermit para rodar em MS-DOS 3.2 nos IBM PC-XT...

Detalhe : tudo sempre em Assembly !

Só recentemente tive de fazer um programa de comunicação serial a 115k Bauds entre dois Atmegas.

Hoje falamos Usart mesmo quando tratamos apenas os sinais Tx/Rx ... naquela época tinha de tratar DCD, DTR, DSR, RTS, CTS, RI ... e claro, os Tx/Rx !

Fazer uma comunicação simples entre dois microcontroladores no mesmo local é brincadeira de criança perto daquela saudosa época de desbravamento !

adicionado 6 minutos depois

@Surid ,

Start bit, stop bit, 9600 bauds ....

Faz o arroz com feijão : um start bit, 8 bits de dados, um stop bit, sem paridade... isso é universalmente conheçido como formato 8N1 .

No arduíno deve ser bico definir isso em uma só linha de programação.

Paulo

.if · 8 de agosto de 2019

13 horas atrás, Visitante disse:

dois resistores nas linhas de transmissão/recepção ligados ao +5V

você está trocando os pés pelas mãos. Este momento ainda vai chegar. Vá por partes

13 horas atrás, Visitante disse:

Faço com o PIC o que eu não consigo fazer com o arduíno e faço com o arduíno o que eu não consigo fazer com o PIC

Eu chamaria de ineficiente pois vais usar duas inteligências pra algo que suponho simples.

13 horas atrás, Visitante disse:

Faria tudo com o pic se eu fosse muito bom em programar Pics

13 horas atrás, Visitante disse:

pic asm é a minha praia

Isso sim parece confuso.

Penso que o desafio de fazer tudo em um é menor do que fazer a conversa entre os dois. Arduínos usam ter um avr atmega que é bem superior ao pic. Isso por si já é motivo pra migração.

13 horas atrás, Visitante disse:

o pic para controlar tudo

Os simples comandos arduínos digitalwrite(), digitalread(), analogread(), analogwrite() já te resolvem 99% dos controles do sistema.

Se quiser falar sobre os pullups, de novo, por hora não são necessários. E pra distância longa hás de usar uma interface tipo max232 pra converter níveis. Mais longa ainda? rs485. Quer ir mais longe ainda? Já que está adiantando as coisas, em algum momento no futuro vai chegar seu momento sem fio. Neste caso, não vai ter como escapar de p.ex. arduino ESP32 que é muito muito muito mesmo barato e tem recurso que não acaba +. Literalmente não há limite pra distância da comunicação. Mais um motivo pra você considerar seu arduíno aí e esquecer do pic.

Se achar que deve, fala + sobre seu projeto. Detalhes e desenhos...

20 de outubro de 2019

@Isadora Ferraz

Olá, Boa Tarde! Desculpe a demora responder :D

Funcionou! Tive que criar um protocolo de comunicação entre o atmega328P e o PIC para que os dois programas pudessem conversar sem se atrapalharem. Tive que usar um terceiro pino (além do RX e TX) para ajudar a organizar o tráfego de informações.

Quando disse que o PIC é minha praia, eu me referi à processamento de informações. Fiz programas com os PICs

16F675, 16F676, 16F628, 16F818, 16F872, 16F873, 16F913 e 16F916.

Tenho mais facilidade com PIC ASM e consigo lidar bem com a complexidade dos códigos em assembly em programas extensos.

Sei fazer muitas coisas com o PIC mas não sei, por exemplo, utilizar sensores ultra-sônicos com o mesmo ou RTC.

Quanto a utilizar somente o arduíno nos meus programas, vai demorar um pouco para eu ter com o mesmo, a destreza que eu tenho com o PIC ASM, além do mais...

- Se eu não me engano, o atmega328P tem 32Kwords. Um programa simples de leitura de sensor com o arduíno já consome 2 ou 3 Kwords.

Com o pic 16F916 de apenas 8kword, fiz um programa de 80 páginas e ainda sobrou espaço.

Quanto aos projetos e esquemas, ainda está tudo na minha cabeça. Pensei em usar o arduíno para gerenciar múltiplos sensores (temperatura, ultra-sônico, RTC ) e o PIC para fazer o processamento de informações, funcionando como master e o arduíno como slave. O arduíno vai estar muito ocupado com os sensores e display, talvez ocupe todos os 32kword. Caberá ao PIC pensar pelos dois e coordenar tudo.

Surid_7

adicionado 53 minutos depois

Olá :

@isadora ferraz

"Quando disse que o PIC é minha praia, eu me referi à processamento de informações. Fiz programas com os PICs

16F675, 16F676, 16F628, 16F818, 16F872, 16F873, 16F913 e 16F916."

Na verdade é PIC 12F675 e não 16F675.

Em 08/08/2019 às 07:46, Isadora Ferraz disse:

você está trocando os pés pelas mãos. Este momento ainda vai chegar. Vá por partes

Eu chamaria de ineficiente pois vais usar duas inteligências pra algo que suponho simples.

Isso sim parece confuso.

Penso que o desafio de fazer tudo em um é menor do que fazer a conversa entre os dois. Arduínos usam ter um avr atmega que é bem superior ao pic. Isso por si já é motivo pra migração.

Os simples comandos arduínos digitalwrite(), digitalread(), analogread(), analogwrite() já te resolvem 99% dos controles do sistema.

Se quiser falar sobre os pullups, de novo, por hora não são necessários. E pra distância longa hás de usar uma interface tipo max232 pra converter níveis. Mais longa ainda? rs485. Quer ir mais longe ainda? Já que está adiantando as coisas, em algum momento no futuro vai chegar seu momento sem fio. Neste caso, não vai ter como escapar de p.ex. arduino ESP32 que é muito muito muito mesmo barato e tem recurso que não acaba +. Literalmente não há limite pra distância da comunicação. Mais um motivo pra você considerar seu arduíno aí e esquecer do pic.

Se achar que deve, fala + sobre seu projeto. Detalhes e desenhos...

20 de outubro de 2019

@isadora ferraz

Boa tarde, de novo:

Isso que eu vou relatar abaixo, tira um pouco o controle da gente sobre os projetos, não é uma coisa ruim pois popularizou o arduíno mas, para tirar 100% das possibilidades do arduíno, é necessário ser um excelente programador (não sei se você vai concordar):

Na internet existem muitas bibliotecas para o arduíno:

- O que a gente aprende nos cursos de arduíno é lidar com o processamento de informações.

- Fazer uma biblioteca que habilite o arduíno a trabalhar com esse ou com aquele sensor, isso já é mais difícil.

- Felizmente a comunidade mundial de colaboradores da plataforma arduíno (muitos programadores profissionais) se encarregam de fazer a parte mais trabalhosa.
- Isso facilita as coisas para a grande maioria de usuários do arduíno, que cresce a cada dia. São os novatos, aqueles que estão começando agora, dos muitos cursos de eletrônica (ou mecatrônica) ou aqueles que não são novatos mas que não estão familiarizados com a plataforma.

- O que a gente faz basicamente é pegar trechos já feitos de programas (bibliotecas), juntá-los e fazer o processamento de informações com o que a gente aprendeu nos cursos de arduíno.

Com o PIC ASM isso não acontece, a gente começa do zero, não existem trechos de programa pré-fabricados para ajudar na confecção dos códigos, tudo é feito na “raça”,

porém o controle que a gente tem do projeto é total.

Sinta-se à vontade para discordar

Surid_7

adicionado 6 minutos depois

6 minutos atrás, Surid_7 disse:

@isadora ferraz

Boa tarde, de novo:

Isso que eu vou relatar abaixo, tira um pouco o controle da gente sobre os projetos, não é uma coisa ruim pois popularizou o arduíno mas, para tirar 100% das possibilidades do arduíno, é necessário ser um excelente programador (não sei se você vai concordar):

Na internet existem muitas bibliotecas para o arduíno:

- O que a gente aprende nos cursos de arduíno é lidar com o processamento de informações.

- Fazer uma biblioteca que habilite o arduíno a trabalhar com esse ou com aquele sensor, isso já é mais difícil.

- Felizmente a comunidade mundial de colaboradores da plataforma arduíno (muitos programadores profissionais) se encarregam de fazer a parte mais trabalhosa.
- Isso facilita as coisas para a grande maioria de usuários do arduíno, que cresce a cada dia. São os novatos, aqueles que estão começando agora, dos muitos cursos de eletrônica (ou mecatrônica) ou aqueles que não são novatos mas que não estão familiarizados com a plataforma.

- O que a gente faz basicamente é pegar trechos já feitos de programas (bibliotecas), juntá-los e fazer o processamento de informações com o que a gente aprendeu nos cursos de arduíno.

Com o PIC ASM isso não acontece, a gente começa do zero, não existem trechos de programa pré-fabricados para ajudar na confecção dos códigos, tudo é feito na “raça”,

porém o controle que a gente tem do projeto é total.

Sinta-se à vontade para discordar

Surid_7

.if · 20 de outubro de 2019

Concordo sim. Mas me permita argumentar que:

-asm não é igual c... cada um tem o seu ... ahh você entendeu...

-aprender o de um novo mc leva tempo. Já c serve pra todos

-com asm você leva mais (muito mais) tempo pra concluir determinada tarefa. A prova é o tempo que demorou a retornar kk

-mesmo achando que tem tempo de sobra, isso é o que você pensa: seu 'concorrente' faz mais rápido

-tem 'arduino' que tem recurso de sobra. Não vejo problema em usar 6K num mc que tem 4M. Apesar que no fundo senti dó de usar 50K só pra piscar um led num esp32 kk

-do arduino só me atrai a parte C dele

-Pra aprender como conversar com novo sensor e arduíno é relativamente fácil,bastando dar uma boa lida no d.s. dele e claro, saber como o mc trata os IO's

-e ao contrário, assembly é que exige excelência em programação. P.ex. apesar da antiga chamada 'only 32 opcodes to learn' ou algo assim do pic, C se resume a meia dúzia e olhe lá.

Obviamente, rápido ponto de vista pessoal...

22 de outubro de 2019

Em 20/10/2019 às 17:23, Isadora Ferraz disse:

Concordo sim. Mas me permita argumentar que:

-asm não é igual c... cada um tem o seu ... ahh você entendeu...

-aprender o de um novo mc leva tempo. Já c serve pra todos

-com asm você leva mais (muito mais) tempo pra concluir determinada tarefa. A prova é o tempo que demorou a retornar kk

-mesmo achando que tem tempo de sobra, isso é o que você pensa: seu 'concorrente' faz mais rápido

-tem 'arduino' que tem recurso de sobra. Não vejo problema em usar 6K num mc que tem 4M. Apesar que no fundo senti dó de usar 50K só pra piscar um led num esp32 kk

-do arduino só me atrai a parte C dele

-Pra aprender como conversar com novo sensor e arduíno é relativamente fácil,bastando dar uma boa lida no d.s. dele e claro, saber como o mc trata os IO's

-e ao contrário, assembly é que exige excelência em programação. P.ex. apesar da antiga chamada 'only 32 opcodes to learn' ou algo assim do pic, C se resume a meia dúzia e olhe lá.

Obviamente, rápido ponto de vista pessoal...

@Isadora Ferraz

Bom Dia:

Quando você citou o ESP32, fui me atualizar..

Realmente é muito barato e dá para fazer um led piscar pela IDE do Arduíno.

Mas em relação a ele eu me sinto como o Luiz Gonzaga nessa história (fato verídico) a seguir:

Quando começou a ganhar dinheiro, Luiz Gonzaga comprou um "fole" (acordeom) de 120 baixos (Os baixos são recursos mecânicos no instrumento musical responsáveis pelo acompanhamento da música tocada no acordeom).

Olhando seu pai (Januário José dos Santos) tocar, ele ponderou:

- Meu fole tem 120 baixos, mas eu só uso dois ( por não saber usar mais)...

- O fole de Januário tem só 8 baixos, mas ele usa todos os 8.

.if · 22 de outubro de 2019

Ok. De fato eficiência é bem vinda. Me fez lembrar que certa feita fiz um projetinho num mc de 1K de flash. Fui apertando daqui e dali e ocupou 1022 bytes!

Atualmente como sabemos, o dinheiro fala mais alto. P.ex. O mc era um pic16f676 @ $1.50. Já o stm8s003 @ $0.35 (consultei agora na digikey). Este com recursos "infinitos" com relação ao pic. Adivinha qual a gente escolheria atualmente?

Quando seu público cansar de ouvir baião de dois acordes, você deve sentir que pode fazer novos.

Olha o que vem por aí... (já veio)

ESP32-S2

Menor e provavelmente ainda + barato... Ninguém segura estes chineses!!

22 de outubro de 2019

Em 20/10/2019 às 17:23, Isadora Ferraz disse:

-do arduino só me atrai a parte C dele

@Isadora Ferraz

Boa Tarde:

Aparentemente você gosta da linguagem C !

Eu tenho alguns livros sobre a linguagem PIC C e pratico ela com o 8051.

Pratico também com o arduíno (C com algumas modificações).

Mas não é a minha linguagem padrão. Gostaria de programar mais em C, mas sinto uma certa resistência do meu cérebro em assimilá-la.

Talvez você queira me ajudar nisso !

Minha ideia é a seguinte:

Em anexo segue um dos primeiros programas que eu fiz, logo que comecei a mexer com microcontroladores. Usando uma sucata de campainha sem fio e um pic 16f628,

automatizei o acionamento de vários equipamentos na minha garagem (lâmpada, rádio, etc.)

Tem duas macros que estão destrinchadas na outra folha em anexo e que foram usadas no programa.

Se um dia você não tiver o que fazer, tente passar esse programa que está em assembly para a linguagem C e me devolva.

Não tenha pressa.

Se quiser comercializar esse projeto, eu dou permissão desde que você divida comigo os seu lucros, meio a meio.

OBS: Veja o passatempo, se quiser...

Surid_7

Programa.txt outra folha.txt PIC16F627A_628A_648A.pdf

adicionado 18 minutos depois

@Isadora Ferraz

ERRATA: Não pratico o PIC C em 8051. Pratico a linguagem C no 8051.

Não fique chateada com o desafio (passatempo). Acho que você é inteligente e fiquei curioso.

.if · 22 de outubro de 2019

Pena que asm é literalmente coisa do passado pra mim. O que me fez lembrar que sim, já fui inteligente com ele: meu 1º contato foi com um 8049 (irmão velho do 51). Fiz um programa que funcionava (e teve utilidade! pasme!) baseando apenas nos opcodes que apareciam no conteúdo do assemblador .exe dele o qual eu abria com "pctools". Depois um pouquinho de asm z80. Mais tarde um relativamente complexo timer com display sem driver 7 segmentos, entradas, saídas em 5 pinos (!) com (pasme de novo) pic 12c509 com janelinha... acho que tenho ele até hoje. E sim em assembly.

E ainda mais offtopic.. já "remediei" programas pra meu próprio uso analisando e alterando opcodes de .exe e .dll com "hiew"... bons tempos. Hoje em dia olhando daqui de baixo ... afff... "como é que consegui chegar naquele pico?" kk

O preço de participar ativamente do forum: coisa da idade...contar histórias de si kk

Sim baixei seu programa. Mas de novo...asm... aff... nem sei se tento. Me conta como fez sua automação, pra que servia, o que faz e etc. Também publique o circuito.

Sobre o desafio... melhor pedir ajuda pro google kk. Tico e teco não dão conta disso. Gastei tudo lá atrás kk

edit...

Numa olhadela rápida... é um varre led pelos ports? Seu 1º programa? que nunca conseguiu esquecer?

22 de outubro de 2019

5 minutos atrás, Isadora Ferraz disse:

já fui inteligente

@Isadora Ferraz

Boa Tarde, de novo:

Me desculpe por te expor desse jeito . Às vezes sou impulsivo e inconsequente, coisa de Epimeteu (o que pensa depois).

É a tal busca incansável por afinidades, coisa de animal social .

Bem, como disse, é sucata de campainha sem-fio. Usei o transmissor como controle remoto e o receptor ligado à um relê. Funcionava assim:

-Um toque liga, um toque desliga (relê ligado à alimentação do rádio)

-Dois toques liga, dois toques desliga (relê ligado à iluminação da garagem)

-Três toques liga, três toques desliga (relê ligado a um outro equipamento)

...

No final tem um comando temporizado que acionava o alarme da garagem, para dar tempo de eu sair fora.

Quanto ao esquema, infelizmente se perdeu no passado, assim como o equipamento, mas dá para reconstituí-lo à partir do programa (esquema).

OBS: Ci com janelinha e Z80... Não precisava ir tão longe! Faltou falar daquele transistor japonês que parecia um capacitor eletrolítico

Brincadeira.

Surid_7

adicionado 46 minutos depois

1 hora atrás, Isadora Ferraz disse:

Numa olhadela rápida... é um varre led pelos ports? Seu 1º programa? que nunca conseguiu esquecer?

Boa Tarde:

@Isadora Ferraz

Meu primeiro programa que deu certo, como o primeiro sutiã ( vocês nunca esquecem).

Me desculpe, sou meio careta, não entendi o termo "varre leds"(sério).

Vou explicar:

Os pulsos do controle remoto incrementam a variável TREM
Aí tem tem um código que simula o IF (MACRO JPE):
-Se TREM = 1, desvia para um trecho para tratamento (TRATA_1)

A Macro COMBF inverte a saída, se estava ligado, desliga, se estava desligado, liga.

As saídas estão todas ligadas em relês (não leds).

O resto é fácil.

Essa mobilidade toda do ASM que eu não consigo reproduzir em C, essa agilidade.

Surid_7

.if · 22 de outubro de 2019

Relax amigo. De fato eu escolho o que expor, entende? Meu "contrato" com o forum me permite isso kk.

Quando vi isso...

COMBF    MACRO    REG,BIT
    IF (BIT==0)
        MOVLW    B'00000001'
    ENDIF
    IF (BIT==1)
        MOVLW    B'00000010'
    ENDIF
    IF (BIT==2)
        MOVLW    B'00000100'
    ENDIF

...

...

TRATA_1:
        COMBF     PORTA,0
        CLRF     TREM
        RETFIE
    TRATA_2:
        COMBF     PORTA,1
        CLRF     TREM
        RETFIE
    TRATA_3:
        COMBF     PORTA,2
        CLRF     TREM
        RETFIE

...já imaginei um led andando pelo PORTA. Algo como...

45 minutos atrás, Surid_7 disse:

reconstituí-lo à partir do programa

Sou phd em pisca led kk

45 minutos atrás, Surid_7 disse:

-Um toque liga, um toque desliga (relê ligado à alimentação do rádio)

-Dois toques liga, dois toques desliga (relê ligado à iluminação da garagem)

-Três toques liga, três toques desliga (relê ligado a um outro equipamento)

Fazer isso em c é relativamente fácil. O pulo do gato é "zerar a contagem quando tecla não pressionada por determinado tempo sendo este maior do que o intervalo de tempo de controle". Entre aspas pois seria o coração do sistema. Não consigo pensar muito agora (se é que algum dia consegui) mas (olha o passado aí de novo) me lembro que fiz exatamente isso com 68hcxxx no século passado. Era algo como detectar clique, clique duplo, clique mantido e etc.: 1 botão controlava um patuá de coisa. Talvez algum dia eu ache o fonte. De fato um timer se faz necessário. Vejamos uma baita chute sem consultar o fonte...

if (!RB0) {TMR0=0;a++;while(!RB0);} //zera tempo, incrementa, espera soltar tecla
if (TMR0>100) a=0; //TMR0 está a rodar livre
if (a==1) RA1^⁼1; //1 clique inverte relé 1
if (a==2) RA2^⁼1; //duplo ... relé2
if (a==3) RA3^⁼1; //triplo ... 3

Sei lá... Tomara que não dê certo pois imagine isso daí substituindo todo aquele trabalho seu?

abç

22 de outubro de 2019

16 minutos atrás, Isadora Ferraz disse:

if (!RB0) {TMR0=0;a++;while(!RB0);} //zera tempo, incrementa, espera soltar tecla if (TMR0>100) a=0; //TMR0 está a rodar livre if (a>=1) RA1^⁼1; //inverte relé 1 if (a>=2) RA2^⁼1; //2 if (a>=3) RA3^⁼1; //3

@Isadora Ferraz

Boa Tarde:

Sou meio lento em linguagem C, por isso vou analisar com calma esses códigos para argumentar corretamente e não ficar perguntando coisas óbvias para você.

Com certeza o código em C vai ficar menor que o código em ASM (para escrever).

Infelizmente não vou ter como testar na prática, mas confio na tua habilidade como programadora.

Se o teu raciocínio for lógico, coerente, deve estar correto.

Segue anexo ajuda

Surid_7

INTRUÇÕES MPASM.pdf

.if · 23 de outubro de 2019

De fato o programinha que digitei online tende a não funcionar e foi uma tentativa semifrustrada de fazer algo didático. Mas modéstia à parte, nada mal por ter sido digitado em minutos né?

13 horas atrás, Surid_7 disse:

Se o teu raciocínio for lógico, coerente, deve estar correto

sqn kk.

13 horas atrás, Surid_7 disse:

código em C vai ficar menor que o código em ASM (para escrever)

Creia-me: um bom compilador o deixa como se fosse feito em asm por um programador mediano. Já um compilador bom de verdade deixa até mesmo menor do que fez um excelente e experiente programador asm. Experiência própria.

Como teu desafio é relativamente simples, cogito a qualquer momento criar algo com sua entrada de projeto:

15 horas atrás, Surid_7 disse:

-Um toque liga, um toque desliga (relê ligado à alimentação do rádio)

-Dois toques liga, dois toques desliga (relê ligado à iluminação da garagem)

-Três toques liga, três toques desliga (relê ligado a um outro equipamento)

Além de didático, eventualmente pode ser algo com uso prático...

Aguarde... permaneça nesta página pressionando F5 ... ou visite-a pelo menos uma vez por ano.

23 de outubro de 2019

3 horas atrás, Isadora Ferraz disse:

Além de didático, eventualmente pode ser algo com uso prático...

Aguarde... permaneça nesta página pressionando F5 ... ou visite-a pelo menos uma vez por ano.

@Isadora Ferraz

Bom Dia:

21 horas atrás, Surid_7 disse:

Talvez você queira me ajudar nisso !

Não tenha pressa. Encarar esse desafio é opcional. Passar esse meu projeto ASM para a linguagem C é tarefa para aqueles dias de inverno, sábado à noite, quando todos os seus amigos foram viajar e só você ficou para trás e nada está passando de bom na televisão...

Pode ser simples mas é um desafio para os apreciadores da linguagem C. ( No seu lugar, eu faria isso por pura diversão, mas somos diferentes).

É algo que já funcionou, que ficou anos em operação na minha casa e que sucumbiu ao tempo, como todas as coisas.

Devo ter o chip ainda gravado em algum lugar mas o hardware desapareceu...

Seria mais pela minha curiosidade em ver todas as manobras do programa ASM, toda sua agilidade, todo o seu dinamismo reproduzido numa outra linguagem (C).

Eu me lembro que anteriormente à essa época, em que eu criei esse programa, ví numa revista um projeto de alarme para carro em ASM para o cop8. Passei tudo para o PIC ASM sem qualquer dificuldade.

Peguei leve com você, moça!

OBS: Não querendo me gabar, eu sei que todos vocês são bons em eletrônica mas, ainda bem que eu não passei meu mais recente projeto, de 80 páginas (esse não dá nem para falar, tenho que permanecer anônimo). Você enlouqueceria tentando passá-lo para a linguagem C...(brincadeira)

Ele é tão extenso que toda a vez que eu tenho que fazer um upgrade, tenho que passar alguns dias estudando, para fazer as alterações senão eu mesmo me perco.

OBS2: Isso dá para falar: Digitando num teclado a sequência incorreta de números, ele travava e só voltava a funcionar após a introdução de uma senha secreta gravada em eeprom de 9 números.

Surid_7

adicionado 31 minutos depois

4 horas atrás, Isadora Ferraz disse:

Além de didático, eventualmente pode ser algo com uso prático...

Aguarde... permaneça nesta página pressionando F5 ... ou visite-a pelo menos uma vez por ano.

@Isadora Ferraz

Bom Dia:

É claro que pode ter uso prático! Um único botão que comanda até 10 (ou nove, não lembro) equipamentos, é inovador! Mas lembre-se :somos sócios, meio a meio senão nos veremos nos tribunais

.if · 23 de outubro de 2019

Teste...

23 de outubro de 2019

3 horas atrás, Isadora Ferraz disse:

Teste...

Boa Noite:

Conseguiu reproduzir meu projeto e incluiu (sem permissão) uma função a mais...

Questions:

- Essa simulação foi feita à partir de algum programa em C?

- Por que não publicou o programa em C?

- Vai me mostrar como fez?

Bom trabalho ( Por isso que ficou quieta o dia inteiro)

Surid_7

adicionado 6 minutos depois

55 minutos atrás, Surid_7 disse:

Conseguiu reproduzir meu projeto e incluiu (sem permissão) uma função a mais...

@Isadora Ferraz

Errata:

Me perdoe... Fiquei surpreso e ligeiramente confuso. Não tem função a mais, só o led pisca-pisca.

Parabéns! Me surpreendeu...

Surid_7

.if · 23 de outubro de 2019

#define releA RB7
#define releB RB6
#define releC RB5
#define releD RB4
#define releE RB3
#define releF RB2
#define releG RB1
#define releH RB0
#define led RA1
#define bt RA0
#define tm1h        0xfd //int timer1 400Hz @8MHz e prescaler /8
#define tm1l        0x8f 

#include    <pic.h>
// ************************ configuração ***********************
__CONFIG(FOSC_INTOSCIO&WDTE_OFF&PWRTE_ON&MCLRE_OFF&BOREN_ON&LVP_OFF);

unsigned char t,a,tmp;

/**********************************************************************/
//interrupção timer1
/**********************************************************************/
void interrupt timer1(void)
{
TMR1IF=0;
TMR1H=tm1h;     //restaura 400Hz int
TMR1L=tm1l;
t++;
if (!tmp++) led^=1;
}

/**********************************************************************/
void  main(void)
{
TRISA=0b00000001; 
TRISB=0b00000000; 
PORTA=0;
PORTB=0;
T1CON=0b00110101;   // prescaler/8 timer1 on
TMR1H=tm1h;         // int. 400Hz
TMR1L=tm1l;
TMR1IF=0;           //zera flag timer1
TMR1IE=1;           //hab. int. timer1
PEIE=1;
RBIE=0;
RBIF=0;
CMCON=0x07;//tudo digital
GIE=1; 

for(;;)
{
if (!bt) {a++;t=0;while(!bt);while(t<5);}
if (t>100)
   {
   if (a==1) releA^=1;
   if (a==2) releB^=1;
   if (a==3) releC^=1;
   if (a==4) releD^=1;
   if (a==5) releE^=1;
   if (a==6) releF^=1;
   if (a==7) releG^=1;
   if (a==8) releH^=1;
   a=0;
   }
}
}

Qualquer momento publico o asm que o compilador gerou...

Só não vale ganhar dinheiro com isso

24 de outubro de 2019

26 minutos atrás, Isadora Ferraz disse:


#define releA RB7
#define releB RB6
#define releC RB5
#define releD RB4
#define releE RB3
#define releF RB2
#define releG RB1
#define releH RB0
#define led RA1
#define bt RA0
#define tm1h        0xfd //int timer1 400Hz @8MHz e prescaler /8
#define tm1l        0x8f 

#include    <pic.h>
// ************************ configuração ***********************
__CONFIG(FOSC_INTOSCIO&WDTE_OFF&PWRTE_ON&MCLRE_OFF&BOREN_ON&LVP_OFF);

unsigned char t,a,tmp;

/**********************************************************************/
//interrupção timer1
/**********************************************************************/
void interrupt timer1(void)
{
TMR1IF=0;
TMR1H=tm1h;     //restaura 400Hz int
TMR1L=tm1l;
t++;
if (!tmp++) led^=1;
}

/**********************************************************************/
void  main(void)
{
TRISA=0b00000001; 
TRISB=0b00000000; 
PORTA=0;
PORTB=0;
T1CON=0b00110101;   // prescaler/8 timer1 on
TMR1H=tm1h;         // int. 400Hz
TMR1L=tm1l;
TMR1IF=0;           //zera flag timer1
TMR1IE=1;           //hab. int. timer1
PEIE=1;
RBIE=0;
RBIF=0;
CMCON=0x07;//tudo digital
GIE=1; 

for(;;)
{
if (!bt) {a++;t=0;while(!bt);while(t<5);}
if (t>100)
   {
   if (a==1) releA^=1;
   if (a==2) releB^=1;
   if (a==3) releC^=1;
   if (a==4) releD^=1;
   if (a==5) releE^=1;
   if (a==6) releF^=1;
   if (a==7) releG^=1;
   if (a==8) releH^=1;
   a=0;
   }
}
}

Qualquer momento publico o asm que o compilador gerou...

Só não vale ganhar dinheiro com isso

@Isadora Ferraz

Boa Noite:

Obviamente não é para mim esse recado, já que o programa é meu.

Agradeço o trabalho que você fez, agora eu posso comparar o programa em ASM com o programa em C e tirar minhas conclusões.

Ficou menor, hein?

A impressão que ficou é que economizamos neurônios com a linguagem C, parece tudo tão simples...

Você não tem o costume de comentar seus programas? Me ajudaria a entender como é que você fez tudo isso...

Vou me debruçar em meus livros e tentar entender como é que você fez isso... (lembrando que eu sou "virgem" em linguagem PIC C, conheço um pouco mais do C usado em 8051 e do "C" usado no arduíno).

Surid_7

.if · 24 de outubro de 2019

10 horas atrás, Surid_7 disse:

linguagem PIC C, conheço um pouco mais do C usado em 8051

Ao contrário do ditado popular, "gosto e C, cada um tem tem o seu", o C é igual pra todos. O que difere é a inicialização do hw de cada mc que obviamente é diferente.

Quanto aos comentários, sim mas faço-os quando é algo inerente ao projeto e não quanto à linguagem c pura.

Mas já que insistes, o coração é este:

if (!bt) {a++;t=0;while(!bt);while(t<5);}

if (!bt)... !=NOT ou seja "se RA0=0"... poderia fazer if (RA0==0) mas quero poupar teclado

a++ ... incremente (ou some um à) a variável a

t=0 ... zera tempo (só pra lembrar, ele vai ser incrementado sozinho na interrupt)

while(!bt) ... 'enquanto' não soltar o botão, fique aqui

while(t<5) ... 'enquanto' não passar um tempinho, fique aqui (lembra que t está 'passando' na interrupt?)

if (t>100) { if (a==1) releA^=1; ... depois de um certo tempo, verifique os valores de a.

'se' 1, inverta (^=EXCLUSIVE OR) o que tiver no bit do port releA

...

a=0; ... pra recomeçar