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));

Revisão 01 em JavaScript

{

    var a = 2

    let = 3

}

console.log(a);

//console.log(b);//não consegue acessar por estar reservada

//Template String

const produto = 'iPad'

console.log(`${produto} é muito caro !`);

//Destructuring

const [l, e, k, ...tras] = "BLOG engenhariaCotidiana"

console.log(l, e, k);

console.log(tras,'\n');

const[x, , y] = [1,2, 3]

console.log(x,y);

//Desestruturar usa chaves

const {idade: i, nome} = {nome: 'Ana', idade: 9}

console.log(i, nome);

Exercício Série de Fourier em Tempo Discreto

2) Use a Equação de análise para calcular os valores numéricos de um período dos coeficientes da série de Fourier do sinal periódico 

Resolução:

3) Seja x[n] um sinal periódico real e ímpar com período N = 7 e coeficientes de Fourier ak . Dado que

a15 = j, a16 = 2j, a17 = 3j , determine os valores de a0 , a–1 , a–2 e a–3 .

Resolução:

Middlewares 01 em JavaScript

const passo1 = (ctx, next) =>{

    ctx.valor1 = 'mid1'//adc dentro desse objeto

    next()

}

const passo2 = (ctx, next) =>{

    ctx.valor2 = 'mid2'

    next()

}

const passo3 = ctx => ctx.valor3 = 'mid3'

const exec = (ctx, ...middlewares) =>{

    const execPasso = indice =>{//executa o índice 

//se middlwares == true e índice middlw menor que o comprimento passado

        middlewares && indice < middlewares.length &&

            middlewares[indice](ctx, () => execPasso(indice +1))

    }

    execPasso(0)//dispara a execução

}

//vai juntar em 1 array

const ctx = {}

exec(ctx, passo1, passo2, passo3)//forma interativa

console.log(ctx);

//não executa porque o passo passo3 não chama os outros

exec(ctx, passo3, passo2, passo1)

Palavras chave:

JavaScript Middlewares 01

Прамежкавы JavaScript JavaScript 01

JavaScript Middlewares 01

JavaScriptミドルウェア01

JavaScript Middlewares 01

Sinais periódicos em Série de Fourier

3.2)  Um sinais periódico de tempo discreto x[n] tem valor real e período fundamental N = 5. Os coeficientes da série de Fourier diferentes de zero de x[n] são:

Expresse x[n] na forma:

Resolução 1:

Resolução 2:

Escrevendo em arquivo com JavaScript

const fs = require('fs')

const produto = {

    nome: 'Celular',

    preco: 1249.99,

    desconto: 0.15

}

fs.writeFile(__dirname + '/arquivoGerado.json', JSON.stringify(produto), err => {

    console.log(err || 'Arquivo salvo!')

})

é gerado o arquivo: arquivoGerado.json com os dados de produto