top of page
JACOBSON.jpg

Meus projetos

Retornar

O que é eletrônica?

É o estudo do comportamento e do controle dos elétrons livres do  átomo

semicondutor e condutor.

Ela é uma ciência?

Sim.

Tudo que é estudado é uma ciência.

 

​

​

​

 

​

 

​

O uso intencional da ciência !

millis()

Realmente a compreensão do funcionamento da função millis()

é a princípio meio confusa, mas eu preparei um GIF que ajuda muito a compreender o funcionamento dessa função

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

Biblioteca MAX6675

Hexadecimal do OledSendPC

Veja o vídeo clicando na imagem

/* 
  ***********************************************
  * Visite o site "ESPAÇO DIGITAL em
  * https://sistemasnb.wixsite.com/sistemas-nb  
  * Software versão : Arduino 1.8.9
  * Firmware (Sketch) : Acelerômetro          "ADXL335B"
  * Data da criação  __/__/__ 
  * Autor : Brincando com Idéias
  * Modificado em _01_/06_/_19_  por :  Jacobson G. Ferreira
  * Descrição e nota : foi modificdo os parâmetros de 
  * inclinações para se adapitar com o acelerômetro ADXL335 deste lote  
  * Foi incluido seis LEDs para monitorar os movimentos X,Y,Z          
  * Fiz uso dos Registradores de Uso Geral com o intuito de simplificar
  * o programa (DDR e PORT)
  * Caso o seu acelerômetro não funcione corretamente, deve-se
  * alterar as coniguraçoes de inclinação também
  * **********************************************
  * Notei que há acelerômetros com mais ou menos senssibilidade que outros         
  * portanto, construi esta tabela de referência pra configureção "deste módulo" 
  *       |------------------------------------------------|
  *       |  posição normal x352 y352 z426                 |
  *       |  inclinado p/x  x282 y357 z354                 |
  *       |  inclinado p/y  x356 y252 z337                 |
  *       |  inclinado p/z  x356 y360 z286 (contra cabeça) |
  *       |------------------------------------------------|
  *       ADXL335 5V 3 pinos para comunicação x-out,y-out,z-out
  *       
  * pinos Arduino  |  pinos ATmega328 | REG Layout | 
  *       2        |      4           |   ->  PD2  |
  *       3        |      5           |   ->  PD3  |
  *       4        |      6           |   ->  PD4  |
  *       5        |      11          |   ->  PD5  |
  *       6        |      12          |   ->  PD6  |
  *       7        |      13          |   ->  PD7  |
 */

 #define habilita 1  // 1 habilita e 0 desabilita 

 #define A0_X A0      
 #define A1_Y A1
 #define A2_Z A2 
 
   void setup() 
   {     
      Serial.begin(115200);
      
      DDRB =  0x05;         // desabilita o pino 13 
      DDRD =  0xff;         // habilita todo PORTD em OUTPUT 
      PORTD = 0x00;         // nivela o PORTD em LOW
      //Serial.end();       // habilita/desabilita a com RX/TX   
   }                     

   void loop() 
   {       
      int valX = analogRead(A0_X);  // A0
      int valY = analogRead(A1_Y);  // A1
      int valZ = analogRead(A2_Z);  // A2
      
      //habilitar  para auxiliar na confguração
  #if habilita == 0
      Serial.print("  X: ");
      Serial.print(valX);

      Serial.print("  Y: ");
      Serial.print(valY);
   
      Serial.print("  Z: ");      
      Serial.println(valZ); 
  #endif
      
     #if habilita == 1
         if (valZ < 300) 
         {
            Serial.println(F(" Posição de (6 horas) eixo Z"));
            PORTD = 0x4;      //B00000100; // PORTD |= ( 1 << PORTD2 );      
         } 
         else if ((valZ < 370) && (valY < 290)) 
         {
            Serial.println(F(" Esquerda eixo Y"));
            PORTD = 0x8;      //B00001000;      
         } 
         else if ((valZ < 370) && (valY > 390)) 
         {
            Serial.println(F(" Direita eixo Y"));
            PORTD = 0x10;     //B00010000;     
         } 
         else if ((valZ < 370) && (valX < 300)) 
         {
            Serial.println(F(" Para Frente eixo X"));
            PORTD = 0x20;     //B00100000;      
         } 
         else if ((valZ < 370) && (valX > 390)) 
         {
            Serial.println(F(" Para Trás eixo X"));
            PORTD = 0x40;     //B01000000;         
         } 
         else 
         {     
            Serial.println(F(" Posição de (12 horas) eixo Z"));
            PORTD = 0x80;     //B10000000;          
         }
     #endif
         delay(20);
   }
 
// ******** End *********

/*O DIGITAL em
  * https://sistemasnb.wixsite.com/sistemas-nb  
  * Software versão : Arduino 1.8.8
  * Data da criação  _22_/_05_/_19_
  * Firmware (Sketch):   
  * Autor : Jacobson G. Ferreira
  * Modificado em  __/__/__  por :  
  * Descrição e nota : Estudo dos registradores DDR
  * e PORT conforme datasheet do -PU # o código
  * ativa os pinos 14,15,16,17,18,19 como saídas digitais,
  * e iniciliza o 15,16,17,18,19 em HIGH e 14 em LOW
  * O REG. PORTC etá em zero, no momento, para não
  * aquecer o regulador de tensão em um tempo prolongado
  * O resultado do processamento pode ser visualizado
  * na saída serial monitor
  **********************************************/
// Bibliotecas
// Constantes e definições
// variáveis públicas
// Protótipos de funções

 void setup()
 {  
    Serial.begin(9600);
    
      DDRC = B11111111; // Todos pinos são saída digitas (0xff)
    PORTC =  B100010; //0x3E O pino 14 é referênciado como GND, os demas são HIGH (0x22)  
    // favor ñ alterar o 1º bit
    
    Serial.print(" Hexadecimal : 0x00"); //imprime no serial o valos da variável PORTC      
    Serial.println(PORTC, HEX);  
    Serial.print(" Decimal : ");
    Serial.println(PORTC, DEC);
    Serial.print(" Binário : 0b");
    Serial.println(PORTC, BIN);                                                                                                  
 }

 void loop()
 {
 
 }
 // ................... end .....................
 
 /*
  * Conecte cinco LEDs com seus resistores nos pinos:
  * 15,16,17,18,19 (470 À 1000 Ohms de 125mW (1/8))
  * todos com o cátodo conectdos ao pino 14
  * Estes pinos são canais analóicos configurados para digital:
  * A0 = 14 configurado para ser o (GND), se usar uma shild com Arduino nano
  * A1 = 15      caso cntrário, podera alterar este pino para high
  * A2 = 16      Se for utilizar um nano, lembre-se que os pinos 20 e 21,
  * A3 = 17      são usados pelo SCL e SDA (comunicação I²C), belesa, munheca?
  * A4 = 18
  * A5 = 19  
 */a
// ************** End ***************

​

​

