Hardware SPI Problem

[cler :) (Gast)]

Hi ich habe ein Problem mit meinen SPI Funktionen und weiß nicht was ich 
falsch mache, denn den Code habe ich eingentlich aus dem entsprechenden 
Datenblatt entnommen.

Es geht hierbei um den ATmega44a mit dem ich den CC1100 von TI 
ansprechen will.

Ich habe vorher noch nicht mit Hardware SPI geareitet, daher bin ich 
erstmal dabei in dem CC1100 in die Register zu schreiben und dann wieder 
auszulesen.

Hier ist mein Programm:

main.c

#include <avr/io.h>
//#include <avr/sleep.h>
#include "uart.h"
#include "cc1101.h"
#include "ioconf.h"
#include "register.h"

int main(void)
{  
  char input = 0xff;
  
  //initialization functions
  io_init();
  spi_init();
  uart_init();  
  
  cc_power(1);
  uart_puts("cc1100 eingeschaltet\n");
  cc_config();
  uart_puts("cc1100 configuriert");
  
  //program started go into while loop
  uart_puts("start\n");
  
    while(1){                
  }
  
  return 0;
}

cc1101.c:

/************************************************************************/
/* cc1101.c - functions for cc1101 and spi functions                    */
/************************************************************************/
#include "cc1101.h"
#include "ioconf.h"
#include <avr/io.h>
#include "register.h"
#include "uart.h";

/*************************************************************************
void spi_init():
  SPI configuration as master                                                                   
************************************************************************/
void spi_init(){
  SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0);
}

/************************************************************************
void spi_send(char data)
  data = address or input on the SPI bus
************************************************************************/
void spi_send(char data){    
  SPDR = data;
  uart_puts("SPDR has received data content\n");
  while(!(SPSR & (1 << SPIF)));  
  uart_puts("end of while and spi_send()\n");
}

/************************************************************************
char spi_read(char addr):
  addr = address of spi register of cc1101
  
  addr will be manipulated that the msb shows that the master is
  reading from the bus
************************************************************************/
char spi_read(char addr){
  SPDR = (addr);
  while(!(SPSR & (1 << SPIF)));
  return SPDR;
}

/************************************************************************
cc_writeRegister(char addr, char data)
  addr = register address
  data = data written to registers address  
************************************************************************/
void cc_writeRegister(char addr, char data){
  uart_puts("cc_writeRegister start\n");
  cc_select(1);
  
  spi_send(addr);
  spi_send(data);
  
  cc_select(0);
  uart_puts("cc_writeRegister end\n");
}

/************************************************************************
cc_readRegister(char addr)
  addr = address of register
************************************************************************/
char cc_readRegister(char addr){
  char data = 0xff;
  
  uart_puts("cc_readRegister start\n");
  cc_select(1);
  
  data = spi_read(addr | 0x80);
  
  cc_select(0);
  uart_puts("cc_readRegister end\n");
  
  return data;
}

/************************************************************************
void cc_config():
  configures the cc1101 with the necessary settings:
************************************************************************/
void cc_config(){
  uart_puts("write 1\n");
  cc_writeRegister(CC1100_FSCTRL1, 0x08);
  uart_puts("write 2\n");
  cc_writeRegister(CC1100_FSCTRL0, 0x00);
  uart_puts("write 3\n");
  cc_writeRegister(CC1100_FIFOTHR, 0x04);
  uart_puts("write 4\n");
  cc_writeRegister(CC1100_FREQ2, 0x21);
  uart_puts("write 5\n");
  cc_writeRegister(CC1100_FREQ1, 0x76);
  uart_puts("write 6\n");
  cc_writeRegister(CC1100_FREQ0, 0x27);      
}

Die Register (Tabelle mit CC1100 Registern) und die IO Sachen sind 
ausgiebig getestet das stimmt soweit aber wenn ich das Programm laufen 
lasse bricht er in cc_config() ab und zwar wenn ich den ersten Register 
beschreibe. Ich habe zum debuggen kommentare über die serielle 
Schnittstelle ausgeben lassen.

