I2C Display och Arduino

[4kTRB]

Äntligen hittade jag något, i mitt tycke, vettigt.

Using Arduino board as ISP to program ATmega328 IC without a crystal
https://medium.com/@srmq/using-arduino- ... -a-crystal

Och så det här ... https://github.com/technoblogy/atmegabr ... 52ecf76e4d

[pi314]

4kTRB:

Jag tror att det blev något fel på första länken.
Den här verkar fungera.
https://medium.com/@srmq/using-arduino- ... 67ef0fccf4

/Pi

[4kTRB]

Samma alltså!
Det där hoppas jag kommer fungera med prylen från KoC.

Nu håller jag på och läser in mig på avbrottsrutiner i C och Arduino.

Testade att ansluta en tryck-brytare till pinne 2 och får utskrift på displayen vid varje tryck.
Fungerar riktigt bra.

Kod: Markera allt

#include "Arduino.h"
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
const byte BUTTON = 2;
byte index;
volatile boolean buttonFlag;

/*
 * ISR
 */
void switchPressed(){
	if(digitalRead(BUTTON) == HIGH){
		buttonFlag = true;
	}
	else {
		buttonFlag = false;
	}
}


void setup()
{
	Serial.begin(9600);
	Serial.println("Program Start");
	digitalWrite(BUTTON,HIGH);
	attachInterrupt(digitalPinToInterrupt(BUTTON), switchPressed, CHANGE);
	lcd.init();
	lcd.backlight();
	lcd.clear();
	buttonFlag = false;
	index = 0;
}


void loop()
{
	if(buttonFlag)
		i2cLCD();
}

void i2cLCD(){
	index++;
	if(index <= 8){
		lcd.print(index);
		lcd.print("_");
		if(index == 8){
			lcd.setCursor(0, 1);			// Byt till rad 2
		}
	}
	if((index > 8) && (index <= 14)){
		lcd.print(index);
		lcd.print("_");
	}
	if(index > 14){
		lcd.clear();
		index = 0;
	}
	buttonFlag = false;
}

[4kTRB]

Testade att känna av flankerna på en signal som skiftar nivå.
Använder de 2 pinnar som kan sättas till att känna av Rising, Falling och Change genom att koppla de till samma signal.
Det fungerar verkligen om man gör rätt och deklarerar pinMode som INPUT för de 2 pinnarna.
Först sker Falling- eller Rise-interruptet och när sedan ISR-rutinen väl kör igång så har signalen antingen hunnit att bli Hög eller Låg.

InterruptPulse.jpg

Kod: Markera allt

#include "Arduino.h"
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
const byte ISR_RISING_PIN = 2;
const byte ISR_FALLING_PIN = 3;
byte index;
volatile boolean isrRisingFlag;
volatile boolean isrFallingFlag;


void i2cLCD(int);


/*
 * ISR
 */
void switchPressed(){
	if(digitalRead(ISR_FALLING_PIN) == LOW){
		isrFallingFlag = true;
	}
	if(digitalRead(ISR_RISING_PIN) == HIGH){
		isrRisingFlag = true;
	}
}


void setup()
{
	lcd.init();
	lcd.backlight();
	pinMode(ISR_RISING_PIN,INPUT);
	pinMode(ISR_FALLING_PIN,INPUT);
	attachInterrupt(digitalPinToInterrupt(ISR_RISING_PIN), switchPressed, RISING);		// pinne 2 reagerar på LOW -> HIGH
	attachInterrupt(digitalPinToInterrupt(ISR_FALLING_PIN), switchPressed, FALLING);	// pinne 3 reagerar på HIGH -> LOW
	isrRisingFlag = false;
	isrFallingFlag = false;
	index = 0;
	Serial.begin(9600);
	Serial.println("Program Start");
}


void loop()
{
	if(isrRisingFlag)																	// pinne 2 har detekterat en LOW -> HIGH
		i2cLCD(1);
	if(isrFallingFlag)																	// pinne 3 har detekterat en HIGH -> LOW
		i2cLCD(0);
}
/*
 * Skriv ut på LCD om det var en "Rising-Edge detected" (skriver en 1:a)
 * eller om det var en "Falling-Edge detected" (skriver en 0:a)
 * Pinne D2 känner av stigande flanker och pinne D3 känner av fallande flanker
 */
