Bygge av varvräknare med hallgivare *Så blev det *

[MiaM]

Ja, LochMaster verkar klart intressant!

Det jag menar med kontrast v.s. temperatur är att åtminstone vissa displayer behöver olika styrspänning för att ge vettig kontrast beroende på temperatur. Det är väl mest minusgraderna jag funderar på - jag vet inte hur du gör med båten när det är vinter. Om den hålls varm så är det ju inget större problem, men om du av någon anledning behöver köra när det är -30 så är risken stor att displayerna är blanka eller visar 8888 om de är trimmade för bäst kontrast vid +20.

Det här kanske blivit mycket bättre de senaste åren?

[SeniorLemuren]

Angående vintern. Temperaturen beror på vad jag sjäv tycker är lagom.

[SeniorLemuren]

Här blev det en liten utlöpare utanför projektet. Där finns ett par bilder av hur kortet blev till slut.

[SeniorLemuren]

Varvräknaren klar. Det blev en liten men oerhört rörig videosnutt också.
5 voltsregulatorn saknas fortfarande på kortet och är än så länge ersatt med en röd trådbit. Så den matas med en stabiliserad 5 Volt utifrån.

[Icecap]

Undrar på en sak: den går i steg om 10 RPM - men det var så viktigt med rätt kristall för att avvikelsen annars kunde bli för mycket mellan de två maskiner. Jag får inte riktigt den bit att hänga ihop...

[SeniorLemuren]

Jag satte den till 10 r/m här för att borrmaskinen är väldigt fladdrig och det blev inte bra att filma. Dieslmotorn är ju mycket mer stabil i sitt varvtal så när det är dags för montering så ändrar jag till 5 r/m.

[Icecap]

Ah... elementärt Watson...

[SeniorLemuren]

Lite slutliga kompletteringar. Har lagt in visning för rotationsriktning, Framåt/Bakåt. Pinne RB2 känner av signal från mikrobrytare på backslaget och informerar om riktning. När Noll RPM registreras så visas texten Stoppad. Har även plockat dit den 7805 jag fick på posten i dag från Swech.

Har inte lagt ut programmen i sin slutgiltiga version. Om någon är intresserad så är det bara att skrika till. ett stort tack till Icecap (och alla andra i forumet förstås) som tålmodigt har fört detta fram till en färdig lösning.

På bilden kan man se hallgivaren som jag helt enkelt bakade in i en krympslang. Vid sidan om ligger en likadan.
Den blå potten uppe till vänster är för bakgrundsbelysningen och den kommer sedan att flyttas ut från kortet och sammankopplas med övrig instrumentbelysning.

Slutligen kan man väl säga, att hade man etsat ett kort till detta så hade man kunna krympa ner det till en bråkdel av nuvarande storlek. Men eftersom jag har gott om plats rakt bakåt (som pigan sa) så funkar detta bra för mig.

Sista videosnutten för detta projekt följer här.

[frownlayer]

Jag har länge funderat på en varvräknare till en 2-taktsmotor.
Jag har en lcd och jag har pic16f690.
tror du det är svårt att göra om programmet så man tar bort rotationsriktning + byter skärm och microprocessor?

så skicka gärna programmet. jag är intresserad av all hjälp.

[Icecap]

LCD-modulen är i stort det samma, ska bara initieras som 2-radigt, annars identisk. Att få RPM på en 2-takt är mer en fråga om att få en bra puls ut, även där duger hall-sensorn.

Att låta bli att skriva fram/back är ju det lättaste av det hela så jag anser att SeniorLemurens projekt kan plankas nästan rakt av, den enda skillnad är att displayen är 2-radig och att det inte ska skrivas fram/back.

[PHermansson]

Där går det ju att ta pulser från tändspolen också. Men det gäller att ha avstört tändsystem, annars blir det inte vackert. Jag byggde nästan klart min, ska göra färdigt den när tid finns... info finns på http://elektronikforumet.com/forum/view ... =4&t=20529

[SeniorLemuren]

LCD-modulen är i stort det samma, ska bara initieras som 2-radigt, annars identisk. Att få RPM på en 2-takt är mer en fråga om att få en bra puls ut, även där duger hall-sensorn.

Att låta bli att skriva fram/back är ju det lättaste av det hela så jag anser att SeniorLemurens projekt kan plankas nästan rakt av, den enda skillnad är att displayen är 2-radig och att det inte ska skrivas fram/back.

Har du en texkendisplay med Svenska tecken så kan du skippa programmeringen av de egna tecknen också.
Så här är den den version ut som körs nu. den består av 3 filer.

