I2C scanner not finding ATtiny using TinywireS(Rambo)

I have been trying to get this working all night, but for some reason the I2C scanner written by Nick Gammon wont detect it… (not his fault…)
Right now i am just trying to add I2C to my current code, so I have commented out anything that was not needed for the I2C scanner to pick it up…
Can anyone tell me what i have missed
Any help is greatly appreciated. :slight_smile:

I2C Lib from GitHub - rambo/TinyWire: My modifications to TinyWire Arduino libs

My code

/*
	rst	-  -	VCC	
	3	-  -	2
	4	-  -	1
	GND	-  -	0
*/
//Include libaries\\
//----------------\\
#include <util/delay.h>
#include <avr/io.h>
#include "TinyWireS.h"


#define F_CPU 8000000
#define I2C_SLAVE_ADDRESS 0x26

#ifndef TWI_RX_BUFFER_SIZE
#define TWI_RX_BUFFER_SIZE ( 16 )
#endif

//#define Interupt 1
//#define ledpin 3
//#define PWMPin 4

int fanRPS = 0; //Fans revalutions per second
char charToSend = ' ';
int fanDC = 85; //Fans duty cycle

// typedef struct{                  //Defines the structure for multiple fans and their dividers
// 	char fantype;
// 	unsigned int fandiv;
// }fanspec;
// fanspec fanspace[3]={{0,1},{1,2},{2,8}};
// char fan = 2;

//----------------------------------------------//

void setup(){
/*
	//PWM setup\\
	//---------\\
	//Control Register A for Timer/Counter-0 (Timer/Counter-0 is configured using two registers: A and B)
	//TCCR0A is 8 bits: [COM0A1:COM0A0:COM0B1:COM0B0:unused:unused:WGM01:WGM00]
	//2<<COM0A0: sets bits COM0A0 and COM0A1, which (in Fast PWM mode) clears OC0A on compare-match, and sets OC0A at BOTTOM
	//2<<COM0B0: sets bits COM0B0 and COM0B1, which (in Fast PWM mode) clears OC0B on compare-match, and sets OC0B at BOTTOM
	//3<<WGM00: sets bits WGM00 and WGM01, which (when combined with WGM02 from TCCR0B below) enables Fast PWM mode
	TCCR0A = 2<<COM0A0 | 2<<COM0B0 | 3<<WGM00;

	//Control Register B for Timer/Counter-0 (Timer/Counter-0 is configured using two registers: A and B)
	//TCCR0B is 8 bits: [FOC0A:FOC0B:unused:unused:WGM02:CS02:CS01:CS00]
	//0<<WGM02: bit WGM02 remains clear, which (when combined with WGM00 and WGM01 from TCCR0A above) enables Fast PWM mode
	//1<<CS00: sets bits CS01 (leaving CS01 and CS02 clear), which tells Timer/Counter-0 to not use a prescalar
	TCCR0B = 0<<WGM02 | 1<<CS00;

	//Control Register for Timer/Counter-1 (Timer/Counter-1 is configured with just one register: this one)
	//TCCR1 is 8 bits: [CTC1:PWM1A:COM1A1:COM1A0:CS13:CS12:CS11:CS10]
	//0<<PWM1A: bit PWM1A remains clear, which prevents Timer/Counter-1 from using pin OC1A (which is shared with OC0B)
	//0<<COM1A0: bits COM1A0 and COM1A1 remain clear, which also prevents Timer/Counter-1 from using pin OC1A (see PWM1A above)
	//1<<CS10: sets bit CS11 which tells Timer/Counter-1  to not use a prescalar
	TCCR1 = 0<<PWM1A | 0<<COM1A0 | 2<<CS10;

	//General Control Register for Timer/Counter-1 (this is for Timer/Counter-1 and is a poorly named register)
	//GTCCR is 8 bits: [TSM:PWM1B:COM1B1:COM1B0:FOC1B:FOC1A:PSR1:PSR0]
	//1<<PWM1B: sets bit PWM1B which enables the use of OC1B (since we disabled using OC1A in TCCR1)
	//2<<COM1B0: sets bit COM1B1 and leaves COM1B0 clear, which (when in PWM mode) clears OC1B on compare-match, and sets at BOTTOM	
	GTCCR = 1<<PWM1B | 2<<COM1B0;
	OCR1C = 170;
*/
	//Interupt setup\\
	//--------------\\
	// GIMSK = 1<<PCIE;		
	// PCMSK = 1<<PCINT1;	

	//Pin setup\\
	//---------\\
	// pinMode(Interupt, INPUT);
	// pinMode(ledpin, OUTPUT);
	// pinMode(PWMPin, OUTPUT);
	// digitalWrite(ledpin, LOW);

	//I2C setup\\
	//---------\\
	TinyWireS.begin(I2C_SLAVE_ADDRESS);
	// TinyWireS.onReceive(receiveEvent);
	// TinyWireS.onRequest(requestEvent);

	// if(getRPM() < 500){
	// 	fan = 1;
	// }
}

//----------------------------------------------//