void i2cLCD(int value){
	index++;
	if(index == 1)							// börja med att rensa LCD
		lcd.clear();
	if(index <= 16){						// skriv i ordning från vänster till höger på rad 1
		lcd.print(value);
		if(index >= 16){
			lcd.setCursor(0, 1);			// Byt till rad 2
		}
	}
	if((index > 16) && (index <= 32)){		// skriv i ordning från vänster till höger på rad 2
		lcd.print(value);
		if(index >= 32){
			index = 0;
		}
	}
	isrRisingFlag = false;
	isrFallingFlag = false;
}

[4kTRB]

Funderade på hur det fungerar,
så snart koden attachInterrupt exekverats i setup så antar jag att ett avbrott kan komma som triggar.
Men säg att jag vet att jag väntar på först en stigande flank, alltså det som pinne D2 väntar på,
men att det blivit något lurigt så det första som händer är att det blir en negativ flank.
Då vill jag till exempel inte att den negativa flanken ska trigga som första avbrott.
Jag vet att det går frysa avbrott men vart de skulle läggas in i koden och hur?

[4kTRB]

Det här med ISR-funktioner och vad man bör tänka på är aningen komplext.

Till exempel går det bra att spara tiden med millis() inuti ISR-rutinen men var medveten om att klockan inte uppdateras i en ISR-funktion.
Även i den korta ISR-funktionen i mitt senaste program ger det skillnad på en runt 134 ms puls beroende på var i ISR-funktionen millis() placeras.
Jag testade och fick i snitt snabbare pulstid eller aningen lånsammare pulstid beroende på var i if-satserna milli() placeras.
Placerar jag som nu millis() i huvud-loopen fås i snitt något mittemellan snabbast och långsammast, mer åt det snabbare hållet.
I övrigt verkar det fungera bra. Använder en logikpulsare som jag haft som projekt för längesedan.

Kod: Markera allt

#include "Arduino.h"
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
const byte ISR_RISING_PIN = 2;
const byte ISR_FALLING_PIN = 3;
byte index;
volatile boolean isrRisingFlag;
volatile boolean isrFallingFlag;
volatile unsigned long timeA;
volatile unsigned long timeB;
unsigned long timeDiff;
volatile boolean time_RE_Flag;
volatile boolean time_FE_Flag;


void i2cLCD(int);


/*
 * ISR
 */
void switchPressed(){
	if(digitalRead(ISR_RISING_PIN) == HIGH){
		isrRisingFlag = true;
	}
	if(digitalRead(ISR_FALLING_PIN) == LOW){
		isrFallingFlag = true;
	}
}


void setup()
{
	timeA = 0;
	timeB = 0;
	timeDiff = 0;
	time_RE_Flag = false;
	time_FE_Flag = false;
	isrRisingFlag = false;
	isrFallingFlag = false;
	index = 0;
	Serial.begin(9600);
	Serial.println("Program Start");
	lcd.init();
	lcd.backlight();
	pinMode(ISR_RISING_PIN,INPUT);
	pinMode(ISR_FALLING_PIN,INPUT);
	attachInterrupt(digitalPinToInterrupt(ISR_RISING_PIN), switchPressed, RISING);		// pinne 2 reagerar på LOW -> HIGH
	attachInterrupt(digitalPinToInterrupt(ISR_FALLING_PIN), switchPressed, FALLING);	// pinne 3 reagerar på HIGH -> LOW
}


