RFM12B portierte Library will auf dem Tiny nicht mehr

[Mike M. (mikeii)]

Ich habe mir vor einiger Zeit mal eine Arduino Library für das RFM12B 
Funkmodul an den Atmega 2560 angepasst, so dass ich das Arduino Gedöns 
nicht brauche.
Um sie universeller für die Zukunft zu halte, habe ich auch noch 
Bitbanging eingebaut. Die Library funktioniert einwandfrei.

Jetzt wollte ich das sie gerade mit einem Attiny2313 verwenden, aber das 
ganze macht keinen Mucks. Am Atmega2560 funktioniert ein uns das  selbe 
Funkmodul aber.

nSel ist an B4
SCK ist an B7
SDO ist an B5
SDI ist an B6
nIRQ ist an D2

Controller läuft mit 8 Mhz ohne Vorteiler.
Die Änderungen die ich vorgenommen habe, inkl. original Code habe ich 
mit dem Kommentar "//Für den Tiny geändert" versehen.

Es kommen Daten aus dem DO des Tiny raus, und ein Clock Signal kommt 
auch an. Nur kommen augenscheinlich keine Daten aus dem Funkmodul zurück 
(hab leider nur ein Oszi, weil LA kaputt).

In der Funktion void SendWait(uint8_t waitMode) hängt das ganze, weil 
kein Interrupt vom Funkmodul erzeugt wird und somit die Variable für den 
aktuellen Zustand (rxstate) nicht verändert wird.
Der Interrupt funktioniert. Es wird in den Handler gesprungen, wenn ich 
den Pin manuell auf low ziehe.


Wenn sich jemand den Code ansehen könnte, ob die Änderungen von mir alle 
so korrekt sind, das wäre nett.

Hier ist mal die c und die h Datei angehängt.



C-Datei

#include "RFM12B.h"
#include "avr/io.h"
#include "string.h"

#define F_CPU 8000000UL
#include <util/delay.h>

void SPIInit() {

  SS_DDR |= (1 << cs_pin);
  //DI
  DDRB &= ~(1 << 5);
  //DO
  DDRB = (1 << 6);
  //SCK
  DDRB |= (1 << 7);
  //Interrupt Pin has Pullup
  DDRD &= ~(1 << 2);
  PORTD |= (1 << 2);
}


uint8_t Byte(uint8_t out){

  uint8_t returnvalue = 0;
  int8_t i;
  for (i = 7;i>=0;i--){

    //Bit low or high?
    if(out & (1<<i))
      PORTB |= (1<<6);
    else
      PORTB &= ~(1<<6);

    //Clock High
    PORTB |= (1 << 7);
    _delay_us(1); 

    //Clock Low
    PORTB &= ~(1 << 7); 

    //Read input    
    if ( PINB & (1<<PINB5) ) {
      returnvalue |= (1<<i);
    }   
   _delay_us(1);
  }
  return returnvalue;
}


uint16_t XFERSlow(uint16_t cmd) {

  SS_PORT &= ~(1 << cs_pin);
  uint16_t reply = Byte(cmd >> 8) << 8;
  reply |= Byte(cmd);
  SS_PORT |= (1 << cs_pin);
  return reply;
}

void XFER(uint16_t cmd) {
  SS_PORT &= ~(1 << cs_pin);
  Byte(cmd >> 8) << 8;
  Byte(cmd);
  SS_PORT |= (1 << cs_pin);
}

