Interrupção com PIC 16F628A

Software: proteus 2010

Código feito em CCS C Compiler

#include <16f628a.h>

#fuses intrc_io, nowdt, mclr//fuses bits

#use delay(clock = 4MHz)

#use fast_io(a)//diretiva otimiza o programa e evita mudanças no decorrer

#use fast_io(b)

#INT_RB // interrupucao

//função de interrupção

void RB(void){

   

   output_high(pin_a0);

   delay_ms(500);

   output_low(pin_a0);

   delay_ms(500);

   

}

void main(void){

   //tris_a tudo como saída

   set_tris_a(0x00);

   set_tris_b(0xf0);//metade como entrada e metade como saída

   output_b(0x00);//para todo port

   

   //senão colocar enable, nenhum tipo de interrupção irá acontecer

   ENABLE_INTERRUPTS(INT_RB);//habilitando a interrupção RB

   ENABLE_INTERRUPTS(GLOBAL);//HABILITANDO A INTERRUPÇÃO GERAL

   

   while(true){

   

      output_b(0xff);//vai colocar tudo como saída

      delay_ms(500);

      output_b(0x00);//

      delay_ms(500);

      

   }

}

Memória EPROM 3 com PIC 18F4550

Objetivo: Gravar na memória EPROM com a interrupção

Código feito em CCS C Compiler

#include <18f4550.h>

#device ADC=8

#FUSES xt, put, nowdt, nomclr//fuses bits

#use delay(crystal = 20M)

#use fast_io(a)//ports com as diretivas

#use fast_io(b)

#use fast_io(c)

#use fast_io(d)

#include <lcd.c>

#INT_EXT//interrupção externa gerada pelo pino a0

//função 

void senha(void){

   

   write_eeprom(1,2);//escreve no endereço 1 o número 2

   write_eeprom(2,0);

   write_eeprom(3,1);

   write_eeprom(4,4);

   output_b(0x00);//vai externa no port b tudo 0

   delay_ms(1000);

   output_high(pin_e0);//vai externar no pino e0 o nível logico alto

   delay_ms(2000);

   output_low(pin_e0);//vai externar em nível baixo nesse pino

   delay_ms(2000);

   output_low(pin_e0);

   delay_ms(1000);

   lcd_putc(" \f   SENHA GRAVADA\n   COM SUCESSO");

   delay_ms(1000);

   

}

void main(void){

   

   set_tris_a(0xff);//port como entrada

   set_tris_b(0x01);//port como saída

   output_b(0x00);//externando o port b como 0

   

   enable_interrupts(int_ext);//habilitando a interrupção externa

   enable_interrupts(global);//habilitando a chave geral

   lcd_init();

   lcd_putc("  FAVOR GRAVAR\nSENHA:");

   

   while(true){

      

      output_b(0xff);//externando tudo 1

      delay_ms(500);

      output_b(0x00);

      delay_ms(500);

      

      //quando houver 1 interrupção, irá chamar a função

   }

}

Memória EPROM 2 com PIC 16F877A

Código feito em CCS C Compiller

#include <16f877a.h>

#device ADC=8

#FUSES NOWDT

#FUSES NOBROWNOUT

#FUSES NOLVP

#use delay(crystal = 20M)

#use fast_io(a)

#use fast_io(b)

#INT_EEPROM

//função 

void eprom(void){

   output_high(pin_b0);

   delay_ms(500);

   output_low(pin_b0);

   delay_ms(500);

   

}

void main(void){

   

   set_tris_a(0xff);//port como entrada

   set_tris_b(0x00);//port como saída

   output_b(0x00);

   enable_interrupts(GLOBAL);

   enable_interrupts(INT_EEPROM);

   

   write_eeprom(1, 0xff);//escrevendo no endereço e atribuindo ao endereço ff

   write_eeprom(2, 0x00);

   

   while(true){

      

      output_b(read_eeprom(1));//externando o port b no endereço 1

      delay_ms(500);

      output_b(read_eeprom(2));//externando o port b no endereço 2

      delay_ms(500);

      write_eeprom(1, 0xff);

      write_eeprom(2, 0x00);

      

   }

}

Iframe em HTML

Código:

<iframe src="https://www.youtube.com/embed/MANF9kLUPWg" width="250" height="250" allowfullscreen></iframe>

Memória EPROM 1 com PIC 16F84A

Código feito em CCS C Compiler

#include <16f84a.h>

//xt= oscilador crystal , nowdt= desabilitando

#fuses xt, nowdt, put//put= habilitando o temporizador inicial

#use delay(clock = 20MHz)

#use fast_io(a)

#use fast_io(b)