void loop()
{
	if(isrRisingFlag){																	// pinne 2 har detekterat en LOW -> HIGH
		timeA = millis();																// starttid
		i2cLCD(1);																		// skriv en 1:a på LCD
		time_RE_Flag = true;
		Serial.print("Rising Edge Detected    ");
	}

	if(isrFallingFlag){																	// pinne 3 har detekterat en HIGH -> LOW
		timeB = millis();																// sluttid
		i2cLCD(0);																		// skriv en 0:a på LCD
		time_FE_Flag = true;
		Serial.print("Falling Edge Detected   ");
	}

	if(time_RE_Flag && time_FE_Flag){													// Beräkna pulstid
		timeDiff = timeB - timeA;
		Serial.print("Time = ");
		Serial.print(timeDiff);
		Serial.println(" ms");
		Serial.println();
		timeDiff = 0;
		timeA = 0;
		timeB = 0;
		time_RE_Flag = false;
		time_FE_Flag = false;
	}
}
/*
 * Skriv ut på LCD om det var en "Rising-Edge detected" (skriver en 1:a)
 * eller om det var en "Falling-Edge detected" (skriver en 0:a)
 * Pinne D2 känner av stigande flanker och pinne D3 känner av fallande flanker
 */
void i2cLCD(int value){

	index++;
	if(index == 1)							// börja med att rensa LCD
		lcd.clear();
	if(index <= 16){						// skriv i ordning från vänster till höger på rad 1
		lcd.print(value);
		if(index >= 16){
			lcd.setCursor(0, 1);			// Byt till rad 2
		}
	}
	if((index > 16) && (index <= 32)){		// skriv i ordning från vänster till höger på rad 2
		lcd.print(value);
		if(index >= 32){
			index = 0;
		}
	}
	isrRisingFlag = false;
	isrFallingFlag = false;
}

Utskrift.......

Kod: Markera allt

Program Start
Time = 135 ms

Time = 134 ms

Time = 134 ms
 
Time = 133 ms

Time = 135 ms
 
Time = 134 ms

Time = 134 ms 

Time = 133 ms
 
Time = 134 ms
 
Time = 134 ms
 
Time = 135 ms

[pfyra]

Det borde gå att först registrera en ISR för stigande flank och i den konfigurera om den till stigande och fallande flanker. Annars skulle du kunna läsa av pinnen och invänta att den blir låg innan din ISR registreras.

[4kTRB]

Det visade sig vara enkelt att få det att fungera oavsett om en fallande eller stigande flank detekteras först.
Jag bara testar vilken av millis()-värdena är störst, det avgör saken.

Avrundningen med floor() gav bra värden upp till 6 sek pulstid men sedan ökade felet.
Lade på 1000000 i täjaren och 10000 i nämnaren, hade 100000 och 1000 innan.
Millisekund-värdena behöver inte avrundas.

Ex: 1/125 är 8ms, 1/30 är 33.3ms osv.

Använder en presentation för tider snabbare än 1s och en annan för >= 1 s.
Samma man ser på kamerans tidsratt.

IMG_Shutterspeed_000.jpg

IMG_Shutterspeed_001.jpg

Kod: Markera allt

#include "Arduino.h"
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
const byte ISR_RISING_PIN = 2;
const byte ISR_FALLING_PIN = 3;
byte index;
volatile boolean isrRisingFlag;
volatile boolean isrFallingFlag;
volatile unsigned long timeA;
volatile unsigned long timeB;
unsigned long timeDiff;
volatile boolean time_RE_Flag;
volatile boolean time_FE_Flag;

void i2cLCD(int);
void i2cLCD_ShowTime(unsigned long);
void i2cLCD_ShowShutterSpeed(double);

/*
 * ISR
 */
void switchPressed(){
	if(digitalRead(ISR_RISING_PIN) == HIGH){
		isrRisingFlag = true;
	}
	if(digitalRead(ISR_FALLING_PIN) == LOW){
		isrFallingFlag = true;
	}
}

void setup()
{
	timeA = 0;
	timeB = 0;
	timeDiff = 0;
	time_RE_Flag = false;
	time_FE_Flag = false;
	isrRisingFlag = false;
	isrFallingFlag = false;
	index = 0;
	Serial.begin(9600);
	lcd.init();
	lcd.backlight();
	pinMode(ISR_RISING_PIN,INPUT);
	pinMode(ISR_FALLING_PIN,INPUT);
	attachInterrupt(digitalPinToInterrupt(ISR_RISING_PIN), switchPressed, RISING);		// pinne 2 reagerar på LOW -> HIGH
	attachInterrupt(digitalPinToInterrupt(ISR_FALLING_PIN), switchPressed, FALLING);	// pinne 3 reagerar på HIGH -> LOW
}