​

 /* 
  ***********************************************
  * Visite o site "ESPAÇO DIGITAL em
  * https://sistemasnb.wixsite.com/sistemas-nb  
  * Software versão : Arduino 1.8.9
  * Firmware (Sketch):
  * Data da criação  _06_/_07_/_2019_ 
  * Autor : Jacobson G. Ferreira
  * Modificado em    __/__/__   por :  
  * Descrição e nota : 
  **********************************************
*/ 
 int leitura(int a); // protótipo
 int valor;

 void setup() 
 {  
   Serial.begin(9600);
   pinMode(9, OUTPUT);      
 }
 void loop() 
 {          
   analogWrite(9, leitura(analogRead(A0))); // a função escreve no pino 9, a 
   Serial.println( valor);                    // leitura analógica de A0, atravéz da chamada 
   delay(20);                                // da função, que passa como parâmetro,     
 }                                             // a LEITURA da analogRead(A0)
 int leitura(int a)
 {
   #define b 4
   valor = (a/b);
   return(valor);
 }
            /* fim */
 

       VÍDEO

FLUXOGRAMA

/* 
  ***************************************************
  * Visite o site "ESPAÇO DIGITAL em
  * https://sistemasnb.wixsite.com/sistemas-nb  
  * Software versão : Arduino 1.8.9
  * Firmware (Sketch):  ProjetoStepper_2
  * Data de desenvolvimento : _09_/_05_/_2019_ 
  * Autor : Jacobson G. Ferreira
  * Modificado em _12_/_05_/_2019_  por : pelo autor 
  * Descrição e nota :  Programa para estudo dos

  * passos de motores digitais BIPOLAR e UNIPOLAR
  * Motor de passo exemplo : 28BYJ-45 imã permanente
  ***************************************************
  * 1023 bit-----> ângulo 2x 360º
    512  bit-----> ângulo 360º
    256  bit-----> ângulo 180º
    128  bit-----> ângulo 90º
    64   bit-----> ângulo 45º
    32   bit-----> ângulo 22,5º
    16   bit-----> ângulo 11,25º  
    8    bit-----> ângulo 5,627º
    2    bit-----> angulo 1,44º
    1    bit-----> qngulo 0,2245º
*/ 


 // Definições 
 #define TempoSentidoHoario 2    //Mude aqui o Tempo, de (2 à 200)
 #define TempoSentidoAntiHorario 2
#define fin_de_curso 100
 
 
unsigned int bits [36] = {
  1023, 511, 255, 127, 
    63,  63,  63,  63,
    31,  31,  31,  31, 
    15,  15,  15,  15, 
    7 ,  7 ,  7 ,  7 ,       
    3 ,  3 ,  3 ,  3 ,
    1 ,  1 ,  1 ,  1 ,
    1 ,  1 ,  1 ,  1 ,
    1 ,  1 ,  1 ,  1};

 unsigned int angulo; 
 
 // Protótipos 
 void passo_1(void);
void passo_2(void);
void passo_3(void);
void passo_4(void);
void passo_4(void);
void passo_3(void);
void passo_2(void); 
void passo_1(void);

 void setup() { 
 
   Serial.begin(9600);
        // definindo a direção das portas
   for( byte portas = 8; portas <= 11; portas = portas +1 ){
          pinMode( portas, OUTPUT ); digitalWrite( portas, LOW );     
      } 
}
 
void loop() {

   // Sequência de Passo completo com alto torque. (Full step) 

    
     for( byte i = 0; i <= 35; i++ ) {  // exe os 24 passos, 1023,511,255,127,63x4,31x4,15x4,7x8            
        for( angulo = 0; angulo <= bits [i]; angulo++ ) {                                   
              if( angulo == 0 ) delay( fin_de_curso  );  // 0...1023, 0...512, 0...255, 0...127......        
             
              Serial.println(bits[i]);
              
 // chamadas da funçõe sentido horário              
              passo_1();
              delay( TempoSentidoHoario );
              passo_2();
              delay( TempoSentidoHoario );
              passo_3();
              delay( TempoSentidoHoario );
              passo_4();
              delay( TempoSentidoHoario );
           }            
       
        for( angulo = 0; angulo <= bits [i]; angulo++ ) {               
              if( angulo == 0) delay( fin_de_curso ); 
                                        
 // sentido anti horário  
              passo_4();
              delay( TempoSentidoAntiHorario );   
              passo_3();
              delay( TempoSentidoAntiHorario );
              passo_2();
              delay( TempoSentidoAntiHorario ); 
              passo_1();  
              delay( TempoSentidoAntiHorario );
           }     
        }             
}       
 // fim do loop 
 
 // Início das funções a serem chamadas 
 
       void passo_1() {           
            digitalWrite( 8, HIGH ); 
            digitalWrite( 9, HIGH );     
            digitalWrite( 10, LOW );
            digitalWrite( 11, LOW );           
       } 

       void passo_2() {             
            digitalWrite( 8, LOW );
            digitalWrite( 9, HIGH );
            digitalWrite( 10, HIGH );
            digitalWrite( 11, LOW );            
       }  
                  
       void passo_3() {               
            digitalWrite( 8, LOW );
            digitalWrite( 9, LOW );
            digitalWrite( 10, HIGH );
            digitalWrite( 11, HIGH);            
       } 
       
       void passo_4() {             
            digitalWrite( 8, HIGH );
            digitalWrite( 9, LOW );
            digitalWrite( 10, LOW );
            digitalWrite( 11, HIGH );                     
     } 

                  //...... fim ......
 

VÍDEO DO CONTROLE DE CARGA POR CELULAR VIA BLUETOOTH.

                        BANCADA DE ENSAIO ESPAÇO DIGITAL

CLIQUE NA NOTA MUSICAL PARA                         OUVIR O SOM

BAIXE AQUI O APLICATIVO PARA CÁLCULO DA FORMULA DE BAKARA

PASSAGEM DE PARÂMETRO POR VALOR E REFERÊNCIA

/*
  ***********************************************
  * Visite o site "ESPAÇO DIGITAL em
  * https://sistemasnb.wixsite.com/sistemas-nb  
  * Software versão : Arduino 1.8.8
  * Data da criação  _22_/_05_/_19_
  * Firmware (Sketch):   
  * Autor : Jacobson G. Ferreira
  * Modificado em  __/__/__  por :  
  * Descrição e nota : Estudo dos registradores DDR
  * e PORT conforme datasheet do ATmeg328P-PU # o código
  * ativa os pinos 14,15,16,17,18,19 como saídas digitais,
  * e iniciliza o 15,16,17,18,19 em HIGH e 14 em LOW
  * O REG. PORTC etá em zero, no momento, para não
  * aquecer o regulador de tensão em um tempo prolongado
  * O resultado do processamento pode ser visualizado
  * na saída serial monitor
  **********************************************/
// Bibliotecas
// Constantes e definições
// variáveis públicas
// Protótipos de funções

 void setup()
 {  
    Serial.begin(9600);
    
      DDRC = B11111111; // Todos pinos são saída digitas (0xff)
    PORTC =  B100010; //0x3E O pino 14 é referênciado como GND, os demas são HIGH (0x22)  
    // favor ñ alterar o 1º bit
    
    Serial.print(" Hexadecimal : 0x00"); //imprime no serial o valos da variável PORTC      
    Serial.println(PORTC, HEX);  
    Serial.print(" Decimal : ");
    Serial.println(PORTC, DEC);
    Serial.print(" Binário : 0b");
    Serial.println(PORTC, BIN);                                                                                                  
 }

 void loop()
 {
 
 }
 // ................... end .....................
 
 /*
  * Conecte cinco LEDs com seus resistores nos pinos:
  * 15,16,17,18,19 (470 À 1000 Ohms de 125mW (1/8))
  * todos com o cátodo conectdos ao pino 14
  * Estes pinos são canais analógicos configurados para digital:
  * A0 = 14 configurado para ser o (GND), se usar uma shild com Arduino nano
  * A1 = 15      caso cntrário, podera alterar este pino para high
  * A2 = 16      Se for utilizar um nano, lembre-se que os pinos 20 e 21,
  * A3 = 17      são usados pelo SCL e SDA (comunicação I²C), belesa, munheca?
  * A4 = 18
  * A5 = 19  
 */a