void main(void){

   

   set_tris_a(0xff);//port como entrada

   set_tris_b(0x00);//port como saída

   output_b(0x00);//

   

   //tratamento de dados

   write_eeprom(1, 0xff);//colocando no endereco 1 o valor ff em decimal

   write_eeprom(2, 0x00);//escrevendo no endereco 2 tudo 0

   

   while(1){

      

      output_b(read_eeprom(1));//colocando como argumento para ler o endereco 1 da memória eeprom

      delay_ms(500);

      output_b(read_eeprom(2));//colocando como argumento para ler o endereco 2 da memória eeprom

      delay_ms(500);

      

   }

}

Desafio Promise 1 em JavaScript

Objetivo: Encapsule dentro de uma promise a chamada do File System

const fs = require('fs')

const path = require('path')

const { resolve } = require('path')

function lerArquivo(caminho) {

    return new Promise(resolve =>{

        fs.readFile(caminho, function(_, conteudo) {//caminho como parâmetro

            resolve(conteudo.toString())//converte o conteúdo no formato String

        })

        console.log('Depois de ler');

    })

}

const caminho = path.join(__dirname, 'dados.txt')

lerArquivo(caminho)

    .then(conteudo => console.log(conteudo))

    //.then(conteudo => conteudo.split('\n'))

    //.then(linhas => console.log(linhas[1]))

    //.then(linhas => console.log(linhas.length));

    

Arquivo: dados.txt

Canal Analógico 4 com indicador de temperatura no PIC 16F877A

Código feito em CCS C Compiler

#include <16f877a.h>

#device ADC = 8 //RESOLUÇÃO DE 8 BITS

#use delay(clock= 20MHz)

#use fast_io(a)

#use fast_io(b)

#use fast_io(c)

#use fast_io(d)

#include <lcd.c>

void main(void){

   float data, temperatura, tensao;//bits

   

   

   SETUP_ADC_PORTS(AN0);

   SETUP_ADC(ADC_CLOCK_INTERNAL);//SINAL INTERNO PARA CONVERSÃO

   SET_ADC_CHANNEL(0);//SETANDO CANAL EM 0

   

   lcd_init();

   

   while(true){

      

      data = (float) (read_adc());//converte o valor analogico

      delay_ms(10);

      tensao = (5000.0 / 1023) * data;//5000= tensao , 1023= canal analogico

      temperatura = (tensao) / 10;//10= milivolts que é do LM35

      //No datasheet a cada 10 milivolts corresponte a 2 graus

      printf(lcd_putc,"\f  TEMPERATURA: \n   %1f Graus ",temperatura);

      delay_ms(500);

      

   }

}

Palavras chave:

Analog Channel 4 cu indicator de temperatură pe PIC 16F877A

Analog Channel 4 yokhala ndi chizindikiro cha kutentha pa PIC 16F877A

Analog Channel 4 พร้อมตัวบ่งชี้อุณหภูมิบน PIC 16F877A

ערוץ 4 אנלוגי עם מחוון טמפרטורה ב- PIC 16F877A

Kanał analogowy 4 ze wskaźnikiem temperatury na PIC 16F877A

ანალოგური არხი 4 ტემპერატურის მაჩვენებლით PIC 16F877A

Analog Channel 4 with temperature indicator on PIC 16F877A

Аналоговый канал 4 с индикатором температуры на PIC 16F877A

Аналогов канал 4 с индикатор за температура на PIC 16F877A

Canal analògic 4 amb indicador de temperatura a PIC 16F877A

Canal Analógico 3 com PIC 16F877A

Objetivo: Exibir em um display LCD o valor real da tensão aplicada

Código feito em CCS C Compiler:

#include <16f877a.h>

#device ADC = 8 //RESOLUÇÃO DE 8 BITS

#use delay(clock= 4MHz)

#use fast_io(a)

#use fast_io(b)

#use fast_io(c)

#use fast_io(d)

#include <lcd.c>

void main(void){

   float data, tensao;//bits

   

   

   SETUP_ADC_PORTS(AN0);

   SETUP_ADC(ADC_CLOCK_INTERNAL);//SINAL INTERNO PARA CONVERSÃO

   SET_ADC_CHANNEL(0);//SETANDO CANAL EM 0

   

   lcd_init();

   

   while(true){

      

      data = (float) (read_adc());//converte o valor analogico

      delay_ms(50);

      tensao = (5.0 / 255.0) * (data);//valor real da tensão

      printf(lcd_putc,"\f TENSAO = %f ",tensao);

      delay_ms(1000);

      

   }

}

Canal Analógico 2 com PIC 18F4550

