ArduShop.ro

ArduShop.ro
cod Z4A413ZN reducere 5%, pentru vizitatorii paginilor mele !

miercuri, 25 septembrie 2013

Module de transmisie/receptie radio si... Arduino

    Desi am achizitionat de ceva timp o pereche de emitator/receptor pentru frecventa de 433MHz, abia acum am reusit sa fac niste teste.
   Emitatorul are codul MX-FS-03V, iar receptorul MX-05...
   Libraria care se foloseste uzual se numeste VirtualWire.
Eu m-am inspirat din 2 articol despre care unul se gaseste la pjrc.com:
iar celalalt la buildcircuit.com.
   Am folosit 2 placi Arduino, una chinezeasca pe post de receptor si una facuta de mine (Arduiniq sau Arduino de casa), pe post de emitator:
   Schema de conectare este:
   Trebuie retinut ca placa care este conectata cu modul de emisie transmite pe pinul digital 12 (D12), iar cea care este conectata cu modulul receptor primeste datele pe pinul digital 11 (D11).
   In primele teste am costatat ca modulele fara antena pot comunica pe distanta foarte mica (de ordinul centimetrilor), asa ca am improvizat cate o antena din agrafe de birou, distanta de comunicare stabila crescand la cca. 9m:
   Pentru emitator am folosit sketch-ul:
 /*  
 SimpleSend  
 This sketch transmits a short text message using the VirtualWire library  
 connect the Transmitter data pin to Arduino pin 12  
 See more at: http://www.buildcircuit.com/how-to-use-rf-module-with-arduino/#sthash.cUJ8ndxT.dpuf  
 adapted sketch by niq_ro from http://nicuflorica.blogspot.com  
 */  
 #include <VirtualWire.h>  
 const int led_pin = 13;  
 void setup()  
 {  
 // Initialize the IO and ISR  
 vw_setup(2000); // Bits per sec  
 }  
 void loop()  
 {  
 digitalWrite(led_pin, HIGH); // Flash a light to show transmitting  
 send("Salut, Nicu!");  
 delay(1000);  
 }  
 void send (char *message)  
 {  
 vw_send((uint8_t *)message, strlen(message));  
 vw_wait_tx(); // Wait until the whole message is gone  
 digitalWrite(led_pin, LOW); // Flash a light to show transmitting  
 }  

iar pentru receptor:
 /*  
 SimpleReceive  
 This sketch displays text strings received using VirtualWire  
 Connect the Receiver data pin to Arduino pin 11  
 //- See more at: http://www.buildcircuit.com/how-to-use-rf-module-with-arduino/#sthash.cUJ8ndxT.dpuf  
 // modified sketch by niq_ro ( http://nicuflorica.blogspot.com )  
 */  
 #include <VirtualWire.h>  
 byte message[VW_MAX_MESSAGE_LEN]; // a buffer to store the incoming messages  
 byte messageLength = VW_MAX_MESSAGE_LEN; // the size of the message  
 void setup()  
 {  
 Serial.begin(9600);  
 Serial.println("Receptorul e pregatit sa primeasca mesaje...");  
 // Initialize the IO and ISR  
 vw_setup(2000); // Bits per sec  
 vw_rx_start(); // Start the receiver  
 }  
 void loop()  
 {  
 if (vw_get_message(message, &messageLength)) // Non-blocking  
 {  
 Serial.print("Am receptionat mesajul: ");  
 for (int i = 0; i < messageLength; i++)  
 {  
 Serial.write(message[i]);  
 }  
 Serial.println();  
 }  
 }  

