Zbernica i2c: nástroje - História úprav

Balogh: /* Nástroje */

2023-05-13T19:50:00Z

Nástroje

← Staršia verzia		Verzia z 19:50, 13. máj 2023
Riadok 46:		Riadok 46:
	=== Nástroje ===		=== Nástroje ===

			* V Linuxe (aj RPi) je nástroj i2cdetect
			* Pre Arduino existuje kniznica: https://github.com/mcauser/i2cdetect/tree/master
	* Jednoduchy scan zbernice http://playground.arduino.cc/Main/I2cScanner		* Jednoduchy scan zbernice http://playground.arduino.cc/Main/I2cScanner
	* Komplexny i2c scanner https://github.com/RobTillaart/Arduino/tree/master/sketches/MultiSpeedI2CScanner		* Komplexny i2c scanner https://github.com/RobTillaart/Arduino/tree/master/sketches/MultiSpeedI2CScanner

Balogh: /* Literatúra */

2020-03-24T07:03:55Z

Literatúra

← Staršia verzia		Verzia z 07:03, 24. marec 2020
Riadok 11:		Riadok 11:
	** http://hackaday.com/2015/06/25/embed-with-elliot-i2c-bus-scanning/		** http://hackaday.com/2015/06/25/embed-with-elliot-i2c-bus-scanning/
	** http://howtomechatronics.com/tutorials/arduino/how-i2c-communication-works-and-how-to-use-it-with-arduino/		** http://howtomechatronics.com/tutorials/arduino/how-i2c-communication-works-and-how-to-use-it-with-arduino/
			** Dobrý popis je aj tu https://www.circuitbasics.com/basics-of-the-i2c-communication-protocol/

	* Arduino TWI Library https://www.arduino.cc/en/Reference/Wire		* Arduino TWI Library https://www.arduino.cc/en/Reference/Wire

Balogh: /* Literatúra */

2020-03-15T16:28:52Z

Literatúra

← Staršia verzia		Verzia z 16:28, 15. marec 2020
Riadok 26:		Riadok 26:
	* http://www.gammon.com.au/i2c		* http://www.gammon.com.au/i2c
	* http://www.gammon.com.au/forum/?id=10896		* http://www.gammon.com.au/forum/?id=10896


			i2c

			* http://codeandlife.com/2012/05/05/logic-analysis-with-bus-pirate/
			* http://hackaday.com/2008/11/19/how-to-the-bus-pirate-universal-serial-interface/
			* http://blog.stibrany.com/?p=122
			* ftp://ftp.propeller-chip.com/PCMProp/Chapter_10/Docs/i2c/I2C_bus.pdf

	=== Datasheets ===		=== Datasheets ===

Balogh na 10:58, 5. apríl 2016

2016-04-05T10:58:22Z

← Staršia verzia		Verzia z 10:58, 5. apríl 2016
Riadok 347:		Riadok 347:

	</source>		</source>

			[[Category:I2C]]

Balogh na 10:57, 5. apríl 2016

2016-04-05T10:57:43Z