Código feito em CCS C Compiler

#include <18f4550.h>

#device ADC = 10//resolução de 10 bits

//#device ADC = 8 //RESOLUÇÃO DE 8 BITS

#fuses INTRC_IO, NOWDT, NOMCLR

#use delay(clock= 4MHz)

#use fast_io(a)

#use fast_io(b)

#use fast_io(c)

#include <lcd.c>

void main(){

   long data;//bits

   

   

   SETUP_ADC_PORTS(AN0_TO_AN1|VSS_VREF);//CANAL 1 | TENSÃO EXTERNA DE REFERÊNCIA

   SETUP_ADC(ADC_CLOCK_INTERNAL);//SINAL INTERNO PARA CONVERSÃO

   SET_ADC_CHANNEL(1);//SETANDO CANAL EM 1

   

   lcd_init();

   

   while(true){

      

      data = read_adc();//converte o valor analogico em binario

      delay_ms(50);

      printf(lcd_putc,"\f VALOR = %Lu ",data);

      delay_ms(500);

      

   }

}

Promise 03 em JavaScript

//Objetivo: gerar numeros entre

function gerarNumerosEnte(min, max) {

    if(min > max){

        [max, min] = [min, max]

        const [x, y] = a

    }

    //valor aleatório

    return new Promise(resolve => {

        const fator = max - min + 1

        const aleatorio = parseInt(Math.random() * fator) +min

        resolve(aleatorio)

    })

}

gerarNumerosEnte(5, 20).then(console.log)

gerarNumerosEnte(7, 40)

    //composição de função

    .then(num => num * 10)//número multiplicado por 10

    .then(numX10 => `O número gerado foi ${numX10}`)

    .then(console.log)//imprimindo o valor

Canal Analógico 1 com PIC 18F4550

Código feito em CCS C Compiler

#include <18f4550.h>

//#device ADC = 10//resolução de 10 bits

#device ADC = 8 //RESOLUÇÃO DE 8 BITS

#fuses INTRC_IO, NOWDT, NOMCLR

#use delay(clock= 4MHz)

#use fast_io(a)

#use fast_io(b)

#use fast_io(c)

#include <lcd.c>

void main(){

   long data;//bits

   

   

   SETUP_ADC_PORTS(AN0);//canal AN0

   SETUP_ADC(ADC_CLOCK_INTERNAL);//SINAL INTERNO PARA CONVERSÃO

   SET_ADC_CHANNEL(0);//SETANDO EM 0

   

   lcd_init();

   

   while(true){

      

      data = read_adc();//converte o valor analogico em binario

      delay_ms(50);

      printf(lcd_putc,"\f VALOR = %Lu ",data);

      delay_ms(500);

      

   }

}

Promise 02 em JavaScript

setTimeout(function(){

    console.log('1- Executando callback ...');

    setTimeout(function() {

        console.log('2- Executando o callBack...');

        setTimeout(function(){

            console.log('3- Novamente Executando o callback...');

        },2000)

    },2000)

}, 2000)//executa o callback depois de 2 seg

PiscaLeds para efeito de Natal com PIC 16FF877A

Código do circuito feito em CCS C Compiler

#include <16F877A.h>

#use delay(clock=20M)

#fuses XT

#use fast_io(a)

#use fast_io(b)

#byte portb = 0x06

int valor1 = 255, valor2 = 0, valor3= 0x33, valor4= 0xcc;

int valor5 = 0252, valor6= 0125, valor7= 0b11100011, valor8= 0b00011100;

int cont;

void main(void){

   set_tris_b(0x00);

   set_tris_a(0xff);

   output_b(0x00);

   

   while(true){

      

      for(cont =0; cont <= 5; cont++){

         portb = valor1;

         delay_ms(300);

         portb = valor2;

         delay_ms(300);

      }

      

      for(cont =0; cont <= 5; cont++){

         portb = valor3;

         delay_ms(300);

         portb = valor4;

         delay_ms(300);

      }

      

      for(cont =0; cont <= 5; cont++){

         portb = valor5;

         delay_ms(300);

         portb = valor6;

         delay_ms(300);

      }

      

      for(cont =0; cont <= 5; cont++){

         portb = valor7;

         delay_ms(300);

         portb = valor8;

         delay_ms(300);

      }

      

      for(cont =0; cont <= 5; cont++){

         output_b(0x0f);

         delay_ms(500);

         portb = valor2;

         delay_ms(500);

      }

   }

}

Promise 01 em JavaScript

//Método 1

let p = new Promise(function(cumprirPromesa) {

    cumprirPromesa({

        x: 3,

        y: 4

    })

})

