Convertor frecventa / tensiune

Dacă ai o singură gaură în roată da, este durata unei rotaţii.

1. Pulsein masoara din momentul in care ai tranzitia spre high (in cazul asta) si pana la tranzitia spre low. Deci ai numai o parte din ciclul complet. Acuma, in functie de cat de mare e zona low si cat de mare se doreste a fi precizia, poate fi ok. Ca varianta, daca se considera viteza constanta si e cunoscuta proportia high/low se poate face o aproximare a ciclului complet.
2. Eu am inteles din indicatii ca zona high e atunci cand e gaura in zona senzorului.

Funcţia PulseIn se poate calibra software pt. o reprezentare corectă. Dacă ştii raportul dintre diametrul găurii şi circumferinţa roţii în dreptul găurii se poate face o înmulţire a valorii citite cu acel raport şi se obţine durata completă a rotaţiei. Asta presupunând că optocuplorul comută instantaneu, însă ideea rămâne.

Da, exact, dar cu conditia ca viteza de rotatie sa nu aiba variatii bruste.

Exista optocuploare care merg si in praf. Slefuitoarele cu banda pentru lemn folosesc asa ceva.

Edited by barbu78, 24 May 2017 - 16:56.

 radu000, on 24 mai 2017 - 15:35, said:

Da asa este, cand gaura e in zona senzorului am hight. pulse in am vazut in doc ca masoara timpul dintre 2 hight ceea ce inseamna pt mine o rotatie completa...

In descrierea de pe arduino.cc scrie asa

pulseIn()
Description
Reads a pulse (either HIGH or LOW) on a pin. For example, if value is HIGH, pulseIn() waits for the pin to go HIGH, starts timing, then waits for the pin to go LOW and stops timing. Returns the length of the pulse in microseconds or 0 if no complete pulse was received within the timeout.


Iar daca e HIGH cand gaura e in zona senzorului, ar trebui sa masori LOW pentru o precizie mai buna. Iar rezultatul final il poti calcula cu formula data de mihaicozac dar putin modificata
[circumferinta pe linia gaurii / (circumferinta pe linia gaurii - diametrul gaurii)] * durata masurata

Edited by radu000, 24 May 2017 - 17:44.

Ai dreptate cu pulsein, am citit gresit documentatia.
Reiau problema:

Senzorul este HIGHT cand este in dreptul gaurii si LOW in timp ce "vede roata".

Pulse in HIGHT masoara timpul cat sta HIGHT si se opreste cand devine LOW. Practic in cazul meu masor cat senzorul vede gaura. (Prima oara intelesesem ca el masoara intre 2 HIGHT, de aici confuzia.

Daca fac pulse in LOW, atunci el asteapta sa devina LOW (cat timp se invarte roata) si se opreste can devine HIGHT (adica cand a ajuns in dreptul gaurii). In acest fel masor practic timpul in care roata face o rotatie completa.

Este corect acum?

Rotatia completa contine zona HIGH + zona LOW

 ROTATIE.jpg   70.24K   3 downloads

masori doar zona LOW si aproximezi rotatia completa cum ti-am zis.

Edited by radu000, 25 May 2017 - 14:22.

Sau faci 2 funcţii PulseIn una pe High cealaltă pe LOW şi aduni valorile.

Sau asa.

Multumesc frumos din nou.
@radu000 - Din nou ai dreptate

@mihaicozac - E buna ideea cu adunatul valorilor, incerc acum.

Btw - are vreo relevanta daca fac mai multe gauri? Adica sa am 4 de exemplu dispuse la distante egale (sa impart cercul in 4). Creste acuratetea ? sau ma complic degeaba

Edited by davidbr, 25 May 2017 - 14:40.

Depinde...  dacă vrei doar o măsurare a turaţiei fără prea mari pretenţii, o gaură e suficientă. Dacă vrei şi reglarea ei cu precizie, cu cât mai multe găuri cu atât mai bine.

Daca ai variatii rapide de turatie, ar fi util. Depinde la ce folosesti informatia aceea.
De exemplu ai initial 10 rotatii pe secunda si la un moment dat treci la 1 rotatie la 10 secunde. Daca iti trebuie info asta pentru un alt proces, atunci ai sa ai o perioada in care desi turatia e mica, info disponibila e pt 10 ture pe secunda. Daca e o singura gaura, intervalul asta e mai lung decat daca sunt mai multe gauri. Deci depinde daca problema asta te deranjeaza sau nu.

Edited by radu000, 25 May 2017 - 14:50.

Nu ma regasesc in scenariile descrise deci raman la o gaura )

Va multumesc frumos de ajutor