1: lcd.c, som är drivfilen till displayen.
2 RPM-Measure.c som hanterar räknaren och vad som skall skrivas på displayen.
3 lcd.h, header file

Kod: Markera allt

/***********************/
/* File: RPM-Measure.c */
/* (C) */
/***********************/

#include <htc.h>
#include "lcd.h"


#define SHIFTS 0
#define CHANGE_BEFORE_UPDATE 10


#define false 0
#define true  1

#define _XTAL_FREQ 4000000
#define DelayS(T){unsigned char i;for (i=0; i<T*10; i++)__delay_ms(100);}

typedef unsigned char BYTE;
typedef unsigned int  WORD;
typedef unsigned long DWORD;

typedef union
  {
  DWORD Dword;
  WORD  Word[2];
  BYTE  Byte[4];
  } T_ALL_ACCESS;

T_ALL_ACCESS Time_Now, Time_Then, Time_Diff;

struct
  {
  unsigned char Running : 1;
  unsigned char Update : 1;
  unsigned char Timeout: 1;
  } Flag;

DWORD RPM;
DWORD RPMOLD;

void Initiate_Hardware(void);
void Print_RPM        (void);
void Check_RPM        (void);

#define Overflow Time_Now.Byte[2]
#define PRESCALE 1 /* In this case */
#define MAGIC_CONSTANT (DWORD)((DWORD)_XTAL_FREQ * (DWORD)15)

void main(void)
  {
#if SHIFTS
DWORD Intermediate;
#endif // SHIFTS
  Initiate_Hardware();
  RPM          = 0; // Initial value
  Flag.Running = false;
  Flag.Update  = true;
  Flag.Timeout = false;
  while(true)
    {
    if(Flag.Running)
      {
      RPM          = (MAGIC_CONSTANT / Time_Diff.Dword * 2);
      Flag.Running = false;
      Flag.Update  = true;
	#if SHIFTS
      Intermediate = (Intermediate - (Intermediate >> SHIFTS)) + RPM;
      RPM          = Intermediate >> SHIFTS;
	#endif // SHIFTS
      }
    if(Flag.Timeout)
      {
      RPM          = 0;
      Flag.Timeout = false;
      Flag.Update  = true;
	
      }
    if(Flag.Update)
      { // Print out RPM as needed
      lcd_goto(0);   // select first line
	  if (RB2)
      lcd_puts("Framåt  ");
	  else lcd_puts("Bakåt   ");
	 if (RPM < 10){
	  lcd_goto(0);   // select first line
	  lcd_puts("Stoppad ");
	  } 
      lcd_goto(0x40);   // Select second line
      Check_RPM();
      Flag.Update = false;
      }
    }
  }

void interrupt isr(void)
  {
  if(TMR1IF)
    {
    TMR1IF = false; // Acknowledge interrupt
#if false
    if(Flag.Running) if(++Overflow > 30) Flag.Timeout = true; // The 254 is just an example, other values might be used
    // 254 gives a max. count of 0xFEFFFF in the time measurement = no less than 3,6 RPM
	Flag.Running = false; // << Lade till denna
#else
    if(++Overflow > 30) Flag.Timeout = true; // The 254 is just an example, other values might be used
    // 254 gives a max. count of 0xFEFFFF in the time measurement = no less than 3,6 RPM
	Flag.Running = false; // << Lade till denna
#endif
//    Overflow   = 0; // << Och denna också
    }
  if(CCP1IF)
    { // Save data
    Time_Now.Byte[0] = CCPR1L; // Transfer the value, low byte
    Time_Now.Byte[1] = CCPR1H; // Transfer the value, high byte
    if(!Flag.Running)
      {
      Time_Diff.Dword = Time_Now.Dword - Time_Then.Dword;
      }
    Time_Then.Word[0]    = Time_Now.Word[0];
    Overflow     = 0;      // Start from known state
    Flag.Running = true;
    CCP1IF  = false; // Acknowledge interrupt
    }
  }

void Initiate_Hardware(void)
  {
  //TRISC   = 0b11111111; // All input
  CMCON   = 0b00000111; // No comparator inputs
  CCP1CON = 0b00000101; // Set CCP1 to capture all rising edges
  PIE1    = 0x05;       // Enable CCP1 & Timer1 overflow interrupts  
  PIR1    = 0x00;       // Clear all pending interrupts  
  T1CON   = 0b00000001; // Prescale 1:1, Timer1On = true
  INTCON  = 0xC0;       // Enable GIE & PEIE
  lcd_init();
  lcd_cur_off();
  
  }