Abbruch bzw Endlosschleife laut aufgabe bei:

cc_config() -> cc_writeRegister() -> spi_send(data) -> dort in der While 
Schleife


Ausgabe auf dem Terminal:

cc1100 eingeschaltet
write 1
cc_writeRegister start
SPDR has received data content
end of while and spi_send()
SPDR has received data content

Sind meine SPI Funktionen richtig? Denn das auslesen Funktioniert auch 
nicht. Das habe ich auch schon getestet um die Intertialwerte 
auszulesen.
Den Programmteil habe ich aber verworfen um es simpler zu gestalten.

Wäre cool wenn ihr mir da helfen würdet.

Gruß cler

[spess53 (Gast)]

Hi

>char spi_read(char addr){
>  SPDR = (addr);
>  while(!(SPSR & (1 << SPIF)));
>  return SPDR;

Um etwas vom Slave zu lesen muss man ein Dummy-Byte senden.

MfG Spess

[cler :) (Gast)]

Danke, aber wo muss ich die denn einbauen?

cler

[cler :) (Gast)]

Aber ich sende doch die Addresse an den Chip reicht das nicht als 
Dummybyte? Beim SoftSPI kenne ich das noch so:

Adresse schicken :
   SPDR = (addr);
   while(!(SPSR & (1 << SPIF)));
dann warten und Register lesen:
   return SPDR;

Allerdings muss ich beim HardwareSPI doch nicht warten oder?

[spess53 (Gast)]

Hi

>Aber ich sende doch die Addresse an den Chip reicht das nicht als
>Dummybyte?

Dann muss dein CC1100 hellseherische Fähigkeiten haben. Ein SPI-Slave 
(dein CC1100) bekommt zu Senden und Empfangen den Takt vom Master 
(ATMega). Und ein Takt wird nur erzeugt, wenn der ATMega etwas sendet 
(und dabei gleichzeitig empfängt). So wie du es willst muss der CC1100 
schon beim ersten Bit der Adresse wissen, welche Bits er mit dem Takt 
rausschieben muss.

MfG Spess

[Karl H. (kbuchegg)]

SPI musst du dir wie das gleichzeitige Austauschen von Bytes vorstellen.

Wenn der Master etwas zum Slave sendet, überträgt gleichzeitig der Slave 
1 Byte zum Master.

So wie wenn du und dein Kumpel euch am Tisch gegenüber sitzt.
Jeder hat ein Kuvert in der Hand, in dem die Nachricht steckt.
Du schiebst mit der rechten Hand dein Kuvert über den Tisch und dein 
Kumpel macht genau dasselbe. D.h. mit der rechten Hand schiebst du dein 
Kuvert rüber und mit der linken Hand nimmst du das Kuvert, welches dein 
Kumpel dir zeitgleich rüberschickt.

So. Wenn du jetzt von deinem Kumpel etwas wissen willst, dann kann 
logischerweise die Antwort auf deine Anfrage NICHT im ersten Kuvert 
sein, welches dein Kumpel dir rüberschiebt. Denn der kann ja zu diesem 
Zeitpunk noch gar nicht wissen, was du von ihm willst.

Du musst ihm also mal deine Anfrage in einem Kuvert rüberschieben. Das 
Kuvert welches du von deinem Kumpel kriegst, enthält für dich nichts 
wesentliches. D.h. das kannst du ignorieren.

Dann sieht dein Kumpel in des gerade gekriegte Kuvert rein, besorgt die 
Information, die du angefragt hast, und schreibt sie in das Kuvert das 
er hat.
Damit du dann diese Information wieder kriegen kannst, müsst ihr nochmal 
die Kuverts tauschen.

Und erst dann hast du die Antwort auf deine Anfrage.

Stell es dir einfach bildlich vor, wie das abläuft. Dann ist es ganz 
einfach.