void Initialize(uint8_t ID, uint8_t networkid)
{


  Data = rf12_data;
  DataLen = &rf12_buf[3];

  uint8_t txPower = 0;
  uint8_t airKbps = 0x08;
  uint8_t lowVoltageThreshold = RF12_2v75;


  cs_pin = SS_BIT;
  nodeID = ID;
  networkID = networkid;
  SPIInit();
  XFER(0x0000); // intitial SPI transfer added to avoid power-up problem
  XFER(RF_SLEEP_MODE); // DC (disable clk pin), enable lbd

  // wait until RFM12B is out of power-up reset, this takes several *seconds*
  XFER(RF_TXREG_WRITE); // in case we're still in OOK mode
  //Für den Tiny geändert: while (!(PIND & (1 << 3) ))
  while (!(PIND & (1 << 2) )) //             digitalRead(18) == 0)
    XFER(0x0000);

  XFER(0x80C7 | (RF12_868MHZ << 4)); // EL (ena TX), EF (ena RX FIFO), 12.0pF
  XFER(0xA640); // Frequency is exactly 434/868/915MHz (whatever freqBand is)
  XFER(0xC600 + airKbps);   //Air transmission baud rate: 0x08= ~38.31Kbps
  XFER(0x94A2);             // VDI,FAST,134kHz,0dBm,-91dBm
  XFER(0xC2AC);             // AL,!ml,DIG,DQD4
  if (networkID != 0) {
    XFER(0xCA83);           // FIFO8,2-SYNC,!ff,DR
    XFER(0xCE00 | networkID); // SYNC=2DXX;
  } else {
    XFER(0xCA8B); // FIFO8,1-SYNC,!ff,DR
    XFER(0xCE2D); // SYNC=2D;
  }


  XFER(0xC483); // @PWR,NO RSTRIC,!st,!fi,OE,EN
  XFER(0x9850 | (txPower > 7 ? 7 : txPower)); // !mp,90kHz,MAX OUT               //last byte=power level: 0=highest, 7=lowest
  XFER(0xCC77); // OB1,OB0, LPX,!ddy,DDIT,BW0
  XFER(0xE000); // NOT USE
  XFER(0xC800); // NOT USE
  XFER(0xC043); // Clock output (1.66MHz), Low Voltage threshold (2.55V)

  rxstate = TXIDLE;

  //Für den Tiny geändert
  //Interupt enable
  //EICRA |= (1 << ISC31);
  //EICRA &= ~(1 << ISC30);
  //EIMSK |= (1 << INT3);
  MCUCR |= (1<<ISC01);
  MCUCR &= ~(1<<ISC00);
  GIMSK |= (1<<INT0);

  sei();

}


// access to the RFM12B internal registers with interrupts disabled
uint16_t Control(uint16_t cmd) {
  //Für den Tiny geändert
  //EIMSK &= ~(1 << INT0);
  GIMSK &= ~(1<<INT0);

  uint16_t r = XFERSlow(cmd);
  
  //Für den Tiny geändert
  //EIMSK |= (1 << INT0);
  GIMSK |= (1<<INT0);
  return r;
}



void InterruptHandler() {
  XFER(0x0000);

  if (rxstate == TXRECV) {
    uint8_t in = XFERSlow(RF_RX_FIFO_READ);

    if (rxfill == 0 && networkID != 0)
      rf12_buf[rxfill++] = networkID;

    rf12_buf[rxfill++] = in;
    rf12_crc = _crc16_update(rf12_crc, in);

    if (rxfill >= rf12_len + 6 || rxfill >= RF_MAX)
      XFER(RF_IDLE_MODE);
  } else {
    uint8_t out;

    if (rxstate < 0) {
      uint8_t pos = 4 + rf12_len + rxstate++;
      out = rf12_buf[pos];
      rf12_crc = _crc16_update(rf12_crc, out);
    } else
      switch (rxstate++) {
      case TXSYN1: out = 0x2D; break;
      case TXSYN2: out = networkID; rxstate = -(3 + rf12_len); break;
      case TXCRC1: out = rf12_crc; break;
      case TXCRC2: out = rf12_crc >> 8; break;
      case TXDONE: XFER(RF_IDLE_MODE);
      default:     out = 0xAA;
      }

    XFER(RF_TXREG_WRITE + out);
  }
}

//Für den Tiny geändert:
//ISR(INT3_vect) {
ISR(INT0_vect) {

  InterruptHandler();
}


void ReceiveStart() {
  rxfill = rf12_len = 0;
  rf12_crc = ~0;
  if (networkID != 0)
    rf12_crc = _crc16_update(~0, networkID);
  rxstate = TXRECV;
  XFER(RF_RECEIVER_ON);
}

char ReceiveComplete() {
  if (rxstate == TXRECV && (rxfill >= rf12_len + 6 || rxfill >= RF_MAX)) {
    rxstate = TXIDLE;
    if (rf12_len > RF12_MAXDATA)
      rf12_crc = 1;
    if (RF12_DESTID == 0 || RF12_DESTID == nodeID) {
      if (!rf12_crc)
        rf12_seq = -1;
      return 1;
    }
  }
  if (rxstate == TXIDLE)
    ReceiveStart();
  return 0;
}

char CanSend() {

  if (rxstate == TXRECV && rxfill == 0 && (Byte(0x00) & (RF_RSSI_BIT >> 8)) == 0) {
    XFER(RF_IDLE_MODE);
    rxstate = TXIDLE;
    return 1;
  }
  return 0;
}