void Check_RPM(void)
   {
	 if((RPM >= RPMOLD + CHANGE_BEFORE_UPDATE) || (RPM <= RPMOLD - CHANGE_BEFORE_UPDATE))
     {
     RPM    -= RPM % CHANGE_BEFORE_UPDATE;
     RPMOLD = RPM;
     Print_RPM();
     }
   }


void Print_RPM(void)
  {
  WORD Work;
  BYTE XX, Blank;
  Work = RPM ;
  Blank = ' ';
  XX = Blank;
  

  if(Work >= 1000)
    {
    Blank = '0';
    for(XX = '0'; Work >= 1000; Work -= 1000, XX++);
    }
  lcd_putch(XX);
  XX = Blank;
  if(Work >= 100)
    {
    Blank = '0';
    for(XX = '0'; Work >= 100; Work -= 100, XX++);
    }
  lcd_putch(XX);
  XX = Blank;
  if(Work >= 10)
    {
    for(XX = '0'; Work >= 10; Work -= 10, XX++);
    }
  lcd_putch(XX);
  XX = '0' + Work; 
  lcd_putch(XX); 
  lcd_puts(" RPM"); 	
  }

Kod: Markera allt

/*
 *	LCD interface to PIC16F628A
 *	File name lcd.c
 *	This code will interface to a standard LCD controller
 *	like the Hitachi HD44780. It uses it in 4 bit mode, with
 *	the hardware connected as follows :
 *	
 *	PORTD bits 0-3 are connected to the LCD data bits 4-7 (high nibble)
 *	PORTB bit 4 is connected to the LCD RS input (register select)
 *	PORTB bit 6 is connected to the LCD R/W bit (READ WRITE)
 *	PORTB bit 7 is connected to the LCD E bit (ENABLE)
 *	To use these routines, set up the port I/O (TRISB, TRISD) then
 *	call lcd_init(), then other routines as required.
 *	
 */

#ifndef _XTAL_FREQ
 // Unless specified elsewhere, 4MHz system frequency is assumed
#define _XTAL_FREQ 4000000
#endif


#include	<htc.h>
#include	"lcd.h"

#define	LCD_RS RA1
//#define	LCD_RW RB6
#define LCD_EN RA0

#define LCD_DATA	PORTB
//#define	LCD_STROBE()	((LCD_EN = 1),(LCD_EN=0))
#define LCD_STROBE() {LCD_EN = 1;  LCD_EN = 0;}

//Teckentabell med 8 byte för varje tecken. totalt 4 tecken å,Å,;Ä,Ö med adress 0x40 till 0x5f	
unsigned char char_table[32]={0x04,0x0e,0x11,0x11,0x1f,0x11,0x11,0x00,0x11,0x0e,0x11,0x11,0x1f,0x11,0x11,0x00,0x11,0x0e,0x11,0x11,0x11,0x11,0x0e,0x00,0x04,0x00,0x0e,0x01,0x0f,0x11,0x0f,0x00};


void
lcd_write(unsigned char c)
{
	if (c == 'Å') c = 0x00; // Å
	if (c == 'Ä') c = 0x01; // Ä
	if (c == 'Ö') c = 0x02; // Ö
	if (c == 'å') c = 0x03; // å
	if (c == 'ä') c = 0xe1; // ä
	if (c == 'ö') c = 0xef; // ö
	__delay_us(40);
// Denna rutin används när de låga bitarna är kopplade till LCD-modulen
	//LCD_DATA = (c & 0xF0) | (LCD_DATA & 0x0F);
  	//LCD_STROBE();
  	//LCD_DATA = ((c << 4) & 0xF0) | (LCD_DATA & 0x0F);
  	//LCD_STROBE();

// Denna rutin används när de höga bitarna är kopplade till LCD-modulen
	LCD_DATA = ( c & 0b11110000 );
	LCD_STROBE();	
	LCD_DATA = ( ( c << 4 ) & 0b11110000 );
	LCD_STROBE();
}

/*
 * 	Clear and home the LCD
 */

void
lcd_clear(void)
{
	LCD_RS = 0;
	lcd_write(0x1);
	__delay_ms(2);
}
void
lcd_right(void)
{
	LCD_RS = 0;
	lcd_write(0x14);
	__delay_ms(2);
}

void
lcd_left(void)
{
	LCD_RS = 0;
	lcd_write(0x10);
	__delay_ms(2);
}
void
lcd_cur_off(void)
{
	LCD_RS = 0;
	lcd_write(0xC);
	__delay_ms(2);
}

/* write a string of chars to the LCD */