Revin cu rugamintea de a ma ajuta iar daca se poate.
Am reusit sa trimit pe i2c valoarea rpm de pe un arduino pe altul, dar problema este ca eu primesc pe master secventa de 4 caractere si nu reusesc sa o fac iarasi int sa pot face anumite operatii cu ea

Aveti vreo idee cum as putea face asta?

Cod slave:

// Slave rpm
#include <Wire.h>
unsigned char pin_in = A0;
float duration;
unsigned long val0, val1, val;
int rpm ;
char b[4] ="";
String rpm2 = "";
void setup() {
  Serial.begin(9600);
  pinMode(pin_in, INPUT);
  Wire.begin(10);				// join i2c bus with address #10
  Wire.onRequest(requestEvent); // register event
}
void loop() {
  val0 =  pulseIn(pin_in, LOW,1000000);
  val1 =  pulseIn(pin_in, HIGH,1000000);
  val = val0+val1;
  if (val==0){
	rpm = 1;
  }
  else {
	rpm = 60000000 / val / 4;
  }
  Serial.print(rpm);
  Serial.println();
  sprintf(b, "%04d", rpm);
  Serial.print(;
  Serial.println();
  delay(50);
}
void requestEvent() {
  //String randomString(;
 
  Wire.write(; // respond with message of 4 bytes as expected by master
}

Cod master

//Master rpm
#include <Wire.h>
void setup() {
  Wire.begin();		// join i2c bus (address optional for master)
  Serial.begin(9600);  // start serial for output
}
void loop() {
  Wire.requestFrom(10, 4);	// request 4 bytes from slave device #10
  while (Wire.available()) { // slave may send less than requested
	char c = Wire.read(); // receive a byte as character
   
	Serial.println(c);
  }
  delay(500);
}

Am rezolvat asa : (poate mai are nevoie cineva)

master

#include <Wire.h>
#define PAYLOAD_SIZE 4 // how many bytes to expect from each I2C salve node
#define NODE_MAX 4 // maximum number of slave nodes (I2C addresses) to probe
#define START_NODE 2 // The starting I2C address of slave nodes
#define NODE_READ_DELAY 100 // Some delay between I2C node reads
int nodePayload[PAYLOAD_SIZE];
void setup()
{
  Serial.begin(9600); 
  Serial.println("MASTER READER NODE");
  Serial.print("Maximum Slave Nodes: ");
  Serial.println(NODE_MAX);
  Serial.print("Payload size: ");
  Serial.println(PAYLOAD_SIZE);
  Serial.println("***********************");
 
  Wire.begin();		// Activate I2C link
}
void loop()
{
  for (int nodeAddress = START_NODE; nodeAddress <= NODE_MAX; nodeAddress++) { // we are starting from Node address 2
	Wire.requestFrom(nodeAddress, PAYLOAD_SIZE);	// request data from node#
	if(Wire.available() == PAYLOAD_SIZE) {  // if data size is avaliable from nodes
	  for (int i = 0; i < PAYLOAD_SIZE; i++) nodePayload[i] = Wire.read();  // get nodes data
	  for (int j = 0; j < PAYLOAD_SIZE; j++) Serial.println(nodePayload[j]);   // print nodes data  
	  Serial.println("*************************");	 
	  }
	}
	delay(NODE_READ_DELAY);
}

slave

#include <Wire.h>
#define NODE_ADDRESS 3  // Change this unique address for each I2C slave node
#define PAYLOAD_SIZE 4 // Number of bytes  expected to be received by the master I2C node
byte nodePayload[PAYLOAD_SIZE];
uint8_t r0,r1,r2;
unsigned char pin_in = A0;
unsigned long val0, val1, val;
int rpm;
void setup()
{
  pinMode(pin_in, INPUT);
// Serial.begin(9600); 
// Serial.println("SLAVE SENDER NODE");
// Serial.print("Node address: ");
// Serial.println(NODE_ADDRESS);
// Serial.print("Payload size: ");
// Serial.println(PAYLOAD_SIZE);
// Serial.println("***********************");
  Wire.begin(NODE_ADDRESS);  // Activate I2C network
  Wire.onRequest(requestEvent); // Request attention of master node
}
void loop()
{
  delay(50);
  val0 =  pulseIn(pin_in, LOW,1000000);
  val1 =  pulseIn(pin_in, HIGH,1000000);
  val = val0+val1;
  if (val==0){
	rpm = 0;
  }
  else {
	rpm = 60000000 / val / 4;
  }
   r0 = rpm/100;
   rpm = rpm-r0*100;
   r1 = rpm/10;
   r2 = rpm-r1*10;
 
 
  nodePayload[0] = NODE_ADDRESS; // I am sending Node address back.  Replace with any other data
  nodePayload[1] = r0;
  nodePayload[2] = r1;
  nodePayload[3] = r2;
 
}

Pt codul de mai sus rpm nu poate fi mai mare de 999.