RGB Matrix mit I2C

[Pascal C. (pascal01)]

Hallo Former,

ich habe mir ein kleines Projekt aufgesetzt und möchte eine RGB LED über 
I2C  Bus und Sensor(is471) ansteuern. Alles ist eigentlich soweit fertig 
und bereit. (Hardware). Die Software ist "eigentlich" fertig, wenn da 
nicht  ein kleines Problem wäre.

Ich sollte hier vielleicht noch sagen dass meine letzte Berührung mit 
AVR schon viele, viele Jahre zurück liegt. Es hat mich einfach wieder 
gepackt und möchte da wieder einsteigen. Also habt bitte etwas 
Nachsicht, jedoch konstruktive Kritik muss sein.

Kurz zu dem wie die LED reagieren soll.
Ich sende per I2C einen Wert, welcher die Farbe sowohl auch die 
Lichtstärke definiert.

Hierzu benutze ich ein Arduino als Master.

#include <Wire.h>

byte rgb[3] = {0,0,0};

void setup()
{
  TWBR=50000L;  // set SCL Clock to 50kHz für ATtiny2313 1MHz clock
  Wire.begin(); // join i2c bus (address optional for master) 
  Serial.begin(9600);  // start serial for output
  Serial.println("OK>");
}

void loop()
{
    // begin transmission to device 1    
    Wire.beginTransmission(5);
    // send
    rgb[0] = 0;
    rgb[1] = 0;
    rgb[2] = 110;
    Wire.write(rgb,3);
    // done
    Wire.endTransmission();  
  
    Wire.requestFrom(5,1);    // request 1 bytes from slave device #5
    while (Wire.available())  // slave may send less than requested
    {
      byte c = Wire.read();
      Serial.println(c);
    }
}

Auf dem Slave liegt nun mein Problem.
Sobald ich die Hand vom Sensor weg nehme, dimmt die LED mit Weiss aus 
und der I2C ist tot. Soweit ich diese vom Oszilloskop sehen kann. Danach 
geht nix mehr.

Wenn ich das Delay (_delay_ms(5)) in der Schleife zum Dimmen 
auskommentiere, funktioniert alles bestens, nur dimmen dann die LED eben 
nicht mehr. Gut sie dimmen schon, aber einfach zu schnell :)

Ich bin da etwas ratlos....

/**
* I2C.c
*
* Created: 19.02.2015 22:39:00
*  Author: Pascal
*
* Pin definition on ATtiny2313
*                         --------
*        (RESET/dW) PA2  1|°     |20  VCC
*             (RXD) PD0  2|      |19  PB7 (UCSK/SCL/PCINT7)
*             (TXD) PD1  3|      |18  PB6 (MISO/DO/PCINT6)
*           (XTAL2) PA1  4|      |17  PB5 (MOSI/DI/SDA/PCINT5)
*           (XTAL1) PA0  5|      |16  PB4 (OC1B/PCINT4)
*  (CKOUT/XCK/INT0) PD2  6|      |15  PB3 (OC1A/PCINT3)
*            (INT1) PD3  7|      |14  PB2 (OC0A/PCINT2)
*              (T0) PD4  8|      |13  PB1 (AIN1/PCINT1)
*         (OC0B/T1) PD5  9|      |12  PB0 (AIN0/PCINT0)
*                   GND 10|      |11  PD6 (ICP)
*                         --------
*/


#define F_CPU 1000000UL

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <usiTwiSlave.h> // Don Blake's library

// The TWI address for this slave device
const uint8_t TWI_SLAVE_ADDRESS = 0x05;

// init array for RGB
uint8_t data[3];  

#define pwm1 OCR0A
#define pwm2 OCR0B
#define pwm3 OCR1A
//#define pwm4 OCR1B