void SendStart(uint8_t toNodeID, char requestACK, char sendACK) {
  rf12_hdr1 = toNodeID | (sendACK ? RF12_HDR_ACKCTLMASK : 0);
  rf12_hdr2 = nodeID | (requestACK ? RF12_HDR_ACKCTLMASK : 0);
  rf12_crc = ~0;
  rf12_crc = _crc16_update(rf12_crc, networkID);
  rxstate = TXPRE1;
  XFER(RF_XMITTER_ON);
}

void SendStart2(uint8_t toNodeID, const void* sendBuf, uint8_t sendLen, char requestACK, char sendACK, uint8_t waitMode) {
  rf12_len = sendLen;
  memcpy((void*) rf12_data, sendBuf, sendLen);



  SendStart(toNodeID, requestACK, sendACK);

  SendWait(waitMode);
}


void SendACK2(const void* sendBuf, uint8_t sendLen, uint8_t waitMode) {
  while (!CanSend()) ReceiveComplete();
  SendStart2(RF12_SOURCEID, sendBuf, sendLen, 0, 1, waitMode);
}



void SendACK() {
  const void* sendBuf = "";
  uint8_t sendLen = 0;
  uint8_t waitMode = SLEEP_MODE_IDLE;
  while (!CanSend()) ReceiveComplete();
  SendStart2(RF12_SOURCEID, sendBuf, sendLen, 0, 1, waitMode);
}



void Send(uint8_t toNodeID, const void* sendBuf, uint8_t sendLen, char requestACK)
{
  uint8_t waitMode = SLEEP_MODE_STANDBY;
  while (!CanSend()) ReceiveComplete();
  SendStart2(toNodeID, sendBuf, sendLen, requestACK, 0, waitMode);
}

void SendWait(uint8_t waitMode) {
  while (rxstate != TXIDLE);
  
}

void OnOff(uint8_t value) {
  XFER(value ? RF_XMITTER_ON : RF_IDLE_MODE);
}

void Sleep2(char n) {
  if (n < 0)
    Control(RF_IDLE_MODE);
  else {
    Control(RF_WAKEUP_TIMER | 0x0500 | n);
    Control(RF_SLEEP_MODE);
    if (n > 0)
      Control(RF_WAKEUP_MODE);
  }
  rxstate = TXIDLE;
}
void Sleep() { Sleep2(0); }
void Wakeup() { Sleep2(-1); }

char LowBattery() {
  return (Control(0x0000) & RF_LBD_BIT) != 0;
}

uint8_t GetSender() {
  return RF12_SOURCEID;
}

uint8_t * GetData() { return rf12_data; }


uint8_t GetDataLen() { return *DataLen; }
char ACKRequested() { return RF12_WANTS_ACK; }

char ACKReceived(uint8_t fromNodeID) {
  if (ReceiveComplete())
    return CRCPass() &&
           RF12_DESTID == nodeID &&
           (RF12_SOURCEID == fromNodeID || fromNodeID == 0) &&
           (rf12_hdr1 & RF12_HDR_ACKCTLMASK) &&
           !(rf12_hdr2 & RF12_HDR_ACKCTLMASK);
  return 0;
}

char CRCPass() {
  return rf12_crc == 0;
}

H-Datei

#ifndef RFM12B_h
#define RFM12B_h

#include <inttypes.h>
#include <avr/io.h>
#include <util/crc16.h>
#include <avr/eeprom.h>
#include <avr/sleep.h>

#include <avr/interrupt.h>






#define RF12_MAXDATA    128
#define RF_MAX          (RF12_MAXDATA + 6)

#define RF12_315MHZ     0
#define RF12_433MHZ     1
#define RF12_868MHZ     2
#define RF12_915MHZ     3

#define RF12_2v25       0
#define RF12_2v55       3
#define RF12_2v65       4
#define RF12_2v75       5
#define RF12_3v05       8
#define RF12_3v15       9
#define RF12_3v25       10

#define RF12_HDR_IDMASK      0x7F
#define RF12_HDR_ACKCTLMASK  0x80
#define RF12_DESTID   (rf12_hdr1 & RF12_HDR_IDMASK)
#define RF12_SOURCEID (rf12_hdr2 & RF12_HDR_IDMASK)

#define RF12_WANTS_ACK ((rf12_hdr2 & RF12_HDR_ACKCTLMASK) && !(rf12_hdr1 & RF12_HDR_ACKCTLMASK))