void
lcd_puts(const char * s)
{
	LCD_RS = 1;	// write characters
	while(*s)
		lcd_write(*s++);
}

/* write one character to the LCD */

void
lcd_putch(char c)
{
	LCD_RS = 1;	// write characters
	lcd_write( c );
}


/*
 * Go to the specified position
 */

void
lcd_goto(unsigned char pos)
{
	LCD_RS = 0;
	lcd_write(0x80+pos);
}


	
/* initialise the LCD - put into 4 bit mode */
void
lcd_init()
{
	char init_value;
	init_value = 0x30;
	TRISB= 0B00001100; // bit RB2 and RB3 input	
	CMCON = 0b00000111;   //Comparators Off
	TRISA = 0b00000000;
	LCD_RS = 0;
	LCD_EN = 0;
	//LCD_RW = 0;
	
	__delay_ms(50);	// wait 15mSec after power applied,
	LCD_DATA	 = init_value;
	LCD_STROBE();
	__delay_ms(5);
	LCD_STROBE();
	__delay_us(200);
	LCD_STROBE();
	__delay_us(200);
	LCD_DATA = 20;	// Four bit mode
	LCD_STROBE();

	lcd_write(0x28); // Set interface length
	lcd_write(0xF); // Display On, Cursor On, Cursor Blink
	lcd_clear();	// Clear screen
	lcd_write(0x6); // Set entry Mode

	// ladda ner svenska tecken	
int i=0;
for(i = 0; i < 32; i++){
	LCD_RS = 0;
	lcd_write(0x40+i); //CG-RAM-adress
	__delay_us(50);
	LCD_RS = 1;
	lcd_write(char_table[i]); //CG-RAM-data	
	__delay_us(50);
	}

	//TRISB= 0B00001100;
	
}

Kod: Markera allt

/*	Ver 1.0
 *	LCD interface header file
 *	File name lcd.c 
 */

/* write a byte to the LCD in 4 bit mode */

extern void lcd_write(unsigned char);

extern void lcd_left(void);
extern void lcd_right(void);
extern void lcd_cur_off(void);

/* Clear and home the LCD */

extern void lcd_clear(void);

/* write a string of characters to the LCD */

extern void lcd_puts(const char * s);

/* Go to the specified position */

extern void lcd_goto(unsigned char pos);
	
/* intialize the LCD - call before anything else */

extern void lcd_init(void);

extern void lcd_putch(char);


/*	Set the cursor position */

//#define	lcd_cursor(x)	lcd_write(((x)&0x7F)|0x80)

[Mizzarrogh]

Intressant projekt, jag är dock fortfarande nyfiken på era (ni som har mer kunskaper) lösningar kring Tomas ide om att få ut mätdata direkt från kuggar och liknande.
Sitter någonting liknande på en del lantbruksmaskiner här.

Om man tex ville ha ut multipla mätpunkter från olika delar av apparaten i fråga (med olika varvtal då), vad säger ni om Tomas ide (eller andra förslag)?

Jag har också med sinspiration fråpn ett annat forum klurat en del över en optisk räknar enhet av en IR diod och en receptor av lämpligt slag (tex basserat på delar av gamla TV fjärrkontroller eller liknande, sedan låta ljuset reflekteras mot en blank yta (med fält indelning), tex en glanspolerad mutter, etc Sedan en förstärkar enhet osv)

*allmänt nyfiken*

Gillar annars iden på bilden också.

[Icecap]

Hur man får pulserna är ganska likgiltigt så länge de representerar hastigheten. Jag är dock själv ganska konservativ och visar bara för varje hela varv, då kan man säkra sig mot mekanisk onoggrannhet på ett varv men är pulserna stabilt placerat är det inget problem att mäta för varje puls.

Optiska varvräknare är gammalt, ofta placerar man en bit reflextejp på axeln som ska mätas och använder sedan en reflex-optoenhet, t.ex. laser.

Man ska komma ihåg att en oftare utläsning än var 300ms är utan nytta, man hinner inte se annat än fladder då. Då kan det vara en idé att mäta minst 300ms och då räkna antal varv + totaltid och sedan räkna ut RPM efter det, då får man bäst möjlig upplösning och noggrannhet.

[Mizzarrogh]

Aha, intressant, min spontana tanke var mer att om det tex gäller en klenare axel med extremt högt varvtal (tex ombyggd turbo eller liknande) så finns ju en teoretisk risk att magneten skapar obalans samt att den behöver kunna fästas säkert osv.

(Men här kanske detta inte spelar någon roll i praktiken.)