// ************** End ***************

​

​

​

 /*
   Criação:------------------------------Jacobson da Glória Ferreira
   Data:---------------------------------01/05/2017
   Compilador:---------------------------Micro C PRO for Pic Microchip   
   Micro controlador utilizado:----------PIC 16F84A Microchip
   Programador utilizado:----------------PIC Kit 3 Microchip
   Este programa aciona uma sequência de oito LEDs  de efeito vai vem.
*/
 #define T 100
 //#CASE
void main()
{

TRISB = 0b00000000;
PORTB = 0b00000000;


     while(1)
    {
       RB0_bit = 0;    
       delay_ms (T);
       RB0_bit = 0;
       delay_ms (10);

       RB1_bit = 1;      
       delay_ms (T);
       RB1_bit = 0;
       delay_ms (10);

       RB2_bit = 1;   
       delay_ms (T);
       RB2_bit = 0;
       delay_ms (10);

       RB3_bit = 1;
       delay_ms (T);
       RB3_bit = 0;
       delay_ms (10);

       RB4_bit = 1;
       delay_ms (T);
       RB4_bit = 0;
       delay_ms (T);

       RB5_bit = 1;
       delay_ms (T);
       RB5_bit = 0;
       delay_ms (10);

       RB6_bit = 1;
       delay_ms (T);
       RB6_bit = 0;
       delay_ms (10);

       RB7_bit = 1;
       delay_ms (T);
       RB7_bit = 0;
       delay_ms (10);

       RB6_bit = 1;
       delay_ms (20);
       RB6_bit = 0;
       delay_ms (10);

       RB5_bit = 1;
       delay_ms (T);
       RB5_bit = 0;
       delay_ms (10);

       RB4_bit = 1;
       delay_ms (T);
       RB4_bit = 0;
       delay_ms (10);

       RB3_bit = 1;
       delay_ms (T);
       RB3_bit = 0;
       delay_ms (10);

       RB2_bit = 1;
       delay_ms (T);
       RB2_bit = 0;
       delay_ms (10);

       RB1_bit = 1;
       delay_ms (T);
       RB1_bit = 0;
       delay_ms (10);
   }
}
              Qualquer dúvida faça contato
​
​

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

Abaixo temos a forma das ondas  dos 7 bits, utilizando o osciloscópio do PROTEUS.

Este projeto, utilizando o uC PIC 16F84A, aciona um display de 7 segmentos em uma contagem de 0Fh (hexadecimal) no tempo de 1segundo em um laço contínuo  e pode der otimizado fasendo uso de um vetor. O código fonte está disponível logo a baixo
/*Display Hexadecimal
  Projeto: JACOBSON DA GLÓRIA FERREIRA
  Compilador utilizado para este projeto Micro C PRO for PIC  MIcrochip
*/
#define T 500    // meio seg
#case

void main()
{

TRISB =0x00; // zerando o registrador TRISB
PORTB =0xFF; // setando o registrador PORTB

//  loop
  while(1)
     {
      portb = 0x3F;   //0   1111111
      delay_ms(T);
      portb = 0x06;   //1   110
      delay_ms(T);
      portb = 0x5B;   //2   1011011
      delay_ms(T);
      portb = 0x4F;   //3   1001110
      delay_ms(T);
      portb = 0x66;   //4   1100110
      delay_ms(T);
      portb = 0x6D;   //5  1101101
      delay_ms(T);
      portb = 0x7D;   //6  1111101
      delay_ms(T);
      portb = 0x07;   //7   111
      delay_ms(T);
      portb = 0x7F;   //8   1111111
      delay_ms(T);
      portb = 0x6F;   //9   1101111
      delay_ms(T);
      portb = 0x77;   //A   1110111
      delay_ms(T);
      portb = 0x7C;   //B   1111100
      delay_ms(T);
      portb = 0x39;   //C   111001
      delay_ms(T);
      portb = 0x5E;   //D   1011110
      delay_ms(T);
      portb = 0x79;   //E   1111001
      delay_ms(T);
      portb = 0x71;   //F   1110001
      delay_ms(T);
     }
}
​
Qualquer dúvida faça contato
 

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

ON/OFF COM UM ÚNICO BOTÃO S1

/*
  ***********************************************
  * Visite o site "ESPAÇO DIGITAL em
  * https://sistemasnb.wixsite.com/sistemas-nb  
  * Software versão : Arduino 1.8.8
  * Data da criação  _22_/_05_/_19_
  * Firmware (Sketch):   
  * Autor : Jacobson G. Ferreira
  * Modificado em  __/__/__  por :  
  * Descrição e nota : Estudo dos registradores DDR
  * e PORT conforme datasheet do -PU # o código
  * ativa os pinos 14,15,16,17,18,19 como saídas digitais,
  * e iniciliza o 15,16,17,18,19 em HIGH e 14 em LOW
  * O REG. PORTC etá em zero, no momento, para não
  * aquecer o regulador de tensão em um tempo prolongado
  * O resultado do processamento pode ser visualizado
  * na saída serial monitor
  **********************************************/
// Bibliotecas
// Constantes e definições
// variáveis públicas
// Protótipos de funções

 void setup()
 {  
    Serial.begin(9600);
    
      DDRC = B11111111; // Todos pinos são saída digitas (0xff)
    PORTC =  B100010; //0x3E O pino 14 é referênciado como GND, os demas são HIGH (0x22)  
    // favor ñ alterar o 1º bit
    
    Serial.print(" Hexadecimal : 0x00"); //imprime no serial o valos da variável PORTC      
    Serial.println(PORTC, HEX);  
    Serial.print(" Decimal : ");
    Serial.println(PORTC, DEC);
    Serial.print(" Binário : 0b");
    Serial.println(PORTC, BIN);                                                                                                  
 }

 void loop()
 {
 
 }
 // ................... end .....................
 
 /*
  * Conecte cinco LEDs com seus resistores nos pinos:
  * 15,16,17,18,19 (470 À 1000 Ohms de 125mW (1/8))
  * todos com o cátodo conectdos ao pino 14
  * Estes pinos são canais analógicos configurados para digital:
  * A0 = 14 configurado para ser o (GND), se usar uma shild com Arduino nano
  * A1 = 15      caso cntrário, podera alterar este pino para high
  * A2 = 16      Se for utilizar um nano, lembre-se que os pinos 20 e 21,
  * A3 = 17      são usados pelo SCL e SDA (comunicação I²C), belesa, munheca?
  * A4 = 18
  * A5 = 19  
 */a
// ************** End ***************

​

​

​

