- SF800 Solar Speicher Tutorial         
Ergebnis 1 bis 7 von 7

Thema: Verständnisfrage zur SPI Kommunikation ..

Hybrid-Darstellung

Vorheriger Beitrag Vorheriger Beitrag   Nächster Beitrag Nächster Beitrag
  1. #1
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    20.08.2008
    Ort
    Karlsruhe
    Alter
    37
    Beiträge
    1.225
    Zitat Zitat von Ritchie Beitrag anzeigen
    heisst das, ich muss die CS Leitung für jedes Byte tooglen oder kann ich die gesamte Übertragung mit einem Low CS fahren, wenn ich mehre Bytes zu übertragen habe.
    Du musst CS während der ganzen Übertragung auf Low halten! Mit CS Low->High beendest du die Übertragung und setzt (üblicherweise) den Zustandsautomaten des Slaves zurück, danach beginnt die Kommunikation wieder ganz von vorne!

    Der angehängte Plot sieht gut aus, der Code bei grobem Überfliegen auch.

    mfG
    Markus
    Tiny ASURO Library: Thread und sf.net Seite

  2. #2
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    07.11.2004
    Beiträge
    332
    Hallo Markus,

    die erste Auswertung der übertragenen Werte sieht auch von meiner Seite gut aus.
    Ich muss die Platine jetzt wieder mit dem Hauptrechner (linux cpu) verdrahten, da dieser eine bessere
    Darstellung der Messwerte hat (Interface zum PC)

    Hier wie versprochen der Quellcode des Slaves (ATMEGA8 auf Interrupt-Basis:

    Init Master
    Code:
    // ==================================================================
    //        Setup of the SPI Interface
    // ==================================================================
    
    void    InitSPIInterface(void)
    {
        SPCR = (1<<CPOL)| (1<<CPHA);                    // Signal Mode 3
        SPCR |= (1<<SPE) | (1<<SPIE);                    //Activate the SPI Interrupt
        SPSR  =0;                                        // Clear the Control Register
    }
    Init Slave
    Code:
    // ==================================================================
    //        Setup of the SPI Interface
    // ==================================================================
    
    void    InitSPIInterface(void)
    {
        SPCR = (1<<CPOL)| (1<<CPHA);                    // Signal Mode 3
        SPCR |= (1<<SPE) | (1<<SPIE);                    //Activate the SPI Interrupt
        SPSR  =0;                                        // Clear the Control Register
    }
    Code:
    // ==================================================================
    //                SPI Interrupt handling
    // ==================================================================
    
    SIGNAL (SIG_SPI)
    {
    char    *pointer;
    unsigned char data=0;
    
        data=SPDR;                                        // get the data byte from the register
        if ( data != 0)
        {        
            if (m_buffer_adr == NULL)                        // Is it the first byte to receive (setup buffer)
            {
                switch( data )                                // get the command byte, which data area
                {
                    case    'G':                            // Actual Angle by the Gyro module (Angle change per second)
                            m_buffer_adr = (char*) &DataBuffer;
                            m_NumberOfBytesToSend=10;
                            pointer=(char*) &m_FilteredGyro;
                            DataBuffer[0]= (char)*pointer++;
                            DataBuffer[1]= (char)*pointer++;
                            DataBuffer[2]= (char)*pointer++;
                            DataBuffer[3]= (char)*pointer;
                            pointer=(char*) &m_accelerometer_x;
                            DataBuffer[4]= (char) *pointer++;
                            DataBuffer[5]= (char) *pointer;
                            pointer=(char*) &m_accelerometer_y;
                            DataBuffer[6]= (char) *pointer++;
                            DataBuffer[7]= (char) *pointer;    
                            pointer=(char*) &m_accelerometer_z;
                            DataBuffer[8]= (char) *pointer++;    
                            DataBuffer[9]= (char) *pointer;    
                            break;
                    case    'C':
                            m_buffer_adr = (char*) &m_OrientationFromCompass;            // Actual Compass value of the extern compass
                            m_NumberOfBytesToSend=sizeof(m_OrientationFromCompass);
                            break;
                    case    '!':                            // Status of the Program
                            m_buffer_adr = (char*) &m_Status;
                            m_NumberOfBytesToSend=sizeof(m_Status);
                            break;
                    case    'I':                            // Version of the
                            m_buffer_adr = (char*) &m_version;
                            m_NumberOfBytesToSend=sizeof(m_version);
                            break;
                    case    'T':                            //
                            m_buffer_adr = (char*) &DataBuffer;
                            m_NumberOfBytesToSend=4;
                            DataBuffer[0]=m_MotorTemperatur_Left;
                            DataBuffer[1]=m_MotorTemperatur_Right;
                            DataBuffer[2]=m_ControllerTemperatur_Left;
                            DataBuffer[3]=m_ControllerTemperatur_Right;
                            break;
                    case    'S':                            //
                            m_buffer_adr = (char*) &DataBuffer;
                            pointer=(char*) &m_MotorCurrent_Left;
                            DataBuffer[0]= (char) *pointer++;
                            DataBuffer[1]= (char) *pointer;    
                            pointer=(char*) &m_MotorCurrent_Right;
                            DataBuffer[2]= (char) *pointer++;
                            DataBuffer[3]= (char) *pointer;
                            m_NumberOfBytesToSend=4;
                            break;
    
                    case    'V':                            //
                            m_buffer_adr = (char*) &m_AkkuVoltage;
                            m_NumberOfBytesToSend=sizeof(m_AkkuVoltage);
                            break;
                    default:
                            m_buffer_adr = (char*) &m_version;
                            m_NumberOfBytesToSend=sizeof(m_version);
                }
                SPDR = *m_buffer_adr;                        // Send the received command as a feedback return to master
                m_NumberOfBytesToSend--;                    
            }
            else                                            // get no the data into the buffer
            {
                if(m_NumberOfBytesToSend > 0)
                {
                    if( m_buffer_adr != NULL )                // Do we have a valid pointer
                    {
                        *m_buffer_adr=data;                    // Store the data into the buffer
                        m_buffer_adr++;                        // Incr. Buffer address for the next byte
                    }
    
                    m_NumberOfBytesToSend--;                // dec. counter of byte to send/receive
                    if(m_NumberOfBytesToSend <= 0)
                        {
                        m_buffer_adr=NULL;                    // Clear Buffer Pointer
                        }
                }
                else
                {
                    m_buffer_adr=NULL;                        // Clear Buffer Pointer
                }
    
            SPDR = 0x0;                                        // Dummy Answer
            }            
        }
        else
        {
                //Slave transmitter ============================================================================
    
                if(m_buffer_adr != NULL)                                // Buffer set up ?
                {
                    if(m_NumberOfBytesToSend > 0)                        // do we have to send bytes still
                    {
                        SPDR = *m_buffer_adr;                            // send the data byte
                        m_buffer_adr++;                                    // get the next byte of the buffer
                        m_NumberOfBytesToSend--;                        // dec. counter of byte to send
                    }
                    else
                    {
                        m_buffer_adr=NULL;                                // Clear Buffer Pointer
                        SPDR=0x0;                                        // No more values in the buffer
                    }
                }
                else
                {
                    m_buffer_adr=NULL;                                    // Clear Buffer Pointer
                    SPDR=0x0;                                            // No more values in the buffer
                }
        }
    }

    Vielen Dank für die Hilfe. Manchmal sieht man den Wald vor lauter Bäumen nicht und ist so eine Hilfe doch nicht schlecht.

    Gruss R.
    Kaum macht man es richtig, schon funktioniert's ...

Ähnliche Themen

  1. SPI - Verständnisfrage
    Von hae im Forum Microcontroller allgemeine Fragen/Andere Microcontroller
    Antworten: 1
    Letzter Beitrag: 29.03.2012, 10:44
  2. Verständnisfrage zur Kommunikation
    Von mameise im Forum AVR Hardwarethemen
    Antworten: 11
    Letzter Beitrag: 29.01.2011, 21:08
  3. seltsames SPI - Verständnisfrage
    Von Crazy Harry im Forum Elektronik
    Antworten: 7
    Letzter Beitrag: 01.03.2008, 18:30
  4. SPI Slave senden Verständnisfrage
    Von semicolon im Forum C - Programmierung (GCC u.a.)
    Antworten: 2
    Letzter Beitrag: 24.06.2007, 15:43
  5. SPI Verständnisfrage
    Von bertl100 im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 9
    Letzter Beitrag: 07.09.2006, 16:54

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •  

fchao-Sinus-Wechselrichter AliExpress