> Danke, aber wo muss ich die denn einbauen?
Die Frage solltest du dir jetzt eigentlich selbst beantworten können.
Die Sequenz

  ...
  SPDR = Bytewert;
  while(!(SPSR & (1 << SPIF)))
    ;
  ...

entspricht EINEM Kuverttausch.
Mit der Zuweisung stösst du ihn an, und die while-Schleife wartet 
darauf, dass der Austausch fertig vollzogen ist.
Danach kannst du durch Auslesen von SPDR in das gerade erhaltene Kuvert 
reinschauen. Du kannst, aber du musst natürlich nicht.

[Karl H. (kbuchegg)]

Mir fehlt deine

  io_init();

Hast du den SS Pin der SPI auf Ausgang gestellt?

[cler :) (Gast)]

Super Erklärung vielen Dank :)

Also ich habe dann die lesefunktion so umgeschrieben:
Von der Logik her muss ich dem Chip die Adresse mitteilen, dabei bekomme 
ich Müll dafür bietet sich die Funktion spi_send() an. Dann muss ich 
noch ein Dummybyte senden damit ich in der Antwort daraufhin die Info 
bekomme.

Aber im /**/ habe ich makiert wo mein Programm nicht mehr funktioniert. 
Ich bekomme keine Meldung über das Terminal

Was mache ich noch falsch?

Danke euch schonmal

in der main aufgerufen:

uart_puts("\nread FREQ2\n");
uart_putc(cc_readRegister(CC1100_FREQ2));

char cc_readRegister(char addr){
  char data = 0xff;
  
  uart_puts("cc_readRegister(");
  uart_putc(addr);
  uart_puts(") start\n");
  cc_select(1);
  
  spi_send(addr | 0x80);  //anfrage nach inhalt der addresse

  data = spi_read(addr);  //addresse mit dummy byte zB addr
  
  cc_select(0);
  uart_puts("cc_readRegister end\n");
  
  return data;
}

char spi_read(char addr){
  uart_puts("spi_read() start\n");
  
  SPDR = (addr);
  uart_puts("spi_send() SPDR received data content\n");

        /**/

  while(!(SPSR & (1 << SPIF)));
  uart_puts("spi_read() end returning data\n");
  return SPDR;
}

void spi_send(char data){    
  SPDR = data;
  uart_puts("spi_send() SPDR has received data content\n");
  while(!(SPSR & (1 << SPIF)));  
  uart_puts("end of while and spi_send()\n");
}

Debug Ausgabe auf dem Terminal:

cc1100 eingeschaltet<\n>
start<\n>
<\n>
read FREQ2<\n>
cc_readRegister(<\r>) start<\n>
spi_send() SPDR has received data content<\n>
end of while and spi_send()<\n>
spi_read() start<\n>
spi_send() SPDR received data content<\n>

[Karl H. (kbuchegg)]

cler :) schrieb:

> Aber im /**/ habe ich makiert wo mein Programm nicht mehr funktioniert.
> Ich bekomme keine Meldung über das Terminal
>
> Was mache ich noch falsch?

Nochmal.
Hast du den SS Pin der SPI auf Ausgang gestellt!

Das ist wichtig. Denn sonst fungiert dein µC nicht als Master. Selbst 
dann nicht wenn du es im Konfigurationsregister angefordert hast!

(OK, die Wahrheit ist ein wenig komplizierter, aber in a Nutshell kann 
man das vereinfacht so sagen: Wenn µC als Master fungieren soll, dann 
MUSS der SS Pin der SPI auf Ausgang gestellt werden. Sonst generiert der 
AVR keinen Clock und die Übertragung findet nicht statt)

[Karl H. (kbuchegg)]

Fass die beiden hier

char spi_read(char addr){
  uart_puts("spi_read() start\n");
  
  SPDR = (addr);
  uart_puts("spi_send() SPDR received data content\n");

        /**/

  while(!(SPSR & (1 << SPIF)));
  uart_puts("spi_read() end returning data\n");
  return SPDR;
}

