Zwei PIC18F2550 mit SPI koppeln

[FitzDaKat (Gast)]

Hallo,

ich arbeite seit mehreren Tagen, an einem Teil von meinem Projekt. Ich 
möchte zwei PIC18F2550 über SPI verdrahten, damit diese Daten 
austauschen. An und für sich dachte ich, das wäre kein Problem. Nun 
stellt es sich aber doch sehr kniffelig heraus.


Die µCs sind nach folgendem Schema mit draht aneinander gekoppelt, 
Betriebsspannung ist vorhanden und zugeschaltet;): Der Master soll einen 
counter vom Slave auslesen und über LEDS an PORTA ausgeben.

Master:   Slave:
SCK--------->SCK
SDI<---------SDO
SDO--------->SDI
CS(RB2)----->SS(RA5)

Pull-Up oder Pull-Down Widerstände verwende ich bislang keine.Könnte das 
eine Fehlerquelle sein?

Der bisherige Quellcode des Masters sieht wie folgt aus:

//#include<p18f2550.h>
#include<p18cxxx.h>
#include<delays.h>
#include<portb.h>
#include<timers.h>
#include<adc.h>
#include<stdlib.h>
#include<spi.h>



#pragma config PLLDIV = 5        //PLL for 4Mhz
#pragma config CPUDIV = OSC1_PLL2    //Takt 
#pragma config FOSC = HS        //Interner Oszillator
#pragma config FCMEN = OFF        //keine Taktüberwachung
#pragma config PWRT = ON        //Poweruptimer on
#pragma config BOR = ON        //Kein Brown Out Reset
#pragma config WDT = OFF        //WatchDogTimer Off
#pragma config MCLRE = ON        //MCLR on
#pragma config PBADEN = OFF        //PortB digital I/Os
#pragma config STVREN = OFF        //Kein Stackreset
#pragma config LVP = OFF        //Kein LowPowerICSP
#pragma config DEBUG = OFF        //RB6,RB7 stehen zur Verfügung
#pragma config IESO = OFF        //IESO Off



/*
void high_isr(void);

#pragma code high_vector=0x08
void interrupt_at_high_vector(void){
    _asm goto high_isr _endasm
}*/

#pragma code
/*
#pragma interrupt high_isr
void high_isr (void)
{

}*/

void SPI_TR_Done(void);
char spi_read_write(char data);


void SPI_TR_Done(void)
{
  PORTBbits.RB3=1;
  while(SSPSTATbits.BF==0);
}//SPI_TR_Done()


char spi_read_write(char data)
{
  char dataReturn;
  SSPBUF = data;
  SPI_TR_Done();
  dataReturn=SSPBUF;
  return(dataReturn);
}//spi_write(char data)  

void main(void)
{
char i=0x0A;


ADCON1=0x0F;


PORTA=0;
TRISA=0;

PORTBbits.RB2=1;
PORTBbits.RB3=0;
PORTBbits.RB4=0;

//Enable MSSP
OpenSPI(SPI_FOSC_16, MODE_10, SMPMID);

DDRBbits.RB0=1;//SDI = Input
DDRBbits.RB1=0;//SCK=Output
DDRBbits.RB2=0;//CS=Output
DDRCbits.RC7=0;//SDO=Output
DDRBbits.RB3=0;
DDRBbits.RB4=0;


PORTA=i;
Delay10KTCYx(150);


while(1)
{
PORTBbits.RB2=0;
i=spi_read_write(0xFF);
PORTBbits.RB2=1;
LATA=i;
Delay10KTCYx(200);
}


}//end main

Der des Slave so:

#include <p18F2550.h>
#include<p18cxxx.h>
#include<delays.h>
#include<math.h>
#include<capture.h>
#include<timers.h>
#include <stdlib.h>
#include<spi.h>

#define STATLEDDIR DDRCbits.RC6
#define STATLED PORTCbits.RC6
#pragma config PLLDIV = 1        //PLL for 20Mhz
#pragma config CPUDIV = OSC1_PLL2    //Takt = 12Mhz:1=12Mhz
#pragma config FOSC = HS        //bis 20MHz Taktung
#pragma config FCMEN = OFF        //keine Taktüberwachung
#pragma config PWRT = ON        //Poweruptimer on
#pragma config BOR = ON          //Kein Brown Out Reset
#pragma config WDT = OFF        //WatchDogTimer Off
#pragma config MCLRE = ON        //MCLR on
#pragma config PBADEN = OFF        //PortB digital I/Os
#pragma config STVREN = OFF        //Kein Stackreset
#pragma config LVP = OFF        //Kein LowPowerICSP
#pragma config DEBUG = OFF        //RB6,RB7 stehen zur Verfügung
#pragma config IESO = OFF        //IESO Off
#pragma config CCP2MX = ON        //CCP2 multiplexed mit RC1