void loop()
{
	if(isrRisingFlag){												// pinne 2 har detekterat en LOW -> HIGH
		isrRisingFlag = false;
		timeA = millis();											// starttid
		time_RE_Flag = true;
	}
	if(isrFallingFlag){												// pinne 3 har detekterat en HIGH -> LOW
		isrFallingFlag = false;
		timeB = millis();											// sluttid
		time_FE_Flag = true;
	}
	if(time_RE_Flag && time_FE_Flag){								// Beräkna pulstid/slutartid
		if(timeB > timeA)											// sekvens LOW -> HIGH -> LOW
			timeDiff = timeB - timeA;
		else														// sekvens HIGH -> LOW -> HIGH
			timeDiff = timeA - timeB;

		double A = (double)timeDiff;
		double B = 10000000 / A;
		double C = B + 0.5;
		double D = floor(C);
		double E = D / 10000;
		double F = 1 / E;

		Serial.print("A = "); Serial.println(A,4);
		Serial.print("B = "); Serial.println(B,4);
		Serial.print("C = "); Serial.println(C,4);
		Serial.print("D = "); Serial.println(D,4);
		Serial.print("E = "); Serial.println(E,4);
		Serial.print("F = "); Serial.println(F,4);
		Serial.println();

		i2cLCD_ShowTime(timeDiff);
		i2cLCD_ShowShutterSpeed(E);
		timeDiff = 0;
		timeA = 0;
		timeB = 0;
		time_RE_Flag = false;
		time_FE_Flag = false;
	}
}

void i2cLCD_ShowTime(unsigned long time){							// 1:a raden text
	lcd.clear();
	lcd.print("New Shutterspeed");
	delay(1800);
	lcd.clear();
	lcd.print("Time = ");											// presentera slutartiden i millisekunder
	lcd.print(time);
	lcd.print(" ms");
}

void i2cLCD_ShowShutterSpeed(double speed){							// 2:a raden text på "kamerastandard"-format
	lcd.setCursor(0,1);
	if(speed > 1){
		lcd.print("Speed = 1 / ");									// slutartider < 1 sekund, typ 1/250, 1/60, 1/2
		lcd.print(speed,2);
	}
	else {
		speed = 1.00/speed;											// slutartider >= 1 sekund
		lcd.print("Speed = ");
		lcd.print(speed,1);											// skriv ut med 1 decimal, 1:a raden ger fler siffror
		lcd.print(" s");
	}
}

/*
 * Skriv ut på LCD om det var en "Rising-Edge detected" (skriver en 1:a)
 * eller om det var en "Falling-Edge detected" (skriver en 0:a)
 * Pinne D2 känner av stigande flanker och pinne D3 känner av fallande flanker
 */
void i2cLCD(int value){
	index++;
	if(index == 1)							// börja med att rensa LCD
		lcd.clear();
	if(index <= 16){						// skriv i ordning från vänster till höger på rad 1
		lcd.print(value);
		if(index >= 16){
			lcd.setCursor(0, 1);			// Byt till rad 2
		}
	}
	if((index > 16) && (index <= 32)){		// skriv i ordning från vänster till höger på rad 2
		lcd.print(value);
		if(index >= 32){
			index = 0;
		}
	}
	isrRisingFlag = false;
	isrFallingFlag = false;
}

[4kTRB]

Labbade med C och kom fram till en välfungerande funktion för att avrunda till valbart antal decimaler.
Har inte testat på Arduino ännu.
På äkta C-vis ska koden givetvis vara så kompakt och oläsbar som kodaren klarar av.

Kod: Markera allt