void spi_send(char data){    
  SPDR = data;
  uart_puts("spi_send() SPDR has received data content\n");
  while(!(SPSR & (1 << SPIF)));  
  uart_puts("end of while and spi_send()\n");
}

zu einer einzigen Funktion zusammen. Du brauchst da keine 2 getrennte 
Funktionen, das verwirrt doch nur. Die machen sowieso dasselbe.

char spi_transfer(char byte)
{
  uart_puts("spi_transfer() start\n");
  
  SPDR = byte;
  uart_puts("spi_transfer() SPDR received data content\n");

  while(!(SPSR & (1 << SPIF)))
    ;
  uart_puts("spi_transfer() end returning data\n");
  return SPDR;
}

und mit der baust du dann deine
void cc_writeRegister(char addr, char data)
char cc_readRegister(char addr)
Funktionen auf.

[cler :) (Gast)]

Also ich bleibe jetzt nicht mehr in der Schleife hängen und das lag doch 
tatsächlich an einem IO Pin der falsch gesetzt war.. der ss pin muss 
beim atmega gesetzt sein, damit das ganze mit der spi funktioniert

Allerdings habe ich jetzt ein paar Register mit werten Beschrieben und 
anschließend wollte ich die wieder auslesen aber ich bekomme mit der 
Funktion spi() nur \0 zurück

char spi(char data){
  SPDR = data;
  while(!(SPSR & (1 << SPIF)));
  return SPDR;
}

was läuft da immernoch falsch?

funktion um in die Register zu schreiben:

void cc_writeRegister(char addr, char data){
  char tmp = 0xff;
  
  cc_select(1);
  
  tmp = spi(addr);
  uart_puts("tmp = ");
  uart_putc(tmp);
  uart_putc('\n');
  
  tmp = spi(data);
  uart_puts("tmp = ");
  uart_putc(tmp);
  uart_putc('\n');
  
  cc_select(0);
}

tmp ist immer \0 was ich auch nicht verwunderlich finde, aber ich dachte 
mir wenn ich die Info habe kann ich sie auch rausrücken.

cler

[Karl H. (kbuchegg)]

Na was erwartest du?
Beim schreiben von Registern wird dir der IC nichts sinnvolles 
zurückschicken. Der nimmt die Adresse, nimmt den Wert und beschreibt 
sein internes Register. Mehr wird der nicht tun.
Irgendwas muss er zurückgeben, ob er will oder nicht - weil das ja immer 
ein Bytetausch ist. Also wird der halt immer 0 zurückgeben. Ist ja 
schliesslich auch eine Information. Nämlich: 'HuHu, ich bin da!'

Anders sieht es beim Lesen aus!

[Karl H. (kbuchegg)]

cler :) schrieb:

> tmp ist immer \0 was ich auch nicht verwunderlich finde, aber ich dachte
> mir wenn ich die Info habe kann ich sie auch rausrücken.

Ja, schon.
Aber warum gibst du sie nicht als Zahlenwert aus, sondern über 
usart_putc?
Schreib dir halt ein usart_puth, welches die ein Byte als Hexzahl 
ausgibt. Ist doch keine Hexerei, sich die Hilfsunktionen zu bauen, die 
man braucht. Und gerade Zahlenausgabe braucht man immer wieder.


PS: wenn wir schon dabei sind.
Der angebrachte Datentyp für alles was im weitesten Sinne ein Byte ist, 
ist ein unsigned char, oder ein uint8_t. Aber einen char willst du da 
eigentlich nicht nehmen. Du willst an dieser Stelle es nicht dem 
Compiler überlassen, ob er ein char als mit oder ohne Vorzeichen 
ansieht.