int main(void)
{
  
  // Timer 0 PWM Init (fast PWM)
  TCCR0A = (1 << WGM00)
  | (1 << WGM01)
  | (1 << COM0A1)
  | (1 << COM0B1);
  TCCR0B = (0 << WGM02) 
  | (0 << CS00)
  | (1 << CS01)
  | (0 << CS02);  
  /**
  * CS02  CS01  CS00  Description
  * ---------------------------------------------------------------
  * 0    0    0    No clock source (Timer/Counter stopped)
  * 0    0    1    clkI/O/(No prescaling)
  * 0    1    0    clkI/O/8 (From prescaler)
  * 0    1    1    clkI/O/64 (From prescaler)
  * 1    0    0    clkI/O/256 (From prescaler)
  * 1    0    1    clkI/O/1024 (From prescaler)
  * 1    1    0    External clock source on T0 pin. Clock on falling edge.
  * 1    1    1    External clock source on T0 pin. Clock on rising edge.  
  * ---------------------------------------------------------------
  */
  

  // Timer 1 PWM Init (fast PWM)
  TCCR1A = (1 << WGM10)
  | (0 << WGM11)
  | (1 << COM1A1)
  | (1 << COM1B1);
  TCCR1B = (1 << WGM12)
  | (0 << WGM13)
  | (0 << CS10)
  | (1 << CS11)
  | (0 << CS12);
  
  /**
  * CS12  CS11  CS10  Description
  * ---------------------------------------------------------------
  * 0    0    0    No clock source (Timer/Counter stopped).
  * 0    0    1    clkI/O/1 (No prescaling)
  * 0    1    0    clkI/O/8 (From prescaler)
  * 0    1    1    clkI/O/64 (From prescaler)
  * 1    0    0    clkI/O/256 (From prescaler)
  * 1    0    1    clkI/O/1024 (From prescaler)
  * 1    1    0    External clock source on T1 pin. Clock on falling edge.
  * 1    1    1    External clock source on T1 pin. Clock on rising edge.
  * ---------------------------------------------------------------
  */
  
  
  
  /**
   * OC0A on pin 14 (PB2)
   * OC1A on pin 15 (PB3)
   * OC0B on pin  9 (PD5)
   * OC1B on pin 16 (PB4)
   */
  DDRB |= (1 << PB2);   // PWM output on PB2 - OC0A
  DDRB |= (1 << PB3);   // PWM output on PB3 - OC1A
  DDRD |= (1 << PD5);   // PWM output on PD5 - OC0B
  //DDRB |= (1 << PB4);   // PWM output on PB4 - OC1B
  
  OCR0A = 0;
  OCR0B = 0;
  OCR1A = 0;
//  OCR1B = 0;

  // set port to input (for Sensor)
  DDRB &= ~(1 << PINB0); // data direction register set as input PINB1
  PORTB |= 1 << PINB0; // set PINB1 to a "high" reading

  // Initialise the I2C interface
  usiTwiSlaveInit(TWI_SLAVE_ADDRESS);

  // Start interrupts
  sei();
  
  // set variable for sensor status
  bool sensor_is_clear = false;


  /**
   * pwm1 = R
   * pwm2 = G
   * pwm3 = B
   */
  while (1)
  {
    // check sensor input
    if(bit_is_clear(PINB, 0))
    {
      sensor_is_clear = true;
      // set color white
      pwm1 = 255;
      pwm2 = 255;
      pwm3 = 255;

      // send value 1 to master if sensor is covered
      usiTwiTransmitByte(1);
    }
    else
    {
      if( sensor_is_clear )
      {
        // if sensor is free fade out white color
        for (int i=255; i>0; i--)
        {
          pwm1 = i; // R
          pwm2 = i; // G
          pwm3 = i; // B
          //_delay_ms(5);
        }
        sensor_is_clear = false;
      }
      else
      {
        // check if data is in the i2c receive buffer
        if(usiTwiDataInReceiveBuffer())
        {
          // get some bytes
          for (int i=0; i<3; i++)
          {
            data[i] = usiTwiReceiveByte();
          }

          pwm1 = data[0];  // R
          pwm2 = data[1];  // G
          pwm3 = data[2];  // B
        }
        
        // send 0 if sensor is clear
        usiTwiTransmitByte(0);        
      }
    }
  }
}