/*
 ============================================================================
 Name        : Avrunda.c
 Author      : 4kTRB
 Version     :
 Copyright   : Your copyright notice
 Description : C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>

int main(void) {
	double decimal_rounding_X(double, double);

	double TAL = 2.265577854213;
	double TAL_1;
	double TAL_2;
	double TAL_3;
	double TAL_4;

	TAL_1 = decimal_rounding_X(TAL,1);
	TAL_2 = decimal_rounding_X(TAL,2);
	TAL_3 = decimal_rounding_X(TAL,3);
	TAL_4 = decimal_rounding_X(TAL,7);

	printf("TAL = ");
	printf("%.8f\n",TAL);
	printf("=======================\n\n");
	printf("1 avrundad decimal = ");
	printf("%.8f\n", TAL_1);

	printf("\n");
	printf("2 avrundade decimaler = ");
	printf("%.8f\n", TAL_2);

	printf("\n");
	printf("3 avrundade decimaler = ");
	printf("%.8f\n", TAL_3);

	printf("\n");
	printf("7 avrundade decimaler = ");
	printf("%.8f", TAL_4);

	return EXIT_SUCCESS;
}

double decimal_rounding_X(double number,double digits){
	double pow(double,double);
	double modf(double,double*);
	double heltal_A;
	double heltal_B;
	modf((modf(number,&heltal_A)*pow(10,digits) + 0.5),&heltal_B);
	return (heltal_A + (heltal_B/pow(10,digits)));
}

Utskrift....

Kod: Markera allt

TAL = 2.26557785
=======================

1 avrundad decimal = 2.30000000

2 avrundade decimaler = 2.27000000

3 avrundade decimaler = 2.26600000

7 avrundade decimaler = 2.26557790

[4kTRB]

Avrundningsformeln fungerar hyggligt bra även på Arduino.
Har inte testat den för mer decimaler än vad som behövs för applikationen.

Nu ser koden ganska bra ut. Ska försöka införskaffa en ATmega328P och cadda ett pcb med 16MHz kristall
och pinnar för programmering plus de pinnar som behövs till LCD och D2-, D3-pinnarna.

Sedan skummade jag igenom en beskrivning hur man kan få Arduino att skriva data till Excel.
Annars så är det så sällan jag kommer testa slutartider att det går bra att anteckna en serie mätningar på papper för att sedan beräkna något slags medelvärde.

Kod: Markera allt

#include "Arduino.h"
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
const byte ISR_RISING_PIN = 2;
const byte ISR_FALLING_PIN = 3;
byte index;
volatile boolean isrRisingFlag;
volatile boolean isrFallingFlag;
volatile unsigned long timeA;
volatile unsigned long timeB;
unsigned long timeDiff;
volatile boolean time_RE_Flag;
volatile boolean time_FE_Flag;

void switchPressed();							// ISR
double decimal_rounding_X(double ,double);
void i2cLCD_ShowTime(unsigned long);
void i2cLCD_ShowShutterSpeed(double);

void setup() {
	timeA = 0;
	timeB = 0;
	timeDiff = 0;
	time_RE_Flag = false;
	time_FE_Flag = false;
	isrRisingFlag = false;
	isrFallingFlag = false;
	index = 0;
	Serial.begin(9600);
	lcd.init();
	lcd.backlight();
	pinMode(ISR_RISING_PIN,INPUT);
	pinMode(ISR_FALLING_PIN,INPUT);
	attachInterrupt(digitalPinToInterrupt(ISR_RISING_PIN), switchPressed, RISING);		// pinne 2 reagerar på LOW -> HIGH
	attachInterrupt(digitalPinToInterrupt(ISR_FALLING_PIN), switchPressed, FALLING);	// pinne 3 reagerar på HIGH -> LOW
}

void loop()
{
	if(isrRisingFlag){												// pinne 2 har detekterat en LOW -> HIGH
		isrRisingFlag = false;
		timeA = millis();											// starttid
		time_RE_Flag = true;
	}
	if(isrFallingFlag){												// pinne 3 har detekterat en HIGH -> LOW
		isrFallingFlag = false;
		timeB = millis();											// sluttid
		time_FE_Flag = true;
	}
	if(time_RE_Flag && time_FE_Flag){									// Beräkna pulstid/slutartid
		if(timeB > timeA)											// sekvens LOW -> HIGH -> LOW
			timeDiff = timeB - timeA;
		else														// sekvens HIGH -> LOW -> HIGH
			timeDiff = timeA - timeB;

		i2cLCD_ShowTime(timeDiff);
		i2cLCD_ShowShutterSpeed((double)timeDiff/1000);
		timeDiff = 0;
		timeA = 0;
		timeB = 0;
		time_RE_Flag = false;
		time_FE_Flag = false;

	}
}

/*
 * ISR
 */