Gewöhn dir an, dass es 3(!) Datentypen gibt

  signed char        kleine Zahlen mit Vorzeichen
  unsigned char      kleine Zahlen ohne Vorzeichen, also Bytes
  char               für alles, was mit Texten oder Textverarbeitung
                     zu tun hat.

Anstelle von signed char kannst du auch einen int8_t nehmen.
Anstelle von unsigned char kannst du auch einen uint8_t nehmen.

Aber akzeptiere, dass es einen Character in 3(!) unterschiedlichen 
Ausprägungen gibt, orientier dich an der 'Tabelle', unter welchen 
Umständen du welchen nimmst, und du hast auf lange Sicht weniger Ärger.

[cler :) (Gast)]

Danke für den Tipp werde mir das mit den 8 Bit Datentypen mal zu Herzen 
nehmen. Ich habe das so auf den 8051ern gelernt. Aber mein Problem liegt 
ja auch beim auslesen.. Das ich da immer \0 zurück bekomme.

Hier schreibe ich in die Frequenzregister:

uart_puts("write 4\n");
cc_writeRegister(CC1100_FREQ2, 0x21);
uart_puts("write 5\n");
cc_writeRegister(CC1100_FREQ1, 0x76);
uart_puts("write 6\n");
cc_writeRegister(CC1100_FREQ0, 0x27);

Hier zB: lese ich die zuvor eingestellten Frequenzen aus:

uart_puts("\nread FREQ2\n");
uart_putc(cc_readRegister(CC1100_FREQ2));
uart_puts("\nread FREQ1\n");
uart_putc(cc_readRegister(CC1100_FREQ1));
uart_puts("\nread FREQ0\n");
uart_putc(cc_readRegister(CC1100_FREQ0));

Warum gibt der mir dann beim Lesen immer nur \0 aus obwohl da jetzt 0x21 
0x76 und 0x27 zurückkommen müsste.

Hier nochmal die Funktion cc_readRegister:

char cc_readRegister(char addr){
  char data = 0xff;
  
  cc_select(1);
  
  data = spi((addr |0x80));
  
  uart_puts("data = ");
  uart_putc(data);
  uart_putc('\n');
  
  data = spi(addr | 0x80);
  
  uart_puts("data = ");
  uart_putc(data);
  uart_putc('\n');
  
  cc_select(0);
  
  return data;
}

Vielen Dank für eure Mühe

Gruß cler :)

[holger (Gast)]

Versuchs mal so:

char cc_readRegister(char addr){
  char data = 0xff;
  
  cc_select(0);
  
  data = spi((addr |0x80));
  
  uart_puts("data = ");
  uart_putc(data);
  uart_putc('\n');
  
  data = spi(addr | 0x80);
  
  uart_puts("data = ");
  uart_putc(data);
  uart_putc('\n');
  
  cc_select(1);
  
  return data;
}

[Scheri (Gast)]

>Warum gibt der mir dann beim Lesen immer nur \0 aus obwohl da jetzt 0x21
>0x76 und 0x27 zurückkommen müsste.

Stimmt der SPI Mode?

[Karl H. (kbuchegg)]

holger schrieb:
> Versuchs mal so:

:-)
oder zeig zumindest die Funktion cc_select her, zusammen mit der 
Information, ob der angehängte IC eine 1 oder eine 0 an seinem 
Select-Eingang sehen will um sich angesprochen zu fühlen.

[cler :) (Gast)]

Hier ist die Funktion mit dem select also wie schon im Datenblatt steht 
CS muss low sein also wenn ich cc_select(1) hab aktiviere ich den Chip 
und schalte demnach auf low:

void cc_select(unsigned char p){
  if(p == 1){
    PORTB &= ~(1 << PB1);  
  }else{
    PORTB |= (1 << PB1);  
  }  
}

Habe das sowohl mit der Polarität und der Phase ausprobiert. Und beides 
nochmal mit vertauschtem cc_select() ich bin langsam mit meinem Latein 
am Ende.

[Felix P. (fixxl)]