Besten Dank für einen Eat, denn ich weiss hier nicht mehr weiter.

Gruss
Pascal

[Frank L. (frank_l)]

Hallo Pascal,

statt einem delay, solltest Du das Dimmen in einen eigenen Timer 
verlagern. Das Delay sperrt alles!

Eventuell auch die Sende und Empfangsroutine auf Interrupt gesteuert 
umstellen, dann wird auch alles andere klappen.

Gruß
Frank

[Pascal C. (pascal01)]

Hallo Frank,

danke für deine Info.
Dass mit den Timern habe ich noch nicht so im Griff. Der tiny2313 hat 
zwei Timers welche ich für die PWM der LED brauche. Da habe ich doch 
keinen Timer mehr frei, oder? Da muss ich mich wohl noch tiefer in die 
Materie graben.

Mit Interrupts habe ich bis jetzt noch nichts gemacht.
Naja, eines nach dem andren....

Gruss
Pascal

[J. T. (chaoskind)]

Mit einem Timer kannst du mehrere PWMs erzeugen. Erstens haben die Timer 
teilweise 2 outpout compare register. Du kannst aber auch einfach einen 
Timer laufen lassen und im Interrupt die Differenz zum nächsten 
"PWM-Umschalten" ins OCR laden. Ich versuch mal nen Beitrag rauszusuchen 
da hatte ich ein ähnliches Problem. Wenn ich ihn finde, meld ich mich 
nochmal.

MfG Chaos

[Pascal C. (pascal01)]

Danke Chaos das wäre sehr hilfreich, da ich mich in diesem Bereich noch 
gar nicht gut auskenne. Ich werde mich in den nächsten Tagen Mal über 
das ganze Datenblatt des 2313 hermachen. Werde dann sehen was ich alles 
verstanden habe und was nicht :)
...

[J. T. (chaoskind)]

Beitrag "Musikalisches Diskettenlaufwerk"

da musste dich mal durchwühlen. Es geht zwar um das parallele Erzeugen 
von mehreren Frequenzen, aber das sollte sich auch auf PWM adaptieren 
lassen.

Edit: Irgendwo in der 2ten Hälfte gehts zum entscheidenden Teil

[Pascal C. (pascal01)]

kurze Zwischenfrage,

ich bin gerade am umbauen des codes auf Interrupt Steuerung.
Bei INT0 und INT1 kann ich das Register MCUCR benutzen um auf eine 
poitive oder negative Flanke zu triggern. Das gleiche möchte ich nun 
auch auf PCINT0 machen. Ich habe da aber kein Eintrag gefunden.

Kann ich dass überhaupt?

Ich habe das mit INT0 auf PD2 gemacht was auch funktioniert hat. Jedoch 
ist dies ja nur ein Interrupt und ich möchte anschliessend mit 
bit_is_clear prüfen ob der Sensor immer noch ein Signal liefert wenn die 
Hand drauf ist.

vielen Dank für eure bisherigen Hilfestellung.

[Falk B. (falk)]

@ Pascal Clément (pascal01)

>Kann ich dass überhaupt?

Nein. Der Interrupt reagiert auf jede Flanke. Welche dann real 
vorliegt, muss man durch Auslesen den PINx Registers rausfinden.

[Pascal C. (pascal01)]

habe es gerade bemerkt. Ich habe es nun doch mit INT0 gelöst.

Jetzt muss ich nur noch den TWI Teil wieder einbauen....

[Pascal C. (pascal01)]

...nun ist die Software grundsätzlich Fertig. Es fehlt mir eigentlich 
nur noch einen kleinen Teil wo ich dem Master mitteile dass der Sensor 
bedeckt ist.

Es ist vielleicht noch etwas viel Beschreibung im Code, jedoch ist diese 
für mich noch recht hilfreich um mich zurecht zu finden.