void loop(){
	//digitalWrite(ledpin, LOW);
	fanRPS = fanDC * 5 / 10;
	charToSend = char(fanRPS);
	TinyWireS_stop_check();
}

//----------------------------------------------//

void requestEvent(){ 
	TinyWireS.send(charToSend);
}

void receiveEvent(uint8_t howMany){
	if(TinyWireS.available()){  
		// if(howMany < 1){
		// 	return;
		// }
		// if(howMany > TWI_RX_BUFFER_SIZE){
		// 	return;
		// }
		// howMany--;
		// if(!howMany){
		// 	return;
		// }
		// while(howMany--){ 
			fanDC = TinyWireS.receive() - '0';
		//}
	}
}

//----------------------------------------------//

// ISR(PCINT0_vect){						//This is the function that the interupt calls
// 	if(digitalRead(Interupt) == HIGH){
// 		fanRPS++;
// 	}
// }

//----------------------------------------------//

//int getRPM(){
//	int Calc = 0;
//	fanRPS = 0;										//Set fanRPS to 0 ready for calculations
//	PCMSK = 1<<PCINT1;								//Enables interrupts
//	_delay_ms(1000);								//Wait 1 second
//	PCMSK = 0<<PCINT1;								//Disable interrupts						
//	Calc = ((fanRPS * 60)/fanspace[fan].fandiv);	//Times fanRPS (which is apprioxiamately the fequency the fan is spinning at) by 60 seconds before dividing by the fan's divider
//	return Calc;
//}

This is some example code from http://letsmakerobots.com/node/39130 that works and is detected

// the 7-bit address (remember to change this when adapting this example)
#define I2C_SLAVE_ADDRESS 0x26

// Get this from https://github.com/rambo/TinyWire
#include <util/delay.h>
#include <avr/io.h>
#include <TinyWireS.h>

// The default buffer size, Can't recall the scope of defines right now
#ifndef TWI_RX_BUFFER_SIZE
#define TWI_RX_BUFFER_SIZE ( 16 )
#endif

//Character variable used to echo data back. 
char chrSendData;

//Variables used in getting and parsing data.
char rxChrData; //Receives the data.
char rxString[12];  //Varbiable for holding one string of data.
int rxIndex = 0; //Used to index rxString.

//Integer for holding the pwm value received from master.
int pwmValA;

void requestEvent(){  
  TinyWireS.send(chrSendData);
}

//Handles receiving i2c data.
void receiveEvent(uint8_t howMany)
{
    if (TinyWireS.available()){  
      if (howMany < 1)
      {   // Sanity-check
          return;
      }
      if (howMany > TWI_RX_BUFFER_SIZE)
      {   // Also insane number
          return;
      }
  
      howMany--;
      if (!howMany)
      {   // This write was only to set the buffer for next read
          return;
      }
      while(howMany--)
      {   //Gets i2c data. 
          rxChrData = TinyWireS.receive();
          //Places the characters in an array one at a time.
          rxString[rxIndex] = char(rxChrData);
          //Increment the data array.
          rxIndex++;
          //If a stop character is read, parse the char array and convert it to a single integer.  
          if (rxChrData == ':'){
              //This is a low memory form of parsing the char array into an intger
              pwmValA = int(100*rxString[2]+10*rxString[3]+rxString[4]);
              //Prints the parsed value.
              Serial.println(pwmValA);
              //Writes the parsed value to pin 1 (PB1).
              digitalWrite(3, HIGH);
              //Resets the char array index.
              rxIndex = 0;  
         }
      }
    }
}

void setup()
{
    Serial.begin(9600);
    pinMode(1, OUTPUT); // OC1A, also The only HW-PWM -pin supported by the tiny core analogWrite
    TinyWireS.begin(I2C_SLAVE_ADDRESS);
    //Sets up the onReceive function (what we do if we get stuff).
    TinyWireS.onReceive(receiveEvent);
    //Sets up the onRequest function (what we do if asked to send something).
    TinyWireS.onRequest(requestEvent);
}

void loop()
{
//Detects a stop sending command.
TinyWireS_stop_check();

//Puts the data we got into a variable to send back for error checking.
chrSendData = char(rxChrData);

}

Any ideas?

	TCCR0A = 2<<COM0A0 | 2<<COM0B0 | 3<<WGM00;

You’re changing pin PB0 (OC0A) by timer events with this setup but that is used as SDA. Given you’re using an ATtiny25/45/85, you didn’t tell us.

But that is commented.. So it shouldn't affect it.. right?

An i am using the ATtiny85

But that is commented.. So it shouldn't affect it.. right?

Oh, excuse me, you're right, there are so many line comments I didn't notice the block comment.

I guess your problem are coming from your strange way to set comments:

    //---------\\
    TinyWireS.begin(I2C_SLAVE_ADDRESS);

The last backslash makes the newline part of the line so it adds the whole next line to the comment and TinyWireS.begin() never gets called.

Yer i worked that out last night after remove all the code and then adding segments in bit by bit. Thanks anyway