#define RF12_SLEEP   0
#define RF12_WAKEUP -1

#define rf12_grp        rf12_buf[0]
#define rf12_hdr1        rf12_buf[1]
#define rf12_hdr2        rf12_buf[2]

#define rf12_len        rf12_buf[3]
#define rf12_data       (rf12_buf + 4)

#define bitSet_(x,y)  (x) |= ((1<<y))

#define SS_DDR      DDRB //Für den Tiny geändert: Vorher DDRD
#define SS_PORT     PORTB //Für den Tiny geändert:Vorher DDRD
#define SS_BIT      4  ////Für den Tiny geändert: Vorher 2


#define RF_RECEIVER_ON  0x82DD
#define RF_XMITTER_ON   0x823D
#define RF_IDLE_MODE    0x820D
#define RF_SLEEP_MODE   0x8205
#define RF_WAKEUP_MODE  0x8207
#define RF_TXREG_WRITE  0xB800
#define RF_RX_FIFO_READ 0xB000
#define RF_WAKEUP_TIMER 0xE000

#define RF_LBD_BIT      0x0400
#define RF_RSSI_BIT     0x0100


enum {
  TXCRC1, TXCRC2, TXTAIL, TXDONE, TXIDLE,
  TXRECV,
  TXPRE1, TXPRE2, TXPRE3, TXSYN1, TXSYN2
};

uint8_t rf12_buf[RF_MAX];
uint8_t rxfill;
volatile int8_t rxstate;
uint16_t rf12_crc;
uint32_t seqNum;
uint32_t cryptKey[4];
long rf12_seq;
uint8_t cs_pin;
uint8_t Byte(uint8_t out);
uint16_t XFERSlow(uint16_t cmd);
void XFER(uint16_t cmd);
void SPIInit(void);
uint8_t networkID;
uint8_t nodeID;
uint8_t* Data;
uint8_t* DataLen;
void InterruptHandler(void);
void Initialize(uint8_t nodeid, uint8_t groupid);
void ReceiveStart(void);
char ReceiveComplete(void);
char CanSend(void);
uint16_t Control(uint16_t cmd);
void SendStart(uint8_t toNodeId, char requestACK, char sendACK);
void SendStart2(uint8_t toNodeId, const void* sendBuf, uint8_t sendLen, char requestACK, char sendACK, uint8_t waitMode);
void SendACK2(const void* sendBuf, uint8_t sendLen, uint8_t waitMode);
void SendACK(void);
void Send(uint8_t toNodeId, const void* sendBuf, uint8_t sendLen, char requestACK);
void SendWait(uint8_t waitMode);
void OnOff(uint8_t value);
void Sleep2(char n);
void Sleep(void);
void Wakeup(void);
uint8_t * GetData(void);
uint8_t GetDataLen(void);
uint8_t GetSender(void);
char LowBattery(void);
char ACKRequested(void);
char ACKReceived(uint8_t fromNodeID);

char CRCPass(void);




#endif

und die Main

#include "RFM12B.h"
#include <stdio.h>
#define F_CPU 8000000UL
#include <util/delay.h>

#define NODEID        2  //network ID used for this unit
#define NETWORKID    99  //the network ID we are on
#define GATEWAYID     1  //the node ID we're sending to





int main(void) {


  Initialize(NODEID, NETWORKID);
  for (;;) {
   
    Send(GATEWAYID, "abc", 3, 0);
    _delay_ms(1000);
  }
  return 0;

}

[Felix P. (fixxl)]

Das Problem liegt vermutlich hier:

void SPIInit() {
  ...
  DDRB = (1 << 6);
  ...
}

Da fehlt ein |, wodurch der CS-Pin wieder zum Eingang wird.

[Mike M. (mikeii)]

Felix P. schrieb:
> Das Problem liegt vermutlich hier:
>

> void SPIInit() {
>   ...
>   DDRB = (1 << 6);
>   ...
> }
>

>
> Da fehlt ein |, wodurch der CS-Pin wieder zum Eingang wird.



JAAAAAAAAAAAAAAAAAAAAAA, das ist es!!!!!
Felix, ich sitze an dem Ding jetzt seit 10 Stunden.... denkst du das 
hätte ich gesehen? Oh mein Gott, du hast mir gerade den Tag versüßt, 
jetzt kann ich beruhigt schlafen.

Danke dir tausendfach!

[Mike M. (mikeii)]

Tja leider war das zu voreilig... Es geht leider doch nicht... Nach wie 
vor hängt es in der gleichen Funktion.