unsigned char SPI_cnt=0;

void SPI_TR_Done(void);
char spi_read_write(char data);

void SPI_TR_Done(void)
{
  STATLED=0;
  while(!PIR1bits.SSPIF);
    PIR1bits.SSPIF = 0x00;
    SSPSTATbits.BF=0;
    SPI_cnt++;
    if(SPI_cnt>0x0F)SPI_cnt=0;

}//SPI_TR_Done()


char spi_read_write(char data)
{
  char dataReturn;
  dataReturn=SSPBUF;
  SSPBUF = data;
  return(dataReturn);
}//spi_write(char data)  

void main(void)
{
unsigned char i=0;
unsigned int j=0;
int Error = 0;

  ADCON1=0x0F;
  TRISA=0x0F;
  PORTC=0x00;
  TRISC = 0x06;
  INTCONbits.GIE=0;    //disable GLOBAL Interruts
  RCONbits.IPEN=1;    //set Priority scan

  M_DRIVER_Init();    //init dopple H-Bridge
  STATLEDDIR = 0;      //init Stauts LED
  STATLED = i;      //unleash LED

//SPI CONFIG
DDRBbits.RB0=1;//SDI=Input
DDRBbits.RB1=1;//SCK=Input
DDRCbits.RC7=0;//SDO=Output
DDRAbits.RA5=1;//SS=Input

//Open SPI
OpenSPI(SLV_SSON, MODE_10, SMPMID);
//End Open SPI

STATLED=1;
//Test for Serial Data Transport
j=0;
while(1)
{
if(j!=0xFF)
{
STATLED=STATLED^1;
Delay10KTCYx(10);
}
if(SSPSTATbits.BF==1)
{
j=spi_read_write(SPI_cnt);
SSPCON1bits.SSPOV=0;
Delay10KTCYx(100);
}
}
}

Wäre super, wenn sich mal jemand die Mühe macht über den Quellcode 
drüber zu lesen. Ich kann mir jetzt nicht erklären, warum die beiden 
Prozessoren nicht wollen. OSC_Master=20MHz, OSC_Slave=12MHz. Für jede 
Art von Anregung bin ich dankbar.

Gruß Fitz

[Jens M. (Gast)]

FitzDaKat schrieb:
> Pull-Up oder Pull-Down Widerstände verwende ich bislang keine.Könnte das
> eine Fehlerquelle sein?

Nein, SPI verwendet keine. Es ist aber immer schwierig mit zwei 
unbekannten Controllern und einem Bus dazwischen zu debugggen.

Schlage daher vor SDI und SDO am Master brücken. Dann kannst du sehen ob 
das was evtl. rausgeht auch wieder reinkommt.

Wenn du irgendein Messgerät hast um Busaktivitäten zu sehen ist das sehr 
hilfreich. Ein Logiktester reicht da oft.

[FitzDaKat (Gast)]

Werde deinem Tipp später mal nachgehen. Zum messen habe ich nur ein 
Nordmende Oszi BJ1933 oder so^^

Deshalb muss da mit einem Jain antworten...

[Jens M. (Gast)]

FitzDaKat schrieb:
> Nordmende Oszi BJ1933 oder so^^

Baujahr 1933? ;-) Reicht aber völlig aus, musst nur Takt und Daten 
anschauen. Wenn das Oszi zu langsam ist setzt du halt den INTosc auf 
500kHz oder kleiner.

[Holger W. (holgerw)]

Ich würde den Master zuerst programmieren, als Slave einen bekannten 
Baustein, z.b. EEprom. Wenn das sicher läuft dann durch den den Slave 
ersetzen, ansonsten hast du immer 2 Baustellen.

Holger

[FitzDaKat (Gast)]

Hallo Jens Martin, hallo Holger!


zunächst danke für die Hinweise. Es wahr wohl auch etwas 
größenwahnsinnig gleich beide Devices zu programmieren.

@Jens Martin ich bin deinem Hinweis mal auf die Spur gegangen. Es 
scheint als würde der Master seinen Job machen. Was er sendet, bekommt 
er auch wieder rein, wenn ich SDO und SDI kurz schließe.


Ich werde mich die nächsten Tage dann mal mit dem Slave genauer 
beschäftigen. Es ist dann mit an Sicherheit grenzender 
Wahrscheinlichkeit davon aus zu gehen, dass das Ding nen knacks hat ;)

Danke soweit, ich halte euch auf dem Laufenden.
Schönen Abend :)