Este aplicativo foi desenvolvido em linguagem "C" e exibe o resultado no                      console do Windows tamanho: 17804 bytes (17KB)

   Ao tentar baixar, o Google irá te proteger exibindo avisos por ser um               executável, isso é normal. Até eu fico com medo com os avisos                                                                   apavorantes :)

​

                                                NÃO É UM VÍRUS, OK?

  baixe o aplicativo para cálculo de resistor p/ LED clicando aqui

1/8 W

CCS PCWHD Compiler version 5.025

 Display LCD com o PIC 16F628A da Microchip

// ESPAÇO DIGITAL

// Data: 20/01/2018

MCU: POC16F628A

// SOFTWARE: CCS PCW

//código de teste para o display LCD INTERFACE HM


#include <16F628A.h>
#fuses XT, NOWDT, NOLVP, PUT
#use delay(clock = 4M)
#use fast_io(b)           // modo manual, porém mais rápido e eficaz.  
#use fast_io(a)           // É necessário setar o TRIS
#byte TRIS = 0X86
#define rs        pin_a0  //caracter/comando
#define enable    pin_a1  //pulso de habilitação "clock"
#define botao     pin_a2  // pino de entrada
#define limpaLCD  0x01    //"limpa a tela"
#define linha_2   0xC0    //vai para a linha 2
#define linha_1   0x80    //vai para a linha1

#case

/*--------------------------------------
PROTÓTIPOS DE FUNÇÕES
--------------------------------------*/

void inicia_LCD(void);           //função
void LCD_texto(char letra);      //função  
void LCD_comando(int comando);   //função      

void main()
 {
         
         set_tris_b(0x00);  //CONFIGURA O PORTB COMO SAÍDA
         set_tris_a(0x04);  // configura o pino a2 como entrada
         
         inicia_lcd();         
         
                      LCD_comando(linha_1);
                      printf (LCD_texto, "INICIALIZANDO...");
                      delay_ms (100);
                      LCD_comando(linha_2);
                      LCD_texto("Pressiono batao");
                      delay_ms (3000);
                      LCD_comando (limpaLCD);
                      delay_ms (5);
        
         while(TRUE)

         {
                      LCD_comando(linha_1);
                      LCD_texto ("*ESPACO DIGITAL*");
                      delay_ms (3000);
                      //LCD_comando (limpaLCD);
                      //delay_ms (5);
        
                              
                  if (!input(pin_a2))
               
                  {
                      LCD_comando(linha_1);
                      printf(LCD_texto, "  Visite o site  ");
                      LCD_comando(linha_2);
                      LCD_texto ("<ESPACO DIGITAL>");
                      delay_ms (3000);
                      LCD_comando (limpaLCD);
                      delay_ms (5);                    
                                    
                      LCD_comando(linha_1);
                      printf (LCD_texto, "  Programacao e ");
                      LCD_comando(linha_2);
                      LCD_texto ("EletronicDigital");
                      delay_ms (3000);
                      LCD_comando (limpaLCD);
                      delay_ms (5);
                      
                      LCD_comando(linha_1);
                      printf (LCD_texto, "     https://   ");
                      LCD_comando(linha_2);
                      LCD_texto("    wixsite/    ");
                      delay_ms (3000);
                      LCD_comando (limpaLCD);
                      delay_ms (5);                    
                                    
                      LCD_comando(linha_1);
                      printf (LCD_texto, "   sistemas_nb   ");
                      LCD_comando(linha_2);
                      LCD_texto ("    .com.br     ");
                      delay_ms (3000);
                      LCD_comando (limpaLCD);
                      delay_ms (5);
                  }
        }
 }
// ...................................................................................................................................
      
       void inicia_lcd()

       {       
                  output_low(rs);        //COLOCA lcd no modo de comando
                  output_b(0x38);        //configura modo 8bits, 2linhas e 5x7 pixelz.
                  output_high(enable);   //pulso de enable
                  output_low(enable);
                  delay_ms(20);          //timing do display
                  output_b(0x0c);        //configura o cursor
                  output_high(enable);   //pulso em enable
                  output_low(enable);
                  output_b(0x06);        //incremento a direita do cursor
                  output_high(enable);   //pulso em enable
                  output_low(enable);
                  output_b(limpaLCD);    // limpa display
                  output_high(enable);   //pulso em enable
                  output_low(enable);
                  delay_ms(5);
       }

                void LCD_texto(char letra)
          
                {
                          output_high(RS);    // modo de dados
                          output_b(letra);    //coloca o carater recebido no portB
                          output_high(enable);//pulso no enable
                         delay_us(500);
                         output_low(enable);
                }

    void LCD_comando(int comando)

    {

              output_low(RS);      //modo de comando
              output_b(comando);   //coloca o comando recebido no portB
              output_high(enable); //pulso no enabe
              delay_us(500);
              output_low(enable);

   }
                             
               //4% Memória RAM -- 24% Memória ROM
                                             //FIM
 

T//////////////////////////////////////////////////////////////////////////////////////////////////////////

Módulo_Acelerômetro_3_Eixos_(x,y,z)_Adxl

// ////////////////////////////////////////////////
// Programa de intuito didático a ser executado
// no Windows 32 e 64 bits
// Software : DEV C++ 4.9.9.2
// Data : 12/11/18
// Autor : Jacobson G. Ferreira
// Descrição : O programa realiza a
// troca dos valores das variáveis X,Y e auxiliar
// ///////////////////////////////////////////////
#include <stdio.h>
#include <windows.h>

int main()
{
    int X, Y, aux;
    printf("\nDigite o valor para X : ");
    scanf("%i", &X);
    printf("\nDigite um valor para Y : ");
    scanf(" %i", &Y);
    getchar();
    puts(" ");    
    
    //...........
    aux = Y;
    Y = X;
    X = aux;
    //...........
    
    printf("\n Os valores das varia\'veis foram trocadas com sucesso!");
    printf("\n\n........\n");
    printf("\n X e\' %i\n\n Y e\' %i\n\n aux e\' %i", X, Y, aux);  
    system("pause > null");  
}

// ///////////////////// fim //////////////////////

/*
* Software : Arduino 1.8.5
* Autor : Jacobson da Glória Ferreira
* Data : 02/07/2018
* Descrição : programa exemplo de utilização do recurso "cão de guarda" WDT
* Link do site : <  https://sistemasnb.wixsite.com/sistemas-nb  >
* < Facebook Jacobson ferreira >
*/
    // biblioteca AVR
#include <avr/wdt.h>
void SimulaBug();

void setup (){
    Serial.begin(9600);   
    
    wdt_enable (WDTO_4S) ;// habilita o WDT para monitorar em 4sg
}
 
void loop () {
    static int contador = 1;
 
    Serial.print(F("var contador = "));
 
    Serial.println(contador);
      
    contador++;      // incrementando a variável contador em 1
 
    delay(500);

    wdt_reset (); // invoca o reset. Entrara em ação se o programa travar.     

   //se conntador for maior que 4, forçar um travamento
    if(contador > 10){
         Serial.println("\t\t forçando travamento proposital! Resetando...\nRestabelecendo...");     
         SimulaBug();  // invoca função de travamento         
    }          
}