Hast du irgendwo in deinem Initialisierungscode die Zeile

DDRB |= 1<<PB1;

drin?

Ansonsten würdest du mit deiner Funktion cc_select(1) nur den 
Pullup-Widerstand deaktivieren bzw. ihn mit cc_select(0) aktivieren.

[Karl H. (kbuchegg)]

Oder mal alles zusammengenommen:

Zeig doch bitte endlich mal den kompletten Code!
Die UART Funktionen brauchen wir nicht. Aber alle Funktionen, egal ob du 
sie für wichtig hältst oder nicht, die im Zusammenhang mit SPI stehen. 
Und ja, die Datenrichtungen gehören da genauso dazu! Im Idealfall 
versetzt du uns in die Lage, deinen Code zu nehmen, zu compilieren und 
auf einen M44 zu brennen.

Du hast doch selber schon gesehen, dass dein erster Fehler (SS Pin) 
nicht in dem aufgetaucht ist, was du präsentiert hast! Gefunden wurde er 
nur, weil das ein Standardfehler ist und korrekt erraten wurde. Lass uns 
nicht raten! Lass uns am Problem arbeiten. Dazu brauchen wir aber 
vollständige Informationen.

[cler :) (Gast)]

IO Initialisierung:

void io_init(){
  // I/O-Ports initialisieren

  /* Port B Initialisierung
  // Port B1  -  CS  ->   output default high
  // Port B2  -  GD0 ->  input with pullup
*/
  PORTB = 0x06;
  DDRB = 0x06;

  /* Port C Initialisierung
  // Port C1  -  SO  -> output default high
  // Port C2  -  SI -> input without pullup
  // Port C3  -  SCLK -> output default low
*/
  PORTC = 0x02;
  DDRC = 0x0A;

  /* Port D Initialisierung
  // Port D0  -  powersupply CC1100 -> output default low

  // Port D7  -  LED -> output default low*/
  PORTD = 0x00;
  DDRD = 0x81;
}

/************************************************************************
void cc_select(unsigned char p):
  p = 1 select cc1101
  p = 0 deselect cc1101
  
  selects the cc1101 on active low     
  PB1 selection pin                                
************************************************************************/
void cc_select(unsigned char p){
  if(p == 1){
    PORTB &= ~(1 << PB1);  
  }else{
    PORTB |= (1 << PB1);  
  }  
}

/************************************************************************
void cc_power(unsigned char p)
  p = 1 power on
  p = 0 power off
  
  turn on the cc1101 on PD0 high
************************************************************************/
void cc_power(unsigned char p){
  if(p == 1){
    PORTD |= (1 << PD0); 
  }else{
    PORTD &= ~(1 << PD0);
  }
}

SPI Funktionen:

/*************************************************************************
void spi_init():
  SPI configuration as master                                                                   
************************************************************************/
void spi_init(){
  SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0);
}

/************************************************************************
char spi(char data):
  data = data to or address of spi register of cc1101
  
  addr will be manipulated that the msb shows that the master is
  reading from the bus
************************************************************************/
char spi(char data){
  SPDR = data;
  while(!(SPSR & (1 << SPIF)));
  return SPDR;
}

/************************************************************************
cc_writeRegister(char addr, char data)
  addr = register address
  data = data written to registers address  
************************************************************************/
void cc_writeRegister(char addr, char data){  
  cc_select(1);
  
  spi(addr);
  spi(data);
  
  cc_select(0);
}

/************************************************************************
cc_readRegister(char addr)
  addr = address of register
************************************************************************/
char cc_readRegister(char addr){
  char data = 0xff;
  
  cc_select(1);
  
  data = spi((addr |0x80));
  
  uart_puts("data = ");
  uart_putc(data);
  uart_putc('\n');
  
  data = spi(addr | 0x80);
  
  uart_puts("data = ");
  uart_putc(data);
  uart_putc('\n');
  
  cc_select(0);
  
  return data;
}