p.then(function(valor) {

    console.log('MÉTODO 1');

    console.log(valor);

    console.log(valor.x);//pegando apenas o valor x

})

//com vetor método 2

let q = new Promise(function(exibirPromesa){

    exibirPromesa(['Ana Paula','Aline','Juliana','Karolayne'])

})

q.then(function (imprimir){

    console.log(imprimir);

    console.log(imprimir[2]);//imprimir a posição 2

})

//método 3, reaproveitando o método 2

q.then((teste) => console.log('\n',teste));

q.then(novo => console.log(novo[1]));

//Método 4

let t = new Promise(function(exibirArray){

    exibirArray(['Meiryele','Geisiane','Laiane','Loiane'])

})

function primeiroElemento(array) {

    return array[0]

}

function primeiraLetra(string) {

    return string[0]

}

t

    .then(primeiroElemento)

    .then(primeiraLetra)

    .then(caracter => caracter.toLowerCase())//convertendo para minuscula

    .then(letraM => console.log(letraM));

Contador usando Latch NOR

Async / Await em JavaScript

// sem promise...

const http = require('http');

const { reject } = require('lodash');

const getTurma = (letra, callback) => {

    const url = `http://files.cod3r.com.br/curso-js/turma${letra}.json`

    return new Promise((resolve, reject) =>{

        http.get(url, res =>{

            let resultado = ''

            res.on('data', dados => {

                resultado += dados

            })

            res.on('end', () => {

                try{

                    resolve(JSON.parse(resultado))

                }catch(e){

                    console.log('Erro ao acessar !');

                    reject(e)

                }

            })

        })

    })

}

//Recurso em ES8

//Objetivo: simplificar o uso de promises ...

let obterAlunos = async() => {

    const ta = await getTurma('A')

    const tb = await getTurma('B')

    const tc = await getTurma('C')

    return [].concat(ta, tb, tc)

}

obterAlunos()

    .then(alunos => alunos.map(a => a.nome))

    .then(nomes => console.log(nomes))

Palavras chave:

Async / Attendre le JavaScript

Async / Čekejte na JavaScript

Async / המתן JavaScript

Async / wag op JavaScript

Async / Așteptați-i JavaScript

Refatorando CallBacks para Promises em JavaScript

// sem promise...

const http = require('http');

const { reject } = require('lodash');

const getTurma = (letra, callback) => {

    const url = `http://files.cod3r.com.br/curso-js/turma${letra}.json`

    return new Promise((resolve, reject) =>{

        http.get(url, res =>{

            let resultado = ''

            res.on('data', dados => {

                resultado += dados

            })

            res.on('end', () => {

                try{

                    resolve(JSON.parse(resultado))

                }catch(e){

                    console.log('Erro ao acessar !');

                    reject(e)

                }

            })

        })

    })

}

//dispara paralelamente

let nomes = []

getTurma('A').then(alunos => {

    nomes = nomes.concat(alunos.map(a => `A: ${a.nome}`))

    getTurma('B').then(alunos => {

        nomes = nomes.concat(alunos.map(a => `B: ${a.nome}`))

        getTurma('C').then(alunos => {

            nomes = nomes.concat(alunos.map(a => `C: ${a.nome}`))

            console.log(nomes)

        })

    })

})

 //todos os elementos em 1 único array

console.log();

Promise.all([getTurma('A'), getTurma('B'), getTurma('C')])

    .then(turmas => [].concat(...turmas))

    .then(x => console.log(x))

console.log();

Promise.all([getTurma('A'), getTurma('B'), getTurma('C')])

    .then(turmas => [].concat(...turmas))

    .then(turmas => alunos.map(aluno => aluno.nome))

    .then(nomes => console.log(nomes))

    .catch(e => console.log(e.message))

//Mensagem de erro caso o arquivo não exista    

//getTurma('D'.catch(e => console.log(e.message)))

CallBacks Aninhadas em JavaScript

// sem promise...

const http = require('http')

const getTurma = (letra, callback) => {

    const url = `http://files.cod3r.com.br/curso-js/turma${letra}.json`

    http.get(url, res => {

        let resultado = ''

        res.on('data', dados => {

            resultado += dados

        })

        res.on('end', () => {

            callback(JSON.parse(resultado))

        })

    })

}

let teste = []

getTurma('A', pessoas1 => {

    console.log(pessoas1);//todos os índices

    console.log('\n',pessoas1[0]);//1° índice

    console.log('\n',pessoas1[0].nome);// somente o nome do 1° índice

})

console.log();

let nomes = []