//..............................
void SimulaBug(){    
    while (true);  // loop infinito, simulando travamento.    
}
//.............................

 
/*
 * Software: Arduino rev 1.8.7
 * Data: 24/10/18
 * Autor: Jacobson da Glõria Ferreira
 * Descrição do algoritimo: invoca rotina de interrupição
*/
#define saidas    10
#define PinBotao1 2
#define PinBotao2 3
byte degraus =    10;
int tempo =       100;
byte portas[saidas] = {4,5,6,7,8}; //{4,5,6,7,8,9,10,11,12,13}

void setup() {
    attachInterrupt(digitalPinToInterrupt(PinBotao1), invocafuncao1, FALLING); //2
    attachInterrupt(digitalPinToInterrupt(PinBotao2), invocafuncao2, FALLING); //3
    
    pinMode(PinBotao1, INPUT_PULLUP);
    pinMode(PinBotao2, INPUT_PULLUP);
    
    //{4,5,6,7,8,9,10,11,12,13}
    for(byte i = 0; i <= 4; i++){
        pinMode(portas[i], OUTPUT);
    }
}
//==========================================
void loop() {
    for(byte i = 0; i <= 4; i++){
         digitalWrite(portas[i], HIGH);
         delay(tempo);
         digitalWrite(portas[i], LOW);       
    }   
}
//==========================================
  //OBS: debouncing por filtro capacitivo ou
  //switch trigger na porta de entrada
void invocafuncao1(){     
       tempo = tempo - degraus;
         if(tempo < 1){
              tempo = 1;           
         }
}
//==========================================
 
//OBS: debouncing por filtro capacitivo ou
//switch trigger na porta de entrada                 
void invocafuncao2(){       
       tempo = tempo + degraus;
         if(tempo > tempo){
              tempo = tempo;           
         }         
}
//==========================================     

/* debouncing por millis
void invocafuncao1() {
     static int tempoArbitrado = 200;
     static unsigned long delayDebounce;
     static unsigned long tempoInicial = 0;  
     
     delayDebounce = (millis() - tempoInicial);
         if(delayDebounce >= tempoArbitrado){
             tempo = tempo - degrau;
             if(tempo < 1){
                 tempo = 1;
             }
             tempoInicial = millis();  
         }
}
//==========================================
debouncing por millis                
void invocafuncao2(){
     static int tempoArbitrado = 150;
     static unsigned long delayDebounce;
     static unsigned long tempoInicial = 0;  
       
     delayDebounce = (millis() - tempoInicial);
         if(delayDebounce >= tempoArbitrado){  
            tempo = tempo + degraus;
            if(tempo > tempo){
                 tempo = tempo;
             }
            tempoInicial = millis();
         }         
} */
//==========================================   


   
 //.........................................................
 // Software: Arduino Rev 1.8.7
 // Data: 30/10/18
 // Autor: Jacobson G. Ferreira
 // Descrição: funções matemáticas  sqrt() e pow() exemplos
 //........................................................

void pot(void);
void raiz(void);
//int potencia;
int tempo = 1000;
//float raizQuad;
//..................
float base = 2.5;       // mude aqui os valores da base
float expoente  = 15.0; // mude aqui os valores do expoente
//.................
float radicando = 3.0;  // mude aqui os valores da RAIZ da tensão 380Volts TRIFÁSICA
byte TensaoTrifasica = 220;

void setup() {
    Serial.begin(9600);    
}
void loop() {
    pot();
    raiz();
}

void pot(){
    //int potencia = pow(2, 8);// A potência de 2.5 elevado à 15 é 931322.56

    Serial.print(" A potência de 2,5 elevado à 15 é ");
    Serial.println(pow(base, expoente));//float - return double
    Serial.println("...................");  
    delay(tempo);  
}

void raiz(){
    //float raizQuad = sqrt(2);  // Raiz de dois = 1,4142
    Serial.print(" A tensão trifásica com neutro concateado é ");
    Serial.println(TensaoTrifasica /(sqrt(radicando)));   //float - return double
    Serial.println("...................");  
    delay(tempo);
}       

// //////////////////////////////
// Software DEV C++ 4.9.9.2
// Autor: Jacobson G. Ferreira
// Data: 08/06/2018
// //////////////////////////////
#include <conio.c>
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

void mensagem(void);
byte x[] = {19, 20, 21, 22, 23, 24};
byte y[] = {63, 64, 65, 66, 67, 68};
byte cor[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};

int main(){
    mensagem();
}

void mensagem()
{
 while(1)
 {
   clrscr();  // system("cls")

   setlocale(LC_ALL, "Portuguese");

   byte C, A, L;

   for(C = 0; C <= 14; C++) {

        for(A = 0; A <= 5; A+=2 ) {

             for(L = 0; L <= 5; L+=2) {

                  textcolor ( cor[C] );

                        gotoxy ( y[L], x[A] );

                        printf("ESPAÇO DIGITAL & ARDUINO");

                        Sleep(200);
                   }
              }
         }
    }
}


 

/*

  Software :  Code :: Blocks  Rev 10.05
  Name: CalculoDeslocamento
  Copyright:
  Author: Jacobson da Glória Ferreira
  Date: 26/09/14 22:01
  Description: Calcula a distância  de ida/volta  do atendimento mais a taxa de   atendimento fixo
*/
#include <stdio.h>        // pré processamento
#include <conio.c>        // pré processamento
#include <locale.h>       // pré processamento
#define Deslocamento 0.65 //constante
#define TaxaUnica 35.0    // constante
#define Valor 35.0        // constante
#define Fixo 10.0         // constante
#define T 250             // constante
int main(void) {
    setlocale(LC_ALL, "Portuguese");
    while(1){
        system("MODE con cols=168lines=57");//tamanho do console
        textcolor(10);                      // tratamento da impressão
        gotoxy(69,3);                       // tratamento da impressão
        printf("<ESPAÇO DIGITAL>");         // tratamento da impressão         
        gotoxy(57,5);                       // tratamento da impressão
        printf("CÁLCULO DE DESLOCAMENTO PARA ATENDIMENTO"); // tratamento da impressão
        gotoxy(40,6);                       // tratamento da impressão
        printf("/////////////////////////////////////////////////////////////////////////////");
        
        float volume;     // variável privada                                                                                                                                         
        float distancia;  // variável privada
        int deslocamento; // variável privada
        float total;      // variável privada
        int quantidade;   // variável privada
        float maximo;     // variável privada
        
        // ///////////////////////////////////////////////////////////////////////////
        
        textcolor(11);                       // tratamento da impressão
        printf("\n\n\tCALCULANDO O VALOR DO DESLOCAMENTO:\n\n\tDigite a distacia percorrida pelo ténico em Kilômetros até o local. OBS: só de IDA e cada Km equivale á R$ 0,65 centavos. \n\n\tKm: ");
        Beep(3000,T);                        // alerta sonoro
        scanf("%f", &distancia);            // leitura do dados
        Beep(3000,T);                        // tratamento da impressão
        distancia = distancia * Deslocamento * 2; // valor digitado x 1,30. Ou seja,se for 5 km x 1,30 = 6,50
        printf("\n\tO valor em R$, do deslocamento de (IDA E VOLTA) é------------------------------> R$ %.2f\n\n", distancia);
                                     // agurda a impressão
        
        // ///////////////////////////////////////////////////////////////////////////
        
        textcolor(14);                       // tratamento da impressão
        printf("\n\n\tDigite o valor fixado de cada atendimento (sem as casas decimais!) \n\n\tR$ ");
        Beep(3000,T);                        // tratamento da impressão
        scanf("%d", &deslocamento);         // leitura de dados
        Beep(3000,T);                        // alerta sonoro
        total = distancia + deslocamento;
        printf("\n\tO total é: ---------------------------------------------------------------------> R$ %.2f\n\n\t",total);
        
        
        // //////////////////////////////////////////////////////////////////////////
        
        textcolor(12);
        printf("\n\tDigite a quantidade de nobreaks. OBS: são R$ 35,00 cada um.\n\n\tQtd ");
        Beep(3000,T);
        scanf("%d",&quantidade);
        Beep(3000,T);
        quantidade = quantidade * Valor;
        maximo = quantidade + total;
        printf("\n\tO semitotal do reembolço é de--------------------------------------------------> R$ %.2f\n\n\t",maximo);
        
        
        // //////////////////////////////////////////////////////////////////////////
        
        textcolor(9);        
        printf("\n\tHá estabilizaores neste atendimento? Se sim digite a quantidade. Se não digite \"0\". OBS. cada estabilizador vale R$10,00\n\n\t=> ");
        
        Beep(3000,T);
        scanf(" %f", &volume);
        Beep(3000,T);
        volume = volume * Fixo;
        volume = volume + maximo;
        printf("\n\tTotal do reembolço a ser pago pela fábrica \" x \" é----------------------------------------> R$%.2f\n\t",volume);
        
        
        // //////////////////////////////////////////////////////////////////////////
        
        textcolor(15);
        printf("\n\n\n\n\tObrigado por utilizar meu software.\n\n\tDIGITE \"QUALQUER TECLA\" PARA RETORNAR OU CLIK NO \"X\" NO CANTO SUPERIOR DIREITO PARA SAIR DO PROGRAMA. \n\n\n\tJACOBSON DA GLóRIA FERREIRA.");
        getch();          
    }
    Beep(3000,T);    
}

 