← Staršia verzia		Verzia z 10:57, 5. apríl 2016
Riadok 31:		Riadok 31:
	* [http://www.atmel.com/images/doc0180.pdf AT24C02 EEPROM memory]		* [http://www.atmel.com/images/doc0180.pdf AT24C02 EEPROM memory]
	* [http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf BlinkM Smart RGB LED]		* [http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf BlinkM Smart RGB LED]

			=== Schéma zapojenia ===

			* [[MEMS cvičenie 6]]

	=== Nástroje ===		=== Nástroje ===

Balogh na 10:56, 5. apríl 2016

2016-04-05T10:56:30Z

← Staršia verzia		Verzia z 10:56, 5. apríl 2016
Riadok 1:		Riadok 1:
			==='''Literatúra'''===

			* Official I2C Specification Version 6 http://www.nxp.com/documents/user_manual/UM10204.pdf
			* Official List of assigned NXP / Philips I2C addresses http://www.diolan.com/downloads/i2c-address-allocation-table.pdf

			* Podrobný článok na Wikipedii: https://en.wikipedia.org/wiki/I%C2%B2C
			** Pseudokod bitbang i2c https://en.wikipedia.org/wiki/I%C2%B2C#Example_of_bit-banging_the_I.C2.B2C_Master_protocol
			** https://learn.sparkfun.com/tutorials/i2c Dobry tutorial
			** Procyon SW library http://www.procyonengineering.com/embedded/avr/avrlib/docs/html/i2csw_8c-source.html
			** Bitbanging by hand http://hackaday.com/2013/08/11/bitbanging-i2c-by-hand/
			** http://hackaday.com/2015/06/25/embed-with-elliot-i2c-bus-scanning/
			** http://howtomechatronics.com/tutorials/arduino/how-i2c-communication-works-and-how-to-use-it-with-arduino/


			* Arduino TWI Library https://www.arduino.cc/en/Reference/Wire
			* http://playground.arduino.cc/Main/WireLibraryDetailedReference


			* http://fritzing.org/projects/readwrite-serial-eeprom-via-i2c - DO PPT
			* https://learn.sparkfun.com/tutorials/i2c - DO PPT


			* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/CD00001163.pdf M24C02 Datasheet]
			* Mitchell Kahn: ''[http://ap.urpi.fei.stuba.sk/mmp/doc/prog_i2c.pdf Programming the i2c interface].'' Dr. Dobb's Journal, June 1992.
			* http://dsscircuits.com/articles/86-articles/47-effects-of-varying-i2c-pull-up-resistors
			* http://www.gammon.com.au/i2c
			* http://www.gammon.com.au/forum/?id=10896

			=== Datasheets ===

			* [http://www.atmel.com/images/doc0180.pdf AT24C02 EEPROM memory]
			* [http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf BlinkM Smart RGB LED]

			=== Nástroje ===

			* Jednoduchy scan zbernice http://playground.arduino.cc/Main/I2cScanner
			* Komplexny i2c scanner https://github.com/RobTillaart/Arduino/tree/master/sketches/MultiSpeedI2CScanner

			Najlepsie je pouzit nasledovny multi-speed skener:

	<source lang="cpp">		<source lang="cpp">
	//		//

Balogh: Vytvorená stránka „ // // FILE: MultiSpeedI2CScanner.ino // AUTHOR: Rob Tillaart // VERSION: 0.1.06 // PURPOSE: I2C scanner @different speeds // DATE: 2013-11-05 ...“

2016-04-05T10:54:34Z

Vytvorená stránka „<source lang="cpp"> // // FILE: MultiSpeedI2CScanner.ino // AUTHOR: Rob Tillaart // VERSION: 0.1.06 // PURPOSE: I2C scanner @different speeds // DATE: 2013-11-05 ...“

Nová stránka

<source lang="cpp">
//
// FILE: MultiSpeedI2CScanner.ino
// AUTHOR: Rob Tillaart
// VERSION: 0.1.06
// PURPOSE: I2C scanner @different speeds
// DATE: 2013-11-05
// URL: http://forum.arduino.cc/index.php?topic=197360
//
// Released to the public domain
//

#include <Wire.h>
#include <Arduino.h>

const char version[] = "0.1.06";

// scans devices from 50 to 800KHz I2C speeds.
// lower than 50 is not possible
// DS3231 RTC works on 800 KHz. TWBR = 2; (?)
const long allSpeed[] = {
50, 100, 200, 250, 400, 500, 800
};
long speed[sizeof(allSpeed) / sizeof(allSpeed[0])];
int speeds;

int addressStart = 0;
int addressEnd = 127;

// DELAY BETWEEN TESTS
#define RESTORE_LATENCY 5 // for delay between tests of found devices.
bool delayFlag = false;

// MINIMIZE OUTPUT
bool printAll = true;
bool header = true;

// STATE MACHINE
enum states {
STOP, ONCE, CONT, HELP
};
states state = STOP;

uint32_t startScan;
uint32_t stopScan;

void setup()
{
Serial.begin(115200);
Wire.begin();
setSpeed('0');
displayHelp();
}

void loop()
{
char command = getCommand();
switch (command)
{
case 's':
state = ONCE;
break;
case 'c':
state = CONT;
break;
case 'd':
delayFlag = !delayFlag;
Serial.print(F("<delay="));
Serial.println(delayFlag ? F("5>") : F("0>"));
break;

case 'e':
// eeprom test TODO
break;

case 'h':
header = !header;
Serial.print(F("<header="));
Serial.println(header ? F("yes>") : F("no>"));
break;
case 'p':
printAll = !printAll;
Serial.print(F("<print="));
Serial.println(printAll ? F("all>") : F("found>"));
break;

case '0':
case '1':
case '2':
case '4':
case '8':
setSpeed(command);
break;

case 'a':
setAddress();
break;

case 'q':
case '?':
state = HELP;
break;
default:
break;
}

switch (state)
{
case ONCE:
I2Cscan();
state = HELP;
break;
case CONT:
I2Cscan();
delay(1000);
break;
case HELP:
displayHelp();
state = STOP;
break;
case STOP:
break;
default: // ignore all non commands
break;
}
}

void setAddress()
{
if (addressStart == 0)
{
addressStart = 8;
addressEnd = 120;
}
else
{
addressStart = 0;
addressEnd = 127;
}
Serial.print(F("<address Range = "));
Serial.print(addressStart);
Serial.print(F(".."));
Serial.print(addressEnd);
Serial.println(F(">"));

}

void setSpeed(char sp)
{
switch (sp)
{
case '1':
speed[0] = 100;
speeds = 1;
break;
case '2':
speed[0] = 200;
speeds = 1;
break;
case '4':
speed[0] = 400;
speeds = 1;
break;
case '8':
speed[0] = 800;
speeds = 1;
break;
case '0': // reset
speeds = sizeof(allSpeed) / sizeof(allSpeed[0]);
for (int i = 0; i < speeds; i++)
{
speed[i] = allSpeed[i];
}
break;
}
}

char getCommand()
{
char c = '\0';
if (Serial.available())
{
c = Serial.read();
}
return c;
}

void displayHelp()
{
Serial.print(F("\nArduino I2C Scanner - "));
Serial.println(version);
Serial.println();
Serial.println(F("Scanmode:"));
Serial.println(F("\ts = single scan"));
Serial.println(F("\tc = continuous scan - 1 second delay"));
Serial.println(F("\tq = quit continuous scan"));
Serial.println(F("\td = toggle latency delay between successful tests. 0 - 5 ms"));
Serial.println(F("Output:"));
Serial.println(F("\tp = toggle printAll - printFound."));
Serial.println(F("\th = toggle header - noHeader."));
Serial.println(F("\ta = toggle address range, 0..127 - 8..120"));
Serial.println(F("Speeds:"));
Serial.println(F("\t0 = 50 - 800 Khz"));
Serial.println(F("\t1 = 100 KHz only"));
Serial.println(F("\t2 = 200 KHz only"));
Serial.println(F("\t4 = 400 KHz only"));
Serial.println(F("\t8 = 800 KHz only"));
Serial.println(F("\n\t? = help - this page"));
Serial.println();
}

void I2Cscan()
{
startScan = millis();
uint8_t count = 0;

if (header)
{
Serial.print(F("TIME\tDEC\tHEX\t"));
for (uint8_t s = 0; s < speeds; s++)
{
Serial.print(F("\t"));
Serial.print(speed[s]);
}
Serial.println(F("\t[KHz]"));
for (uint8_t s = 0; s < speeds + 5; s++)
{
Serial.print(F("--------"));
}
Serial.println();
}

// TEST
// 0.1.04: tests only address range 8..120
// --------------------------------------------
// Address R/W Bit Description
// 0000 000 0 General call address
// 0000 000 1 START byte
// 0000 001 X CBUS address
// 0000 010 X reserved - different bus format
// 0000 011 X reserved - future purposes
// 0000 1XX X High Speed master code
// 1111 1XX X reserved - future purposes
// 1111 0XX X 10-bit slave addressing
for (uint8_t address = addressStart; address <= addressEnd; address++)
{
bool printLine = printAll;
bool found[speeds];
bool fnd = false;

for (uint8_t s = 0; s < speeds ; s++)
{
#if ARDUINO >= 158
Wire.setClock(speed[s] * 1000);
#else
TWBR = (F_CPU / (speed[s] * 1000) - 16) / 2;
#endif
Wire.beginTransmission (address);
found[s] = (Wire.endTransmission () == 0);
fnd |= found[s];
// give device 5 millis
if (fnd && delayFlag) delay(RESTORE_LATENCY);
}

if (fnd) count++;
printLine |= fnd;

if (printLine)
{
Serial.print(millis());
Serial.print(F("\t"));
Serial.print(address, DEC);
Serial.print(F("\t0x"));
if (address < 0x10) Serial.print(0, HEX);
Serial.print(address, HEX);
Serial.print(F("\t"));

for (uint8_t s = 0; s < speeds ; s++)
{
Serial.print(F("\t"));
Serial.print(found[s] ? F("V") : F("."));
}
Serial.println();
}
}

stopScan = millis();
if (header)
{
Serial.println();
Serial.print(count);
Serial.print(F(" devices found in "));
Serial.print(stopScan - startScan);
Serial.println(F(" milliseconds."));
}
}

</source>