[Mike M. (mikeii)]

Hab den Fehler immer noch nicht gefunden.
Slave Select toggelt, Clock ist da und Daten auch. Modul antwortet aber 
am Tiny nicht, am Mega schon.
Gibts da irgendwelche Eigenheiten oder reagiert das Teil sensibel auf 
irgendwas?

[c-hater (Gast)]

Mike M. schrieb:

> Gibts da irgendwelche Eigenheiten oder reagiert das Teil sensibel auf
> irgendwas?

Ja, es reagiert sehr sensibel auf SPI-Zugriffe, bevor der im DB 
definierte Startup-Timeout abgelaufen ist. Und macht dann in der Folge 
oft nur noch völligen Quatsch und ist aus dieser Condition nur durch 
einen erneuten Reset zu erlösen.

Also muss man nach Reset des RFM12 (natürlich auch nach PowerOn-Reset!) 
einfach mal diese Zeit warten, bevor man versucht, per SPI mit dem Teil 
zu kommunizieren. Datenblatt lesen bildet...

Dass es beim Mega funktioniert und beim Tiny nicht, liegt mit einiger 
Wahrscheinlichkeit daran, dass du den Mega mit Quarz laufen läßt (und 
deswegen sinnvollerweise mit recht hohem Startup-Delay), den Tiny 
hingegen mit dem internen RC-Oszillator praktisch ohne Startup-Delay. 
Also: Mindestens das, was du bei der Konfiguration des Taktsystems des 
Mega als Startup-Delay per Fuse vorgegeben hast, musst du beim Tiny in 
Software warten, bevor du das erste Mal mit dem RFM12 kommunizierst bzw. 
eigentlich, bevor du überhaupt die Pins für das Software-SPI 
konfigurierst.

Und selbst dann kann es noch gelegentlich Reset-Probleme geben (wenn der 
Reset für beide ICs quasi gleichzeitig in einem "ungünstigen" Moment 
während der laufenden Kommunikation erfolgt). Dagegen hilft dann nur 
noch ein physischer PullUp am nSel-Pin des RFM12. Diese Sache kann 
übrigens genausogut auch mit einem ATMega und Hardware-SPI zum Problem 
werden...

Der eigentlich springende Punkt ist nämlich der Zeitpunkt der ersten 
H/L-Flanke an nSel nach dem Ende eines Reset des RFM12. Dafür gibt es 
einen wohldefinierten Mindestwert. Und der steht, wie schon oben gesagt, 
im Datenblatt...

[Mike M. (mikeii)]

Das mit dem nSel mit Pullup habe ich gerade getestet, hat nicht 
geholfen.
Ein Delay beim Starten hatte ich auch schon eingebaut gehabt.
Setup- und Holdtimes laut Datenblatt sollten mehr als eingehalten sein.

Ich habe mir gestern einen neuen Logic Analyser gekauft, ich werde jetzt 
wohl mal damit drauf gehen, und schauen ob damit etwas zu finden ist.

[c-hater (Gast)]

Mike M. schrieb:

> Ich habe mir gestern einen neuen Logic Analyser gekauft

OMG. Ein LA kann niemals Sachverstand und DB-Lektüre ersetzen!

Ein LA ist ein sehr praktisches Tool, um logische Fehler in der 
Kommunikation über einen "laufenden" Bus aufzuspüren, aber völlig 
ungeeignet, um Fehler bei der Businitialisierung zu entlarven.

Dazu müsste das Teil nämlich die Eigenheiten aller Busteilnehmer kennen, 
was ich gerade im Bereich SPI für einigermaßen unmöglich halten würde...

[Mike M. (mikeii)]

Was willst du mir jetzt sagen? Das der LA nicht geeignet ist um 
herauszufinden was laut Datenblatt aus meinem Controller kommen soll 
oder wie?
DB habe ich gelesen, Sachverstand vorhanden. Menschen machen Fehler, den 
suche ich, und was machst du so schönes?

[Mike M. (mikeii)]

So, Fehler gefunden:

Warum auch immer die Library auf dem Atmega geht, auf dem Tiny geht sie 
nicht.
Und zwar aus mehreren Gründen:

Der "InterruptHandler" sollte so lange laufen, wie der Pin auf Low ist, 
damit er seine Statemachine abhandeln kann. Dann wurden statt 16bit nur 
8 Bit Statusinfo überprüft....

Die zwei Sachen geändert und schon läuft es.