// Software : Arduino Rev.  1.8.7
// Data : 24/11/18
// Autor : Jacobson G. Ferreira
// Descrição : aciona  o WDT "cão de guarda" por interrupção externa
#include <avr/wdt.h>
#define pinBotao 2


void setup() {
    Serial.begin(9600);
    attachInterrupt(digitalPinToInterrupt(pinBotao), trava, FALLING);
    pinMode(pinBotao, INPUT_PULLUP);
    wdt_enable(WDTO_2S);
}

void loop() {
    wdt_reset();
    static byte contador = 0;
    contador = contador + 1;
    delay(200);


    if(contador == 100){
        contador = 0;
    }
    Serial.println(contador);
}

void trava(){
    while(1);
}

/*
 * Software : ARDUINO IDE 1.8.6
 * Nome do arquivo :  EFEITO PERSEGUIÇÃO com LEDs
 * Data : 29/09/2018
 * Autor : Jacobson G. Ferreira
*/         
                
                           // 0 1 2 3 4 índices
byte portas[5] = {2,3,4,5,6}; // arrey de 5 portas obs: byte portas[5]={};
byte tempo;

void setup() {
   Serial.begin(9600);
  //...........................    
   Serial.print(F(" O total de byte na vetor portas é "));
   Serial.println(sizeof(portas));
  //............................   
   for(byte ind = 0; ind <= 4; ind++){  // índice 01234
        pinMode(portas[ind], OUTPUT);
        digitalWrite(portas[ind], LOW);             
   }  
}
void loop(){  
      tempo = map(analogRead(A0), 0, 1023, 255, 0 );  //tempo = (analogRead(A0)/4);       
      for(byte i = 0; i <= 4; i++){        
          digitalWrite(portas[i], HIGH);
          delay(tempo + 1);   // 0 + 1 até 255 + 1 para que no só incremeto não trave os LEDs no 255
      }
   
      for(byte i = 0; i <= 4; i++){
          digitalWrite(portas[i], LOW);
          delay(tempo + 1);  // 0 + 1 até 255 + 1 para que no só incremeto não trave os LEDs no 255                
      }
    //.....................................
      for(int i = 4; i >= 0; i--){    
          digitalWrite(portas[i], HIGH);
          delay(tempo);                  
      }
 
      for(int i = 4; i >= 0; i--){
          digitalWrite(portas[i], LOW);
          delay(tempo);                  
      }
      Serial.println(tempo);            
}

  /*                                                                      FIM                                                                                 */

======================================================================

Micro servo motor, como programa-lo?

Escrevi este algoritmo para mostrar o funcionamento
automático deste servo.


Este servo possui três fios de cores (marrom ou preto, vermelho e amarelo ou laranja)

O marrom representa o GND, o vermelho o VCC e por fim o amarelo a Entrada de Dados


Veja o vídeo clicando aqui
------------------------


///////////////////////////////////////////////////////////////////////////////////////
// Software : Arduino versão 1.8.8                                                            //
// Data de criação: 06/01/19                                                                      //
// Autor : Jacobson G. Ferreira                                                                   //
// Descrição : Aciona o micro servomotor em trinta e seis passos     //
// que   vai de 0º até 180º em intervalos de 500 milissegundos          //
// Duty Cycle em 90° = 7,1 % - em 0°, 3,3 % - em 180°, 12 % -              //
//  Corrente em funcionamento com carga : 36 mA  e vazio 3 mA      //
///////////////////////////////////////////////////////////////////////////////////////

#include <Servo.h>   // biblioteca Arduino

#define RETARDO 500   // mude o tempo aqui

#define modoSerial  0   //  para ativar o serial, mude do 0 para 1

Servo servo; // instanciando objeto

byte angulo;

byte degraus[] = { 5,10,15,20,25,30,35,40,45,50,
                              55,60,65,70,75,80,85,90,95,100,
                              105,110,115,120,125,130,135,140,
                              145,150,155,160,165,170,175,180 };
void setup (){
  servo.attach(8); 
   #if modoSerial == 1
       Serial.begin(9600);
  #endif
}

void loop( ){
  byte leitura; 
    for(byte x = 0; x <= 35; x++){   
      angulo = degraus[x];        
      servo.write (angulo);

      #if modoSerial == 1
           leitura = servo.read();       
           Serial.print("angulo ");
           Serial.println(leitura);
      #endif
      delay(RETARDO);
  }
}
                                               /*   FIM   */

======================================================================

Diagrama elétrico do código abaixo
/////////////////////////////////////////////////////////////////////////
// Software Arduino : 1.8.8
// Data : 28/01/19
// autor : Jacobson G Ferreira
// Descrição : simples controle de dois servos com dois
// potenciômetros ou um joystick
/////////////////////////////////////////////////////////////////////////

#include <VarSpeedServo.h>     // biblioteca

VarSpeedServo motor1, motor2;  // instanciando objeto motor

#define POT1 A0
#define POT2 A1
#define SERIAL 0  // (1) para habilitar o recurso do serial monito
#define pin_servo1 2
#define pin_servo2 4
byte angulo1;
byte angulo2;
void control1(void);
void control2(void);