/************************************************************************
void cc_config():
  configures the cc1101 with the necessary settings:
************************************************************************/
void cc_config(){
  uart_puts("write 1\n");
  cc_writeRegister(CC1100_FSCTRL1, 0x08);
  uart_puts("write 2\n");
  cc_writeRegister(CC1100_FSCTRL0, 0x00);
  uart_puts("write 3\n");
  cc_writeRegister(CC1100_FIFOTHR, 0x04);
  uart_puts("write 4\n");
  cc_writeRegister(CC1100_FREQ2, 0x21);
  uart_puts("write 5\n");
  cc_writeRegister(CC1100_FREQ1, 0x76);
  uart_puts("write 6\n");
  cc_writeRegister(CC1100_FREQ0, 0x27);      
}

Main:

int main(void)
{  
  //initialization functions
  io_init();
  spi_init();
  uart_init();  
  
  cc_power(1);
  uart_puts("cc1100 eingeschaltet\n");
  cc_config();
  uart_puts("cc1100 configuriert\n");
  
  //program started go into while loop
  uart_puts("start\n");
  
  uart_puts("\nread FREQ2\n");
  uart_putc(cc_readRegister(CC1100_FREQ2));
  uart_puts("\nread FREQ1\n");
  uart_putc(cc_readRegister(CC1100_FREQ1));
  uart_puts("\nread FREQ0\n");
  uart_putc(cc_readRegister(CC1100_FREQ0));
    
    while(1){                
  }
  
  return 0;
}

[Felix P. (fixxl)]

  /* Port B Initialisierung
  // Port B1  -  CS  ->   output default high
  // Port B2  -  GD0 ->  input with pullup
*/
  PORTB = 0x06;
  DDRB = 0x06;

B2 wird durch diese Befehle kein Input mit Pullup sondern ein 5V-Output. 
06h = 00000110b.

[cler :) (Gast)]

Den musste ich so setzen damit die SPI Verbindung nicht mehr in der 
whileschleife hängen bleibt. Habe noch vergessen die Kommentare zu 
pflegen Danke :)

[Karl H. (kbuchegg)]

Entweder stell ich mich jetzt dumm an, oder irgendwas anderes stimmt 
nicht. Ich kann vom Mega44 kein Datenblatt finden.

Nichts desto trotz

> void io_init(){
>   // I/O-Ports initialisieren
>
>   /* Port B Initialisierung
>   // Port B1  -  CS  ->   output default high
>   // Port B2  -  GD0 ->  input with pullup
> */
>   PORTB = 0x06;
>   DDRB = 0x06;
>
>   /* Port C Initialisierung
>   // Port C1  -  SO  -> output default high
>   // Port C2  -  SI -> input without pullup
>   // Port C3  -  SCLK -> output default low
> */
>   PORTC = 0x02;
>   DDRC = 0x0A;


mir fehlt da immer noch das Setzen des SS Pins auf Ausgang

Warum schreibst du das eigentlich alles mit Hex-Zahlen

So...

   /* Port B Initialisierung
   // Port B1  -  CS  ->   output default high
   // Port B2  -  GD0 ->  input with pullup
   */
  PORTB = (1 << PB1) | (1 << PB2);
  DDRB = (1 << PB1) | (1 << PB2);

  /* Port C Initialisierung
  // Port C1  -  SO  -> output default high
  // Port C2  -  SI -> input without pullup
  // Port C3  -  SCLK -> output default low
  */
  PORTC = (1 << C1);
  DDRC = (1 << C1) | (1 << C3);

... wäre das alles viel einfacher zu kontrollieren, ob du auch wirklich 
die richtigen Pins auf Output gesetzt hast.

Mit ein paar define davor

   /* Port B Initialisierung
   // Port B1  -  CS  ->   output default high
   // Port B2  -  GD0 ->  input with pullup
   */
#define CS  PB1
#define GD0 PB2

  PORTB = (1 << CS) | (1 << GD0);
  DDRB = (1 << CS) | (1 << GD0);

  /* Port C Initialisierung
  // Port C1  -  SO  -> output default high
  // Port C2  -  SI -> input without pullup
  // Port C3  -  SCLK -> output default low
  */
#define SO   PC1
#define SI   PC2
#define SCLK PC3

  PORTC = (1 << SO);
  DDRC = (1 << SO) | (1 << SCLK);

... wirds dann gleich noch eine Spur leichter zu durchschauen. Vor allen 
Dingen im Code danach, bei dem dann ein ...

/************************************************************************
void cc_select(unsigned char p):
  p = 1 select cc1101
  p = 0 deselect cc1101
  
  selects the cc1101 on active low     
************************************************************************/
void cc_select(unsigned char p){
  if(p == 1){
    PORTB &= ~(1 << CS);  
  }else{
    PORTB |= (1 << CS);  
  }  
}

... mir schon Codemässig erzählt, dass es hier um den CS (also Chip 
Select) geht. Das der am PB1 hängt muss mich dann eigentlich nicht mehr 
weiter interessieren. OK, das PORTB schränkt mich an dieser Stelle noch 
ein wenig ein, aber gut, könnte man auch noch ändern.


Nichts desto trotz. Ich vermisse den Pin SS der SPI Schnittstelle. Der 
wird nirgends auf Output gesetzt.

[Karl H. (kbuchegg)]

cler :) schrieb:
> Den musste ich so setzen damit die SPI Verbindung nicht mehr in der
> whileschleife hängen bleibt. Habe noch vergessen die Kommentare zu
> pflegen Danke :)