Wie gesagt, möchte ich dem Master mitteilen dass der Sensor bedeckt ist.
Dies mit "usiTwiTransmitByte(1);" funktioniert grundsätzlich. Da aber 
der Interrrupt durch bedecken das Sensors ausgelöst wird, wird auch die 
Kommunikation unterbrochen. Dies kann ich an meinem Oszilloskop sehen.

Wie kann ich also Daten senden bevor die Kommunikation unterbrochen 
wird? Oder ist die ISR Routine falsch?

Der Rest funktioniert soweit eigentlich recht gut. Zurzeit sind auch 
gerade alle OCRnx definiert obwohl ich nur drei brauche. Ist aber für 
mich im Moment nicht so wichtig.

Hier Mal was ich habe.

/**
 * I2C.c
 *
 * Created: 19.02.2015 22:39:00
 * Author: Pascal
 *
 * Pin definition on ATtiny2313
 *                         --------
 *        (RESET/dW) PA2  1|°     |20  VCC
 *             (RXD) PD0  2|      |19  PB7 (UCSK/SCL/PCINT7)
 *             (TXD) PD1  3|      |18  PB6 (MISO/DO/PCINT6)
 *           (XTAL2) PA1  4|      |17  PB5 (MOSI/DI/SDA/PCINT5)
 *           (XTAL1) PA0  5|      |16  PB4 (OC1B/PCINT4)
 *  (CKOUT/XCK/INT0) PD2  6|      |15  PB3 (OC1A/PCINT3)
 *            (INT1) PD3  7|      |14  PB2 (OC0A/PCINT2)
 *              (T0) PD4  8|      |13  PB1 (AIN1/PCINT1)
 *         (OC0B/T1) PD5  9|      |12  PB0 (AIN0/PCINT0)
 *                   GND 10|      |11  PD6 (ICP)
 *                         --------
 */

#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <usiTwiSlave.h> // Don Blake's library

/**
 * The TWI address for this slave device
 */
const uint8_t TWI_SLAVE_ADDRESS = 0x05;

/**
 * init array for RGB
 */
uint8_t data[3];  

/**
 * define pwm[x] for Port B and D
 */
#define pwm1 OCR0A
#define pwm2 OCR0B
#define pwm3 OCR1A
#define pwm4 OCR1B

void initPWMChanels(void);
void initInterrupt0(void);
void initInputSensor(void);
void initTWISlave(void);

int main(void)
{
  initPWMChanels();
  initInterrupt0();
  initInputSensor();
  initTWISlave();

  /**
   * pwm1 = R
   * pwm2 = G
   * pwm3 = B
   */
  while (1)
  {
    // check if data is in the TWI receive buffer
    if(usiTwiDataInReceiveBuffer())
    {
      // get some bytes
      for (int i=0; i<3; i++)
      {
        data[i] = usiTwiReceiveByte();
      }

      pwm1 = data[0];  // R
      pwm2 = data[1];  // G
      pwm3 = data[2];  // B
    }

    // send 0 if sensor is clear
    usiTwiTransmitByte(0);        
  }
}


void initTWISlave()
{
  usiTwiSlaveInit(TWI_SLAVE_ADDRESS);
}

void initInputSensor()
{
  DDRD &= ~(1 << PD2);  // data direction register set as input PIND2
  PORTD |= 1 << PD2;  // set PIND2 to "high"
}