void setup(){
    motor1.attach (pin_servo1);
    motor2.attach (pin_servo2);

    #if SERIAL == 1
      Serial.begin(9600);
    #endif   

     pinMode(POT1, INPUT);
     pinMode(POT2, INPUT);
   
}

void loop(){
    control1();
    control2();
}  

//////////////////////////// end loop ///////////////////////////////
  void control1(void){
      int armazena1 = analogRead(POT1);
      angulo1 = map(armazena1, 0, 1023, 0, 179);
      delay(50);
      motor1.slowmove(angulo1, 255);

      #if SERIAL == 1
         Serial.print("Potenciômetro 1  ");
         Serial.print(angulo1);
         Serial.print("");
      #endif    
  }

  void control2(void){
      int armazena2 = analogRead(POT2);
      angulo2 = map(armazena2, 0, 1023, 0, 179);  
      delay(50);
      motor2.slowmove(angulo2, 255);

      #if SERIAL == 1
         Serial.print("        Potenciômetro 2  ");
         Serial.print(angulo2);
         Serial.println("");
      #endif       
  }
  /////////////////////////// end ////////////////////////////////////

ASSISTA O VÍDEO DO SKETCH ABAIXO CLICANDO AQUI

 ///////////////////////////////////////////////////////////////////////////////////////////////
 // Software Arduino : 1.8.8
 // Data : 09/02/19
 // Autor : Jacobson Glória Ferreira
 // Descrição : sistema de varredura para sensor ultrassônico HC_SR04 COM
 // controle de velocidade de varredura por botão e monitorado por 8 LEDs
 // velocidades de : 4,8,12,16,20,24,28 e 32   com interrupção externa ISRs
 /////////////////////////////////////////////////////////////////////////
 //  Visite o site "ESPAÇO DIGITAL" EM : facebook (jacobson ferreira) ou
 //  <  https://sistemasnb.wixsite.com/sistemas-nb  >
 ////////////////////////////////////////////////////////////////////////////////////////////////

 #include <Servo.h>     // biblioteca padrão Arduino

 Servo motor1;          // instanciando objeto motor para o método Servo


 #define incrementos 1 
 #define pinBotao 2     // ISRs
 #define pin_servo1 3
 #define saidas 8

 #define serial 0   // habilita o recurso serial monitor 

 byte angulo1, angulo2; // variáveis que recebe os ângulos do laço for
 byte atraso  = 4;      // variável para o argumento do delay
 byte atribuicao = 4;   // para ser somado à atraso

 void control_1 (void);  // protótipos
 void control_2 (void);  //

 void beep ( ) {       
      static unsigned int NOTE_B5 = 988;
      tone(12, NOTE_B5, 200);        
 } 
                    
 byte avanco [saidas] = {4, 5, 6, 7, 8, 9, 10, 11};
 
 void setup ( ) {
     attachInterrupt(digitalPinToInterrupt(pinBotao), funcao, FALLING); // ISRs
    
     motor1.attach (pin_servo1);
      
     #if serial == 1
         Serial.begin (9600);
     #endif  

     pinMode (13, OUTPUT);     
      
     pinMode (pinBotao, INPUT_PULLUP);

     for (byte portas = 0; portas < 8; portas++) {
           pinMode (avanco[portas], OUTPUT);
           digitalWrite (avanco[portas], LOW);    
       }    
  }

  void loop ( ) {
     control_1 ();
     control_2 ();

    #if serial == 1
         Serial.print (" atraso = ");  
         Serial.println (atraso);
    #endif        
 }  

 //////////////////////////// end loop ///////////////////////////////
 
  void control_1 ( ) {
    
      for (angulo1 = 60; angulo1 < 120; angulo1 += incrementos) { //  0 - 180
            motor1.write (angulo1);            
            delay (atraso);
         }        
  }

  void control_2 ( ) {
      
      for (angulo2 = 120; angulo2 > 60; angulo2 -= incrementos) { //  180 - 0   
            motor1.write (angulo2);            
            delay (atraso);                         
         }
  }

  void funcao (){     
    unsigned long var;
    static unsigned long temp_ref = 0;
    static unsigned long tempArbit = 300;
 
    var = millis ( ) - temp_ref;
  if (var >= tempArbit) {                     
         atraso  += atribuicao;
         if (atraso > 32) {
                atraso = 4;
            }

         beep ( );
           
             switch (atraso) {
              
              case 4:  // porta 4
                  digitalWrite (avanco [0], HIGH);  // índice 0
                  digitalWrite (avanco [7], LOW);                 
                  break;
                                                 
              case 8:  // porta 5
                  digitalWrite (avanco [1], HIGH);  // índice 1
                  digitalWrite (avanco [0], LOW);               
                  break;
                                
              case 12: // porta 6                
                  digitalWrite (avanco [2], HIGH);  // indice 2
                  digitalWrite (avanco [1], LOW);               
                  break;
                                 
              case 16: // porta 7              
                  digitalWrite (avanco[ 3], HIGH);  // indice 3
                  digitalWrite (avanco [2], LOW);                
                  break;
                                   
              case 20: // porta 8              
                  digitalWrite (avanco [4], HIGH);  // índice 4
                  digitalWrite (avanco [3], LOW);                
                  break;
                                   
              case 24: // porta 9               
                  digitalWrite (avanco [5], HIGH);  // índice 5
                  digitalWrite (avanco [4], LOW);               
                  break;  
                                  
              case 28: // porta 10                                                     
                  digitalWrite (avanco [6], HIGH);  // índice 6
                  digitalWrite (avanco [5], LOW);                                  
                  break;

              case 32: // porta 11
                  digitalWrite (avanco [7], HIGH);  // índice 7
                  digitalWrite (avanco [6], LOW);                 
                  break;                                   
             }
                                                                                      
        temp_ref = millis ();
      }                          
  }
  /////////////////////////// end ////////////////////////////////////

//---------------------------------------------------------------------
// Arduino : 1.8.8
// Data: 15/02/19
// Autor : Jacobson G. Ferreira
// Descrição : Multiplicação da potencia de 2 pela raiz de 4
// Equação em algoritmo :  2 ^ 8 * 4 ^ (1/2) = 512
//----------------------------------------------------------------------
void setup() {
    Serial.begin ( 9600);
    
    int result, base = 2, expoente = 8, radicando = 4;
    
    result = pow (base, expoente) * sqrt (radicando);
    
    Serial.print ("\n\n  Resultado da equação é  =>  ");
    
    Serial.println (result);
    
    Serial.print ("  -------------------------------");
  }

void loop() {
}

//-------------------------------------------------------end-----------------------------------------------------------

/*
 * VISITE O SITE "ESPAÇO DIGITAL EM
 * https://sistemasnb.wixsite.com/sistemas-nb
 * Arduino 1.8.8
 * Autor : jacobson G. Ferreira
 * Data : 22/02/19
 * Descrição : executa comandos no Arduino pelo PC via comubnicação serial
*/

#include <pitches.h>

// definições
#define ACESO HIGH
#define APAGADO LOW
#define LED 13
#define duracao 30    // miliseg
#define buzzer 12     // port 12

// variável para armazenamento da leitura do byte da serial
byte dados = 0;      
int frequenc; //Hertz

// protótipos
void flag (void);     
void piscaLed1 (void);
void piscaLed2 (void);
void piscaLed3 (void);