26.09.2013
   Am gasit un articol frantuzesc bun la skyduino.wordpress.com despre transmisia care foloseste aceeasi librarie.
   Dupa ce am inceput sa ma joc cu textul de transmis, pana la maximul din documentatie (27 caractere), am constatat ca apar probleme de transmisie... aparand erori, de fapt trunchieri ale mesajului.

 

 
 
 
   Am conectat si direct modulele prin fire (masa si firul de transmisie/receptie) pentru a depista problema...
   Am ajuns la concluzia ca textele de 5-8 caractere sunt transmise si receptionate bine, dar din cand in cand e bine sa opresc partea de receptie si s-o repornesc dupa 25 de mesaje, asa cam sketch-ul arata cam asa:
 /*  
 SimpleReceive  
 This sketch displays text strings received using VirtualWire  
 Connect the Receiver data pin to Arduino pin 11  
 //- See more at: http://www.buildcircuit.com/how-to-use-rf-module-with-arduino/#sthash.cUJ8ndxT.dpuf  
 // modified sketch by niq_ro ( http://nicuflorica.blogspot.com )  
 */  
 #include <VirtualWire.h>  
 uint8_t message[VW_MAX_MESSAGE_LEN]; // a buffer to store the incoming messages  
 // byte message[VW_MAX_MESSAGE_LEN]; // a buffer to store the incoming messages  
 uint8_t messageLength = VW_MAX_MESSAGE_LEN; // the size of the message  
 //byte messageLength = VW_MAX_MESSAGE_LEN; // the size of the message  
 int led = 13;  
 int j=0; // count received message;  
   
 void setup()  
 {  
 pinMode(led, OUTPUT);   
 Serial.begin(9600);  
 Serial.println("Receptorul e pregatit sa primeasca mesaje...");  
 // Initialize the IO and ISR  
 vw_setup(2000); // Bits per sec  
 vw_rx_start(); // Start the receiver  
 }  
 void(* resetFunc) (void) = 0; //declare reset function @ address 0  
      
 void loop()  
 {  
 if (vw_wait_rx_max(200)) // Si un message est reçu dans les 200ms qui viennent  
   {  
 if (vw_get_message(message, &messageLength)) // Non-blocking  
 {  
 vw_wait_rx();  
 digitalWrite(led, HIGH);    
 j=j++;  
 Serial.print("Am receptionat mesajul, ");  
 Serial.print(j);  
 Serial.print(" din ");  
 Serial.print(messageLength);  
 Serial.print("/");  
 Serial.print(VW_MAX_MESSAGE_LEN);  
 Serial.print(" caractere: ");  
 for (int i = 0; i < messageLength; i++)  
 {  
 Serial.write(message[i]);  
 }  
 Serial.println();  
 digitalWrite(led, LOW);  
   
 if (j>25) // if received 25 messages, stop the receiver  
 {  
 vw_rx_stop(); // Stop the receiver  
 //delay (500);  
 //Serial.end();  
 //Serial.begin(9600);  
 Serial.println("Receptorul e pregatit iar sa primeasca mesaje...");  
 vw_setup(2000); // Bits per sec  
 vw_rx_start(); // Start the receiver  
 
 j=0;  
    }  
   }  
  }  
 }  
   

 
   Am adaugat si o resetare automanata dupa 150 de mesaje pentru a elimina cat mai mult posibilitatea primirii de mesaje false:
 /*  
 SimpleReceive  
 This sketch displays text strings received using VirtualWire  
 Connect the Receiver data pin to Arduino pin 11  
 //- See more at: http://www.buildcircuit.com/how-to-use-rf-module-with-arduino/#sthash.cUJ8ndxT.dpuf  
 // modified sketch by niq_ro ( http://nicuflorica.blogspot.com )  
 */  
 #include <VirtualWire.h>  
 uint8_t message[VW_MAX_MESSAGE_LEN]; // a buffer to store the incoming messages  
 // byte message[VW_MAX_MESSAGE_LEN]; // a buffer to store the incoming messages  
 uint8_t messageLength = VW_MAX_MESSAGE_LEN; // the size of the message  
 //byte messageLength = VW_MAX_MESSAGE_LEN; // the size of the message  
 int led = 13;  
 int j=0; // count received message;  
 int k=0; // count received message for master reset;  
   
 void setup()  
 {  
 pinMode(led, OUTPUT);   
 Serial.begin(9600);  
 Serial.println("Receptorul e pregatit sa primeasca mesaje...");  
 // Initialize the IO and ISR  
 vw_setup(2000); // Bits per sec  
 vw_rx_start(); // Start the receiver  
 }  
 void(* resetFunc) (void) = 0; //declare reset function @ address 0  
   
   
 void loop()  
 {  
 if (vw_wait_rx_max(200)) // Si un message est reçu dans les 200ms qui viennent  
   {  
 if (vw_get_message(message, &messageLength)) // Non-blocking  
 {  
 vw_wait_rx();  
 digitalWrite(led, HIGH);    
 j=j++;  
 k=k++;  
 Serial.print("Am receptionat mesajul, ");  
 Serial.print(k);  
 Serial.print(" din ");  
 Serial.print(messageLength);  
 Serial.print("/");  
 Serial.print(VW_MAX_MESSAGE_LEN);  
 Serial.print(" caractere: ");  
 for (int i = 0; i < messageLength; i++)  
 {  
 Serial.write(message[i]);  
 }  
 Serial.println();  
 digitalWrite(led, LOW);  
   
 if (j>25) // if received 25 messages, stop the receiver  
 {  
 vw_rx_stop(); // Stop the receiver  
 //delay (500);  
 //Serial.end();  
 //Serial.begin(9600);  
 Serial.println("Receptorul e pregatit iar sa primeasca mesaje...");  
 vw_setup(2000); // Bits per sec  
 vw_rx_start(); // Start the receiver  
   
 j=0;  
 }  
 if (k>150)  
 {  
 Serial.println("resetting");  
  resetFunc(); //call reset  
  /*  
  http://www.instructables.com/id/two-ways-to-reset-arduino-in-software/step2/using-just-software/  
  */  
 }  
   
 }  
   }  
 }  
   
   Distanta maxima de comunicare este de cca. 16m, pentru transmisia la 2000 bps intr-o cladire pe structura metalica si pereti din rigips si BCA... destul de putin fata de cat se prezinta pe net... 

   Trebuie sa incerc si varianta transmisiei seriale cum e prezentat la garagelab.com