void initPWMChanels()
{
  /**
   * set outputs
   */  
  DDRB |= 1 << PB2; // OC0A
  DDRD |= 1 << PD5; // OC0B
  DDRB |= 1 << PB3; // OC1A
  DDRB |= 1 << PB4; // OC1B

  /**
  * Timer/Counter0
  * set as FAST PWM
  *
  * Bit    Register  Value
  * -----------------------------
  * Bits 7    COM0A1      1
  * Bits 6    COM0A0
  * Bits 5    COM0B1    1
  * Bits 4    COM0B0
  * Bits 3    -
  * Bits 2    -
  * Bits 1    WGM01       1
  * Bits 0    WGM00       1
  *
  */
  TCCR0A = (1 << WGM00) 
           | (1 << WGM01)
           | (1 << COM0A1)
       | (1 << COM0B1);

  /**
  * Timer/Counter0
  * set as FAST PWM
  *
  * Bit    Register  Value
  * -----------------------------
  * Bits 7    FOC0A
  * Bits 6    FOC0B
  * Bits 5    -
  * Bits 4    -
  * Bits 3    WGM02
  * Bits 2    CS02
  * Bits 1    CS01        1
  * Bits 0    CS00        1
  *
  */
  TCCR0B = (1 << CS01);

  /**
  * Timer/Counter1
  * set as FAST PWM
  *
  * Bit    Register  Value
  * -----------------------------
  * Bits 7    COM1A1      1
  * Bits 6    COM1A0
  * Bits 5    COM1B1    1
  * Bits 4    COM1B0
  * Bits 3    -
  * Bits 2    -
  * Bits 1    WGM11       
  * Bits 0    WGM10       1
  *
  */
  TCCR1A = (1 << WGM10)
           | (1 << COM1A1)
       | (1 << COM1B1);     

  /**
  * Timer/Counter1
  * set as FAST PWM
  *
  * Bit    Register  Value
  * -----------------------------
  * Bits 7    ICNC1
  * Bits 6    ICES1
  * Bits 5    -
  * Bits 4    WGM13
  * Bits 3    WGM12    1
  * Bits 2    CS12
  * Bits 1    CS11    1
  * Bits 0    CS10
  *
  */
  TCCR1B = (1 << WGM12)
           | (1 << CS11);
}

void initInterrupt0()
{
  /**
  * Mask Register
  * Bit    Register  Value
  * -----------------------------
  * Bits 7    INT1
  * Bits 6    INT0
  * Bits 5    PCIE    1
  * Bits 4    -
  * Bits 3    -
  * Bits 2    -
  * Bits 1    -
  * Bits 0    -
  *
  */
  GIMSK  |= (1 << INT0);  // Enable PCINT0
  
  /**
  * Pin Change Mask Register
  * Bit    Register  Value
  * -----------------------------
  * Bits 7    PCINT7
  * Bits 6    PCINT6
  * Bits 5    PCINT5
  * Bits 4    PCINT4
  * Bits 3    PCINT3
  * Bits 2    PCINT2
  * Bits 1    PCINT1
  * Bits 0    PCINT0    1
  *
  */
  //PCMSK |= (1 << PCINT0);
  
  /**
  * extern INT0
  * MCU Control Register
  * Bit    Register  Value
  * -----------------------------
  * Bits 7    PUD
  * Bits 6    SM1
  * Bits 5    SE
  * Bits 4    SM0
  * Bits 3    ISC11
  * Bits 2    ISC10
  * Bits 1    ISC01    1
  * Bits 0    ISC00
  *
  */
  MCUCR = (1 << ISC01);  // Trigger INT0 on falling edge

  /**
   * Start global interrupts
   */
  sei();  
}

ISR(INT0_vect)
{
  /**
   * Meanwhile the sensor is covered , the color white is output.
   * if the sensor is free, fadeout from white color
   */
  while (1)
  {
    /**
     * check sensor input
     */
    if(bit_is_clear(PIND, 2))
    {
      pwm1 = 255;
      pwm2 = 255;
      pwm3 = 255;
      
      /**
       * send value 1 to master if sensor is covered
       */
      //usiTwiTransmitByte(1);
    }
    else
    {
      for (int i=255; i>0; i--)
      {
        pwm1 = i; // R
        pwm2 = i; // G
        pwm3 = i; // B
        _delay_ms(5);
      }
      return 1;
    }
  }
  reti();  // Exit of an interrupt handler
}