// inicializando
void setup() {
 
    pinMode (LED, OUTPUT);
    digitalWrite (LED, LOW);
    
    Serial.begin (9600);
    Serial.print (F("\n\n\tDigite 1 para o led piscar por 1,0 seg e tecle ENTER \n\tDigite 2 para o led piscar por 0,5 seg e tecle ENTER\n\tDigite 3 para o led piscar por 0,1 seg e tecle ENTER\n\tDigite 0 para o led e o alarme parar,  e tecle ENTER\n\t"));  
    Serial.println (F("-----------------------------------------------------\n"));  
    Serial.print (F("\n\tObseve a velocidade do serial logo abaixo no rodapé que\n\tdeve se (9600 bps)\n\t\n\tJACOBSON"));
}
 
// execução
void loop() {

   while(Serial.available()){
           dados = Serial.read();
        }
   switch(dados) {
            
            case '1':
              frequenc = NOTE_AS6;            
              piscaLed1 ();
              flag ();               
              break;
           
            case '2':
              frequenc = NOTE_DS7;
              piscaLed2 ();
              flag ();
              break;

            case '3':
              frequenc = NOTE_AS7;
              piscaLed3 ();
              flag ();
              break;  
            
            case '0':
              digitalWrite (LED, APAGADO);              
              break;
         }       
}
//*************** Fim do loop **********************

//*********** inicio das sub rotinas ******************

void flag (){
      byte tempoArbitrado = 200;
      static unsigned long tempoInicial = 0;
      static unsigned long debounsing;
      
      debounsing =  millis () - tempoInicial;
      if (debounsing >= tempoArbitrado){             
             tone (buzzer, frequenc, duracao);
             tempoInicial = millis ();
         }       
  }
// ***********************************************  
  void piscaLed1 (){    
      int tempoArbitrado = 1000;
      static unsigned long tempoInicial = 0;
      unsigned long debounsing;
      
      debounsing = millis () - tempoInicial;      
      if (debounsing > tempoArbitrado){      
             digitalWrite (LED, ACESO);
         }
      if (debounsing < tempoArbitrado){    
             digitalWrite (LED, APAGADO);
         }
      if (debounsing >= 2*tempoArbitrado) {
             tempoInicial = millis ();   
         }
      }
// ***********************************************
  void piscaLed2 (){    
      int tempoArbitrado = 500;
      static unsigned long tempoInicial = 0;
      unsigned long debounsing;
      
      debounsing =  millis () - tempoInicial;      
      if (debounsing > tempoArbitrado){      
             digitalWrite (LED, ACESO);
         }
      if (debounsing < tempoArbitrado){    
             digitalWrite (LED, APAGADO);
         }
      if (debounsing >= 2*tempoArbitrado) {
             tempoInicial = millis ();   
         }
  }
// ***********************************************
  void piscaLed3 (){    
      byte tempoArbitrado = 100;
      static unsigned long tempoInicial = 0;
      unsigned long debounsing;
      
      debounsing =  millis () - tempoInicial;      
      if (debounsing > tempoArbitrado){      
             digitalWrite (LED, ACESO);
         }
      if (debounsing < tempoArbitrado){    
             digitalWrite (LED, APAGADO);
         }
      if (debounsing >= 2*tempoArbitrado) {
             tempoInicial = millis ();   
         }          
 }        
// ******************** end ************************

 /*
  * Arduino 1.8.8
  * Data Criação : 03/03/19 --- 2ª atualização :
  * Autor : Jacobson G. Ferreira
  * Descrição : O código escreve na e²prom e lê nos endereços os valores passamdo para o port PWM 9.
  * VISITE O SITE "ESPAÇO DIGITAL EM  < https://sistemasnb.wixsite.com/sistemas-nb >  
  * Arduino 1.8.8
  * Data : 03/03/19
  * Autor : Jacobson G. Ferreira
  * Descrição : O código escreve na e²prom e lê nos endereços os valores passamdo para o port PWM 9.
  * VISITE O SITE "ESPAÇO DIGITAL EM  < https://sistemasnb.wixsite.com/sistemas-nb >
  *
  ********************************************
  * Duty Cycle pwm :  
  * 1023------100
  * 11----------X = 1100/1023 = 1%
  *
  * 1023------100
  * 30----------X = 3000/1023 = 3%
  *
  * 1023------100
  * 70----------X = 7000/1023 = 7%
  *
  * 1023------100
  * 140------  -X = 14000/1023 = 13,6%
  *
  * 1023------100
  * 255---------X = 25500/1023 = 25%  
  ********************************************
  * Para pagar a E²PROM, deve-se zerar os cincos endereços A,B,C,D e E  
  *
 */
 
 #include <EEPROM.h>

 #define led 9    // saida PWM
 #define PWM 16
 #define Clear 0  // ( 1 ) Habilita a função que zera a E²PROM        ( 0 ) Desabilita  

// ( * ) a inicialização da variável é o endereço da E²PROM
// ****************
   int addressA = 0x00 ;  // ( ver serial )
   int addressB = 0x01 ;  // ( ver serial )
   int addressC = 0x02 ;  // ( ver serial )
   int addressD = 0x03 ;  // ( ver serial )
   int addressE  = 0x04 ;  // ( ver serial )    
// ****************

// os valores já estão gravados na memória E²PROM 0 = 11, 1 = 30, 2 = 70, 3 = 140, 4 = 255
 byte value = 0xff;    /* Grave aqui o ( VALOR ) no endereço da E²PROM  OBS.( 0 até 255 )*/
 int val;
 byte contador = 0;
 
 void setup() {
    Serial.begin( 9600 );
    pinMode( led, OUTPUT) ;    
    pinMode( 13, OUTPUT );
    Serial.end();         
 }

 void loop() {

    #if Clear == 0
         EEPROM.write(addressE, value);  // Mude aqui o ( ENDEREÇO ) da E²PROM OBS.( 0 até 1023 para ATmega328P )
    #endif
    
    int T_arbit = 300;
    static unsigned long inicio = 0;
    unsigned long debounce;
    debounce = millis () - inicio;
    if( debounce >= T_arbit ) {       
         contador++;
         if( contador > 4 ) {
              contador = 0;   
            }   
      
         switch ( contador ) {
              case 0:
                  val = EEPROM.read( addressA );
                  break;
              case 1:
                  val = EEPROM.read( addressB );
                  break;                 
              case 2:
                  val = EEPROM.read( addressC );
                  break;
              case 3:
                  val = EEPROM.read( addressD );
                  break;
              case 4:
                  val = EEPROM.read( addressE );
                  break;          
         }  
         inicio = millis();
         Serial.println( val );
         Serial.print("  Valor lido na E²PROM " );
       }
      
   analogWrite( led, val );   // escreve no pino 9 com duty cycle pwm de 1,5% 6,8% e 25%   

   //  Limpa a E²PROM
   #if Clear == 1
       for( int EEPROMClear = 0 ; EEPROMClear < 5 ; EEPROMClear++ ) {
                 EEPROM.write( EEPROMClear, 0 );    
            }
   #endif      
 }
// ********************* ebd ************************

 

Estude

“pois o saber não ocupa espaço de memória”

Retornar para página principal

  • b-facebook
  • Twitter Round
  • b-googleplus
bottom of page