sau cea de la hobby robotics:
sau la Sparkfun...
 /*  
 * Simple Transmitter Code  
 * This code simply counts up to 255  
 * over and over  
 * (TX out of Arduino is Digital Pin 1)  
 */  
 byte counter;  
 void setup(){  
 //2400 baud for the 434 model  
 Serial.begin(2400);  
 counter = 0;  
 }  
 void loop(){  
 //send out to transmitter  
 Serial.print(counter);  
 counter++;  
 delay(10);  
 }  
respectiv:
 /*  
 * Simple Receiver Code  
 * (TX out of Arduino is Digital Pin 1)  
 * (RX into Arduino is Digital Pin 0)  
 */  
 int incomingByte = 0;  
 void setup(){  
 //2400 baud for the 434 model  
 Serial.begin(2400);  
 }  
 void loop(){  
 // read in values, debug to computer  
 if (Serial.available() > 0) {  
 incomingByte = Serial.read();  
 Serial.println(incomingByte, DEC);  
 }  
 incomingByte = 0;  
 }  
    Am testat aceste 2 sketch-uri, prin care Arduino de casa transmite necodat numere de la 0 la 255 din cand in cand pe Tx (am modificat sa transmita mai rar), iar Arduino Uno primeste pe pinul Rx si am constatat ca primesc numere mereau, am deconectat emitatorul meu si numerele aleatoare sunt primite, asa am realizat ca si ce am testat eu intial este influentat de "celalalt" emitatorul... care nu-i al meu... 