getTurma('A', alunos => {

    nomes = nomes.concat(alunos.map(a => `A: ${a.nome}`))

    getTurma('B', alunos => {

        nomes = nomes.concat(alunos.map(a => `B: ${a.nome}`))

        console.log(nomes);

        getTurma('C', alunos => {

            nomes = nomes.concat(alunos.map(a => `C: ${a.nome}`))

            console.log(nomes)

        })

    })

})

For of em JavaScript

const { map } = require("lodash");

for (let letra of "Blog "){

    console.log(letra);

}

const assutosEcma = ['Map', 'Set', 'Promise']

for (let i in assutosEcma){

    console.log(i);

}

console.log();

for (let assunto of assutosEcma) {

    console.log(assunto);    

}

const assuntosMap = new Map([

    ['Map', {abordado: true}],

    ['Set', {abordado: true}],

    ['Promise', {abordado: false}]

])

console.log();

//chaves e valores do array

for(let assunto of assuntosMap){

    console.log(assunto);

}

console.log();

for(let [chave, valor] of assuntosMap){

    console.log(chave);

}

console.log();

//percorrendo somente as chaves

for(let chave of assuntosMap.keys()){

    console.log(chave);

}

console.log();

//desestruturando 1 array com chave e  valor

for(let [ch, vl] of assuntosMap.entries()){

    console.log(ch, vl);

}

console.log();

const s = new Set(['a', 'b', 'c'])

for(let letra of s){

    console.log(letra);

}

Set em JavaScript

//Set não é um conjunto indexada e que não aceita repetição

const times = new Set()

times.add('Vasco')

times.add('São Pauo').add('Palmeiras').add('Corinthians')

times.add('Flamengo')

times.add('Vasco')//não vai adicionar, elemento repetido

console.log(times);

console.log(times.size);//tamanho

console.log(times.has('vasco'));//false

console.log(times.has('Vasco'));//true

times.delete('Flamento')//deletando Flamento

console.log(times.has('Flamento'));

//só vai adicionar 1 Lucas

const nomes = ['Raquel', 'Lucas', 'Julia', 'Lucas']

const nomesSet = new Set(nomes)

console.log(nomesSet);

Tagged Template 02 em JavaScript

function real(partes, ...valores) {

    const resultado = []

    valores.forEach((valor, indice) =>{

        valor = isNaN(valor) ? valor : `R$${valor.toFixed(2)}`

        resultado.push(partes[indice], valor)

    })

    return resultado.join('')

}

const preco = 29.99

const precoParcela = 11

console.log(real `1x de ${preco} ou 3x de ${precoParcela}.`);

Rest/Spread em JavaScript

//Operador ... rest(juntar)/spread(espalhar)

//usar rest com parâmetro de função

//usar spread com objeto

const funcioario = {

    nome: 'Henrique',

    salario: 12500.55

}

//cópia

const clone = {//espalha os elementos

    ativo: true,

    ...funcioario

}

console.log(clone);

const grupoA = ['João', 'Pedro', 'Glória']

//espalhando os atributos de 1 array dentro de outro array

const grupoFinal = ['Maria', ...grupoA, 'Rafael']

console.log(grupoFinal);

Revisão 03 em JavaScript

//ESB: Object.values/Object.entries

const obj = {a: 1, b: 2, c: 3}

console.log(Object.values(obj));

console.log(Object.keys(obj));

console.log(obj);

console.log(Object.keys(obj).entries(obj));

console.log(Object.entries(obj));//1 array de arrays com chave e valor

//Melhorias na Notação Literal

const nome = 'Carla'

const pessoa = {

    nome, 

    ola(){

        return 'Bem vindo ao JavaScript !'

    }

}

console.log(pessoa.nome, ' : ',pessoa.ola());

//Class

class Avo{}

class Pai extends Avo{

    falar(){

        return 'Olá eu sou herança !'

    }

}

console.log(new Cachorro().falar());

Revisão 02 em JavaScript

const { isNull } = require("lodash");

//Arrow Function

const soma = (a, b) => a + b//retorna a + b

console.log(soma,'Soma = ',soma(5, 7));

//Arrow Function(this)

//this esta associado ao local onde a função foi escrita

const lexico1 = () => console.log(this === exports);//this sempre apontará para exports

const lexico2 = lexico1.bind({})//forçando 1 barra, mas não irá funcionar

lexico1()

lexico2()

//parametro default

function log(texto = 'Node') {

    console.log(texto);

}

log();

log('Olá ! Bem Vindo ao JavaScript. ');

log(null);

log(isNull)

//Operador rest

function total(...numeros) {

    let total = 0

    numeros.forEach(n => total += n);

    return total

}

console.log('Total = '+total(2, 3, 4, 5));