Was sagt uns das?
Kommentare sind Scheisse. Wenn du eine Möglichkeit hast, einen Kommentar 
dadurch wegzubringen, indem du direkt im Code genau dasselbe aussagen 
kannst, DANN TU DAS UND LASS DEN KOMMENTAR WEG!

[spess53 (Gast)]

Hi

>Ich kann vom Mega44 kein Datenblatt finden.

Den gibt es auch nicht. Entweder meint er einen ATMega644A oder einen 
ATMega48A.

MfG Spess

[Karl H. (kbuchegg)]

Karl Heinz Buchegger schrieb:
> Entweder stell ich mich jetzt dumm an, oder irgendwas anderes stimmt
> nicht. Ich kann vom Mega44 kein Datenblatt finden.

? Kann wer näheres dazu beitragen
Es gibt einen Tiny44
und einen Mega48

aber einen Mega44 kann ich nicht finden?

[Karl H. (kbuchegg)]

spess53 schrieb:
> Hi
>
>>Ich kann vom Mega44 kein Datenblatt finden.
>
> Den gibt es auch nicht. Entweder meint er einen ATMega644A oder einen
> ATMega48A.

Hab ich mir auch schon gedacht.
Aber die Pinbelegung des Hardware-SPI am Port C passt zu keinem von 
beiden.

[cler :) (Gast)]

Habe mich was den Controller angeht vertippt tut mir Leid.

Ich habe den Fehler gelöst. Der CC1100 auf der Platine scheint defekt zu 
sein zumindest macht es den Eindruck mit der Lupe das würde einiges 
erklären, denke ich.

Gruß cler

[Karl H. (kbuchegg)]

cler :) schrieb:
> Habe mich was den Controller angeht vertippt tut mir Leid.

Und? Welcher ist es?

[cler :) (Gast)]

Der Atmega48a

[Spess53 (Gast)]

Hi

>Der Atmega48a

Der hat aber kein SPI an PortC:

PC3 (ADC3/PCINT11)
PC2 (ADC2/PCINT10)
PC1 (ADC1/PCINT9)

sondern an PortB

PB5 (SCK/PCINT5)
PB4 (MISO/PCINT4)
PB3 (MOSI/OC2A/PCINT3
PB2 (SS/OC1B/PCINT2)

MfG Spess