27.09.2013
   Rasfoind forumul Arduino am regatit o discutie despre transmiterea, respectiv receptia mai multor valori pe unde radio, iar de acolo se facea trimitere la Control Robotics... mentionez ca se foloseste tot libraria Wirtualwire.
 
   Am adaptat un pic sketch-urile de acolo pentru a aprinde LED-urile de la D13 cand transmit, respectiv primesc date, iar datele de transmitere sunt alese aleator de mine (0, 1023, 255, 725).

 /*.............................................................  
 Sending Multiple Variables Using VirtualWire. Transmitter  
 Author: Rodrigo Mompo Redoli  
 For controlrobotics.rodrigomompo.com  
 ..............................................................*/  
 #include <VirtualWire.h>  
 int Sensor1Pin = A1;// The pins were sensor are attached  
 int Sensor2Pin = A2;  
 int Sensor3Pin = A3;  
 int Sensor4Pin = A4;   
 int ledPin = 13;  
 int Sensor1Data;// The variable were the data from each sensor  
 int Sensor2Data;// will be stored   
 int Sensor3Data;  
 int Sensor4Data;  
 char Sensor1CharMsg[21];// The string that we are going to send trought rf   
 void setup() {  
  // LED   
  pinMode(ledPin,OUTPUT);  
  // Sensor(s)  
  pinMode(Sensor1Pin,INPUT);  
  pinMode(Sensor2Pin,INPUT);  
  pinMode(Sensor3Pin,INPUT);  
  pinMode(Sensor4Pin,INPUT);  
  // VirtualWire setup  
  vw_setup(2000); // Bits per sec  
  vw_set_tx_pin(12);// Set the Tx pin. Default is 12  
 }  
 void loop() {  
  // Read and store Sensor Data or put a predefined values (min=0, max=1023, 255, 725)
  /*  
  Sensor1Data = analogRead(Sensor1Pin);  
  Sensor2Data = analogRead(Sensor2Pin);  
  Sensor3Data = analogRead(Sensor3Pin);  
  Sensor4Data = analogRead(Sensor4Pin);  
  */  
  Sensor1Data = 0;  
  Sensor2Data = 1023;  
  Sensor3Data = 255;  
  Sensor4Data = 725;  
  sprintf(Sensor1CharMsg, "%d,%d,%d,%d,", Sensor1Data, Sensor2Data, Sensor3Data, Sensor4Data);  
  // Turn on a light to show transmitting  
  digitalWrite(ledPin, HIGH);  
  vw_send((uint8_t *)Sensor1CharMsg, strlen(Sensor1CharMsg));  
  vw_wait_tx(); // Wait until the whole message is gone  
  // Turn off a light after transmission  
  delay(200);  
  digitalWrite(ledPin, LOW);  
  delay(2000);  
 }  
respectiv
 /*.............................................................  
 Sending Multiple Variables Using VirtualWire. Receiver  
 Author: Rodrigo Mompo Redoli  
 For http://controlrobotics.rodrigomompo.com  
 adapted sketch by niq_ro (Nicu FLORICA) from http://nicuflorica.blogspot.com  
 ..............................................................*/  
 #include <VirtualWire.h>  
 // Sensors   
 int Sensor1Data;  
 int Sensor2Data;  
 int Sensor3Data;  
 int Sensor4Data;  
 char StringReceived[22];   
 int led = 13;   
 void setup() {  
 pinMode(led, OUTPUT);   
 Serial.begin(9600);  
 Serial.println("Receptorul lui niq_ro e pregatit sa primeasca mesaje...");   
  // VirtualWire   
   // Initialise the IO and ISR  
   // Required for DR3100  
   // Bits per sec  
   vw_setup(2000);  
   vw_set_rx_pin(11);   
   // Start the receiver PLL running  
   vw_rx_start();      
 } // END void setup  
 void loop(){  
   uint8_t buf[VW_MAX_MESSAGE_LEN];  
   uint8_t buflen = VW_MAX_MESSAGE_LEN;  
 //Taking the data from the control base  
   if (vw_get_message(buf, &buflen))   
   {  
    digitalWrite(led, HIGH);    
  int i;  
     // Message with a good checksum received, dump it.   
     for (i = 0; i < buflen; i++)  
  {        
      // Fill Sensor1CharMsg Char array with corresponding   
      // chars from buffer.    
      StringReceived[i] = char(buf[i]);  
      Serial.print(StringReceived[i]);  
  }  
    sscanf(StringReceived, "%d,%d,%d,%d,%d,%d",&Sensor1Data, &Sensor2Data,&Sensor3Data,&Sensor4Data); // Converts a string to an array  
 Serial.println();  
 digitalWrite(led, LOW);      
     // Turn off light to and await next message   
   }  
  memset( StringReceived, 0, sizeof( StringReceived));// This line is for reset the StringReceived  
 }  

Schema de conexiune, pentru citirea a 4 valori analogice este:
si trebuie scoase ghilimele de le-am pus eu la citirea intrarilor analogice si mutate la cele predefinite:

void loop() {  
  // Read and store Sensor Data or put a predefined values (min=0, max=1023, 255, 725)
  /*  
  Sensor1Data = analogRead(Sensor1Pin);  
  Sensor2Data = analogRead(Sensor2Pin);  
  Sensor3Data = analogRead(Sensor3Pin);  
  Sensor4Data = analogRead(Sensor4Pin);  
  */  
  Sensor1Data = 0;  
  Sensor2Data = 1023;  
  Sensor3Data = 255;  
  Sensor4Data = 725;  

si trebuie scoase ghilimele de le-am pus eu la citirea intrarilor analogice si mutate la cele predefinite:

void loop() {  
  // Read and store Sensor Data or put a predefined values (min=0, max=1023, 255, 725)
  
  Sensor1Data = analogRead(Sensor1Pin);  
  Sensor2Data = analogRead(Sensor2Pin);  
  Sensor3Data = analogRead(Sensor3Pin);  
  Sensor4Data = analogRead(Sensor4Pin);  
  /*  
  Sensor1Data = 0;  
  Sensor2Data = 1023;  
  Sensor3Data = 255;  
  Sensor4Data = 725;  
  */

duminică, 22 septembrie 2013

Frecventmetru cu.. Arduino

    Un aparat de masura foarte util celor care au pasiunea echipamentelor de telecomuncatii radio este frecventmetrul, adica aparatul care masoara frecventa.
    Pe site-ul lablll (interface.khm.de) am gasit articolul Arduino Frequency Counter Library scris de Martin Nawrath, care prezinta un frecvenmetru care face masuratori pana la 8MHz folosind o librarie proprie (pe care o puteti se descarca de la http://interface.khm.de/wp-content/uploads/2009/01/FreqCounter_1_12.zip).
   Atentie: intrarea semnalului se face doar pe pinul digital 5 al placii Arduino...
   Schema de conectare este foarte simpla constand dintr-un un preamplificator sau un inversor pentru a avea la intrare semnal logic compatibil cu microcontrolerul ATmega depe placa Arduino:

   Sketch-ul propus in acel articol e unul foarte simplu, afisarea frecventei facandu-se pe ecranul calculatorului (monitorizare seriala):
 #include <FreqCounter.h>  
   
 void setup() {  
  Serial.begin(57600);          // connect to the serial port  
  Serial.println("Frequency Counter");  
 }  
   
 long int frq;  
 Void loop() {  
   
  FreqCounter::f_comp= 8;       // Set compensation to 12  
  FreqCounter::start(1000);      // Start counting with gatetime of 1000ms  
  while (FreqCounter::f_ready == 0)     // wait until counter ready  
    
  frq=FreqCounter::f_freq;      // read result  
  Serial.println(frq);        // print result  
  delay(20);  
 }  

   Aceeasi librarie este folosita si in articolul Arduino Frequency Counter, de data asta afisarea facandu-se pe un ecran LCD cu 16 coloane si 2 randuri (cel care foloseste driver-ul DS44780 si notat, uneori, 1602):
   Schema de conectare este urmatoarea:
iar sketch-ul este:
 #include <FreqCounter.h>  
 #include <LiquidCrystal.h>  
   
 LiquidCrystal lcd(2, 3, 4, 6, 7, 8, 9); //Delcares LCD display pins  
 unsigned long frq; //Declares an extended size variable for the measured frequency  
 int cnt;  
   
 void setup() {  
    
  lcd.begin(16, 2); //LCD display columns and rows  
    
  lcd.print("FrequencyCounter"); //Prints a splash screen for 2 seconds  
  lcd.setCursor(0, 1);  
  lcd.print(" Version 2.1 ");  
  delay(2000);  
    
  lcd.clear();  
  lcd.setCursor(0, 0);  
  lcd.print("Frequency /Hz :"); //Prints "Frequency /Hz :"  
    
 }  
   
 void loop() {  
   
  FreqCounter::f_comp=10;  
  FreqCounter::start(1000);  
   
  while (FreqCounter::f_ready == 0)   
   
  frq=FreqCounter::f_freq; //Sets the 'frq' variable as the measured frequency  
    lcd.setCursor(0, 1);  
    lcd.print(frq); //Prints this measured frequency  
    lcd.print("    ");  
 }  

 
   Un alt articol, care foloseste aceasta librarie, facand si comparati intre masuratori cu acest frecventmetru si unul profesional, se numeste http://www.toddfun.com/2013/02/07/arduino-frequency-display-for-kenwood-ts-520s-hf-ham-radio-part-1/

   Ulterior am gasit un site frantuzesc, http://f5mna.free.fr/, care are publicat articolul Fréquencemètre VHF UHF Arduino Exploitation de la librairie "FreqCount"
   Acest frecventmetru masoara pana la 600MHz cu o rezolutie de 100Hz folosindu-se de un divizor dedicat, MB506 (datasheet-ul s epoate descarca de la http://www.qsl.net/n9zia/900/mb506.pdf, pus la intrarea placii Arduino sa divizeze cu 64.
   Partea de conectare si programele aferente se gasesc la adresa http://f5mna.free.fr/arduino/Freq_Arduino.zip, schema dedivizare fiind:
   Partea de afisare se poate adapta pentru domenii de Hz, kHz, MHz, inclusiv o autoscalare, prin conectarea divizorului si selectarea domeniului de divizare 64 sau 256, dar asta intr-un articol viitor...
   Pana una alta, prezint sketch-ul din articolul frantuzesc, cu explicatii ale liniilor din program:
 /*   
  //////////////// Fréquencemètre///////////////////  
    
  * Utilise le prédiviseur MB506 FUJITSU   
  * Les limites de la fréquence d'entrée Arduino et le division par 64  
  * autorisent un comptage jusqu'à environ 600 Mhz pour cette version.  
  * Pour mesurer une fréquence supérieure, le facteur de division sera  
  * de 128 ou 256 (Cf Datasheet).  
  * la ligne " unsigned long count = FreqCount.read() * 0.64001422;"  
  * sera modifiée en conséquence: 1.28 ou 2.56  
  * La valeur 001422 ci-dessus est une valeur d'ajustement.  
  *  
  * Mon site : http://f5mna.free.fr  
  *  
  *   
  * Entrée comptage PIN 5 dig.  
  */  
  // comentarii in romaneste de Nicu FLORICA aka niq_ro  
    
 #include <FreqCount.h> // foloseste libraria dedicata pentru a masura frecventa  
 #include <LiquidCrystal.h> // foloseste libraria dedicata pentru afisaj LCD gen 1602  
 LiquidCrystal lcd(8, 9, 4, 3, 6, 7); // indica modul de conectare al pinior afisajului la placa Arduino  
// LiquidCrystal lcd(RS, E, D4, D5, D6, D7); //se definesc pinii utilizati la afisajul LCD
   
 unsigned long count0, count1, count2, count3, count4, count5; // se definesc variabile de lungime mare de la 0 la 4.294.967.295 (2^32-1)  
   
 void setup() {  
  lcd.begin(16, 2); // definire LCD ca 16x2  
  lcd.setCursor(0, 0); // pozitionare cursor in colt stanga sus  
  lcd.print (" FREQUENCEMETRE "); // scrie textul  
  lcd.setCursor(0, 1); // muta cursorul in colj stanga jos  
  lcd.print ("F5MNA Version 1"); // scrie alt text  
  delay(2000); // asteapta 2 secunde (2000ms)  
  lcd.clear (); // sterge ecranul  
  lcd.setCursor(3, 0); // muta cursorul pe colaone 3 de pe randul 0 (randul de sus)  
  lcd.print("Frequence"); // scrie frecventa  
  FreqCount.begin(1000); // citeste frecventa timp de 1 secunda (1000ms)  
    
 }  
   
 void loop() { // aici incepe progrsmul care ruleaza in blucla infinita  
   if (FreqCount.available()) // daca la intrare este semnal  
   {   
   unsigned long count = FreqCount.read() * 0.64007324; // valoare citita la pinul 5 este inmultita cu 0,64. deoarece a fost divizata anterior cu 64   
     
   // ATENTIE: face asta deoarece nu-i ajung numarul de cifre.. deci "count" e valoarea frecventei impartita la 100  
     
    //unsigned long count = FreqCount.read() * 1.28; // GHz // daca divizarea ar fi cu 128  
 // era asa:  if (count < 10000) { (count = 0);} // signaux parasites ! / daca valaorea citita e mai mica de 10000x100=1MHz, insemna ca e zgomot si considera frecventa zero  
 // eu zic, deoare nu ar masura sub 1MHz  
   if (count < 100) { (count = 0);} // signaux parasites ! / daca valaorea citita e mai mica de 100x100=10000Hz=10kHz, insemna ca e zgomot si considera frecventa zero  
      
   /* Calcul du facteur de division.(1.0000222 ci-dessus)  
    Le quartz de 16 Mhz pilotant Arduino n'est pas précis ni identique pour toutes les platines.  
    Une correction peut être nécessaire au niveau logiciel. Pour ce faire,   
    mesurer la fréquence avec un fréquencemetre étalonné.  
    Puis faire le rapport entre féquence étalon mesurée et fréquence mesurée avec   
    ce fréquencemetre. Exemple 145000200/145000000 = 1.0000014   
    Multiplier le facteur de division (exemple 64) par cette valeur  
    vous obtenez 64.000088. Le facteur de correction devient 0.64000088   
    donc (count = count * 0.64000088)  
   */  
     
  /*     
  // Affichage GHz si nécessaire  
  /////////////////////////////  
    
  // e asa ca nu e bine gandit..  
    
   if (count > 999999999) {   
   count1= (count/100000);   
   count2 = (count - (count1*100000));  
   count3 = (count2/10);  
   count4 = ((count2) - count3*10 );  
   }   
  */  
    
  //  Mhz   
  ///////////////////   
 // original: if ((count > 999999) and (count < 1000000000)) (count1 = (count /10000));  
 // eu zic ca:  
   if ((count > 9999) and (count < 10000000)) (count1 = (count /10000));  
    {   
   count1 = (count /10000); // afla partea intreaga a milioanelor, care reprezinta si numarul milioanelor din numar  
   count2 = (count - (count1*10000)); // afla valoarea numarului de la mii in jos  
   count3 = (count2/10); // afla cifrele de mii  
   count4 = ((count2) - count3*10 ); // afla valoarea ultimei cifre din variabila "count", care reprezinta cifra sutelor din frecventa masurata  
   }  
    
  //  < 1 MHz  
  ////////////////////  
 // nu prea trebuie asta ca e acelasi lucru ca mai sus... deoarece count1=0  
 // original: if (count < 1000000)   
 // eu zic asa:  
   if (count < 10000) // faca frecventa citita e mai mica decat 1MHz (deci valoarea lui "count" < 10000  
   {  
   count2 = (count - (count1*1000)); // valoarea numarului de la mii in jos  
   count3 = (count2/10); // afla cifrele de la mii  
   count4 = ((count2) - count3*10 ); // afla valoarea ultimei cifre din variabila "count"  
   }  
   
   lcd.setCursor(3, 1); // pune cursorul pe randul 1, de jos, si a 3-a coloana  
   lcd.print (count1); // afiseaza cifrele din milioane  
   lcd.print ("."); // pune punct  
   if ((count3 < 100)and (count3 > 9)) (lcd.print ("0")); // daca cifrele din mii sunt de 2 cifre scrie un zero   
   if (count3 < 10) (lcd.print ("00")); // daca e doar o cifra la mii pune 2 de zero  
   lcd.print (count3); // afiseaza cifrele din mii  
   lcd.print ("."); // pune un punct  
   lcd.print (count4); // afiseaza cifra sutelor din frecventa  
   lcd.print ("00"); // rotunjeste cu 2 zerouri  
   lcd.print ("Hz  "); // pusa de niq_ro si unitatea de masura  
   delay (100); // asteapta 0,1secunde si incepe iar masurarea si calculele  
  }  
  }  
   

PS: divizorul cu MB506 modificat pentru 256 in loc de 64 arata asa:

23.09.2013
   Pe ecran sunt afisate urmatoare variante:


   Eu m-am gandit sa afisez frecventa, dar am doua variante:
- in Hz cu puncte intre multiplii
- in GHz cu virgula dupa cifra GHz-ilor, respectiv puncte intre ceilalti multiplii
   Trebuie sa am si un aranjament al afisarii, asa ca m-am gandit la urmatoarele situatii:
- frecventa sub 1kHz
- frecventa peste 1kHz si sub 1MHz
- frecventa peste 1MHz si sub 1GHz
- frecventa peste 1GHz

24.09.2013
   Situatiile ar fi:


31.12.2014
   Am realizat un montaj de testare pentru un generator de semnal cu AD9850 dupa indicatiile din articolul de la http://www.ad7c.com/projects/ad9850-dds-vfo/ obtinand:
   Apoi am incarcat intr-o alta placa Arduino primul sketch, pentru a vedea cum se comporta frecventmetrul (legare directa fara preamplificator, deoarece am semnal cu nivel suficient):
   Rezultatul este foarte bun, eroare de 0,165%:


miercuri, 18 septembrie 2013

Cum facem un cablaj

   Pentru experimente, foarte utile sunt cablajele de test sau cele special realizate, dar in cazul unor proiecte finale trebuie executate frumos si, mai ales, in forma definitiva.
   - cablaj de test cu gaurele: 
   - cablaj special realizat pentru experimente:


   - cablaje in forma definitiva:
   Metoda clasica, am prezentat-o in articolul de la http://www.arduinotehniq.com/old/cablaj/cablaj0.htm si, in mare, presupune urmatoarele etape:
   - desenat pe hartie cu patratele (de matematica) schema in spatiu sau cam cum ar arata, la o scara oarecare; 
   - desenat la scara cablajul pe hartie cu patratele sau calc; 
   Primele 2 etape se pot face foarte usor folosind executatea cablajului cu ajutorul unor programe dedicate si listarea pe hartie...
   - taiat cablajul cu o panza de bomfaier la dimensiunile desenului; 
   - slefuit cu smirghel fin partea acoperita; 
   - prins cu scotch hartia pe cablaj si punctat cu un dorn viitoarele gauri; 
   - desenat cu o seringa cu ac mai gros taiat in care este smoala diluata cu benzina sau antifon diluat.. in cazuri extreme foloseam o scobitoare ascutita, pentru cablaje nepretentioase; 
   - lasat la uscat cateva ore, in functie de vreme :)) 
   - introdus cablajul intr-o tava foto in care este acid azotic sau clorura ferica; 
   - stat pe langa placuta sa se termine "procesul"; 
   - scos placuta cu o penseta, spalata cu multa apa, sters cu o carpa uscata; 
   - sters smoala/antifonul cu diluant; 
   - protejat partea de cupru cu o solutie de sacaz diluat in spirt medicinal; 
   - gaurire placuta; 
   - uneori, acoperire cu fludor a tuturor traseelor...
   A doua varianta, prin metoda transferului de toner de pe hartie cretata, am prezentat-o in articolul de la http://arduinotehniq.com/old/cablaj1/cablaj.htm.
   Acum o sa va prezint o metoda care foloseste tot metoda transferului de tonner dar nu dupa hartie ci de pe bucatele de vinyl sticker (Oracal 641, de exemplu) care se foloseste la reclame. Am descoperit-o in articolul de la http://electroni-city.com/cablaj-simplu-placat/ (care momentan are ceva probleme tehnice, dar pe canalul de pe youtube al dlui Vicentiu Mincior gasiti tutoriale video in 15 pasi)
   Va prezint etapele in imagini (pozele si realizarea sunt ale lui Adi Roman):
- se realizeaza cablajul cu ajutorului unui program dedicat sau de ia de pe net fisierul cu cablajul la scara 1:1
- se listeaza cu imprimnta laser pe o foaie varianta in oglinda (textul de pe cablaj sa fie in oglinda)


- se masoara dimensiunea utila si se decupeaza o bucata ceva mai mare de vinyl stiker 


- se dezlipeste de pe hartia-suport si se lipeste pe hartia obisnuita, peste zona utila de listare
- se introduce harti ain imprimanta si se imprima la calitate maxima, din nou, cablajul




- aici e prezentat un alt cablaj



- se pregateste cablajul propriu-zis pentru transfer (debitare si curatire cu smirghel fin)


- se pozitioneaza vinyl stiker-ul peste cablaj

- se aduce la indemana un vas cu apa
- se "calca" cu fierul 
- se uda si se indeparteaza vinyl-ul





















- se introduce cablajul in clorura ferica
















PS: Puteti vedea in filmuletul Make your PCB in less than 10 minutes etapele prezentate mai sus:

Senzor de masurare tensiune si curent INA219

   Am achizitionat de curand, de la colaboratorii mei de la  ArduShop.ro , un modul cu senzor INA219, care poate masura tensiuni pana la 26V...