void switchPressed(){
	if(digitalRead(ISR_RISING_PIN) == HIGH){
		isrRisingFlag = true;
	}
	if(digitalRead(ISR_FALLING_PIN) == LOW){
		isrFallingFlag = true;
	}
}

/*
 * Avrunda ett tal med valt antal decimaler (digits)
 */
double decimal_rounding_X(double number,double digits){
	double pow(double,double);
	double modf(double,double*);
	double heltal_A;
	double heltal_B;
	modf((modf(number,&heltal_A)*pow(10,digits) + 0.5),&heltal_B);
	return (heltal_A + (heltal_B/pow(10,digits)));
}

/*
 * Presentera uppmätt tid i millisekunder på LCD:ns första rad
 *
 * Indata: time angett i millisekunder
 */
void i2cLCD_ShowTime(unsigned long time){
	lcd.print("New Shutterspeed");
	delay(500);
	lcd.clear();
	lcd.print("Time  = ");											// presentera slutartiden i millisekunder
	lcd.print(time);
	lcd.print(" ms");
}

/*
 * Presentera uppmätt tid i sekunder eller på formatet delar av en sekund
 * (1/8, 1/60...osv) på LCD:ns andra rad
 *
 * Indata: speed, angett i sekunder  (ex. 0.467 sekunder)
 */
void i2cLCD_ShowShutterSpeed(double speed){							// text på "kamerastandard"-format
	lcd.setCursor(0,1);
	if(speed < 1){												// slutartider < 1 sekund
		speed = decimal_rounding_X(1/speed,1);
		lcd.print("Speed = 1 / ");									// slutartider < 1 sekund, typ 1/250, 1/60, 1/2
		lcd.print(speed,1);
	}
	else {													// slutartider >= 1 sekund
		speed = decimal_rounding_X(speed,1);						// avrunda
		lcd.print("Speed = ");
		lcd.print(speed,1);										// skriv ut med 1 decimal
		lcd.print(" s");
	}
}

[4kTRB]

Något sånt här hoppas jag på ska kunna fås att fungera.
Något jag förbisett ?

EAGLE_Sch_000.jpg

[Wihelm]

avkoppling 100nF på Vcc och AVcc. Samt 10uH mellan Vcc och AVcc om du skall köra ADC.

pullup på SDA och SCL.
min är 2.2k så det går ju att ändra lätt om det behövs.

behövs pullup på TX och RX?

LED på SCK? Kan bli problem med att programmeraren inte orkar driva SCK pinnen korrekt.
Använder aldrig dessa pinnar än till ISP behöver jag det så har jag bygel att kunna koppla bort vid programmering.

[4kTRB]

Version 2 av Arduino använder filterspole till AVCC om jag uppfattat det rätt.
Jag ska inte använda A/D-omvandlarna.
Old https://www.arduino.cc/en/uploads/Main/ ... ematic.png
New https://easyeda.com/editor#id=ee5dabcfc ... 2d3adbac4d , någon ytmonterad variant.

På nya versionen är lysdioder kopplade till RX och TX via 1k motstånd från 5V, så det blir ju en slags pull-up.
Inga pull-up någonstans på övriga serie-pinnar vad jag kan se.
Så de åker bort.

En 1000k över kristallen och 47uF +2x100nF på VCC + 100nF direkt vid ingångarna VCC och AVCC.

Kanske specen på den spänningsregulatorn är vassare än en 7805 ?

[4kTRB]

Så här kanske blir bra ?

EAGLE_Sch_001.jpg

[Wihelm]

Om du skall använda I2C så behöver de pullup på SDA, SCL

100nF på AVcc inte aref. Aref kan du lämna öppen.