WebSVN - NaviCtrl - Diff - Rev 242 and 248


/*#######################################################################################*/
/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */
/*#######################################################################################*/
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) 2008 Ingo Busker, Holger Buss
// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
// + FOR NON COMMERCIAL USE ONLY
// + www.MikroKopter.com
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
// + bzgl. der Nutzungsbedingungen aufzunehmen.
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
// + Verkauf von Luftbildaufnahmen, usw.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
// + eindeutig als Ursprung verlinkt werden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
// + Benutzung auf eigene Gefahr
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
// + mit unserer Zustimmung zulässig
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
// + this list of conditions and the following disclaimer.
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
// +     from this software without specific prior written permission.
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permitted
// +     for non-commercial use (directly or indirectly)
// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
// +     with our written permission
// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
// +     clearly linked as origin
// +   * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
//
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// +  POSSIBILITY OF SUCH DAMAGE.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include <string.h>
#include "91x_lib.h"
#include "i2c.h"
#include "uart1.h"
#include "timer1.h"
#include "config.h"
#include "led.h"
 
 
 
volatile u8 I2C_State = I2C_STATE_OFF; // only one byte, because of sync by nesting irqs
 
 
 
// number of bytes to send
volatile u8 I2C_TxBufferSize;
// number of bytes to receive
volatile u8 I2C_RxBufferSize;
 
// the transfer buffer
volatile u8 I2C_Buffer[I2C_BUFFER_LEN];
// the transfer direction 
volatile u8 I2C_Direction;
// the slave address
volatile u8 I2C_SlaveAddress = 0x00;
 
// function pointer to process the received bytes
I2C_pRxHandler_t I2C_pRxHandler = NULL;
// goblal timeout 
volatile u32 I2C1_Timeout = 0;
 
//--------------------------------------------------------------
void I2C1_Init(void)
{
        I2C_InitTypeDef   I2C_Struct;
        GPIO_InitTypeDef  GPIO_InitStructure;
       
        I2C_State = I2C_STATE_OFF;
 
        UART1_PutString("\r\n I2C init...");
        // enable Port 2 peripherie
        SCU_APBPeriphClockConfig(__GPIO2, ENABLE);
        // disable a reset state
        SCU_APBPeriphReset(__GPIO2, DISABLE);
 
        // free a busy bus
 
        // At switch on I2C devices can get in a state where they
        // are still waiting for a command due to all the bus lines bouncing
        // around at startup have started clocking data into the device(s).
        // Enable the ports as open collector port outputs
        // and clock out at least 9 SCL pulses, then generate a stop
        // condition and then leave the clock line high.
 
        // configure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT to normal port operation
        GPIO_StructInit(&GPIO_InitStructure);
        GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;
        GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector;
        GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Disable;
        GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt1;
        GPIO_Init(GPIO2, &GPIO_InitStructure);
 
        u8 i;
        u32 delay;
        // set SCL high and then SDA to low (start condition)
        GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET);
        delay = SetDelay(1);
        while (!CheckDelay(delay));
        GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_RESET);
        // toggle SCL at least 10 times from high to low to high
        for(i = 0; i < 10; i++)
        {
                delay = SetDelay(1);
                while (!CheckDelay(delay));
 
                GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_RESET);
                delay = SetDelay(1);
                while (!CheckDelay(delay));
                GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET);
        }
        delay = SetDelay(1);
        while (!CheckDelay(delay));
        // create stop condition setting SDA HIGH when SCL is HIGH
        GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_SET);
 
 
        // reconfigure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT
        GPIO_StructInit(&GPIO_InitStructure);
        GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;
        GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector;
        GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
        GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; //I2C1_CLKOUT, I2C1_DOUT
        GPIO_Init(GPIO2, &GPIO_InitStructure);
 
        // enable I2C peripherie
        SCU_APBPeriphClockConfig(__I2C1,ENABLE);
        // reset I2C peripherie
        SCU_APBPeriphReset(__I2C1,ENABLE);
        SCU_APBPeriphReset(__I2C1,DISABLE);
 
        I2C_DeInit(I2C1);
        I2C_StructInit(&I2C_Struct);
        I2C_Struct.I2C_GeneralCall = I2C_GeneralCall_Disable;
        I2C_Struct.I2C_Ack = I2C_Ack_Enable;
        I2C_Struct.I2C_CLKSpeed = I2C1_CLOCK;
        I2C_Struct.I2C_OwnAddress = 0x00;
        I2C_Init(I2C1, &I2C_Struct);
 
        // empty rx and tx buffer counters
        I2C_TxBufferSize = 0;
        I2C_RxBufferSize = 0;
 
        I2C_Cmd(I2C1, ENABLE);
        I2C_ITConfig(I2C1, ENABLE);
 
        VIC_Config(I2C1_ITLine, VIC_IRQ , PRIORITY_I2C1);
 
        I2C1_Timeout = SetDelay(10*I2C1_TIMEOUT);
        I2C_GenerateSTOP(I2C1, ENABLE);
        I2C_State = I2C_STATE_IDLE;
 
        // start some dummy transmissions cycles
        // to get the irq routine to work
        for(i=0;i<10;i++)
        {
                I2C_State = I2C_STATE_BUFFBUSY;
                I2C_Transmission(0,1,0,1);
                if(I2C_WaitForEndOfTransmission(10)) break;
                UART1_Putchar('.');
        }
        UART1_PutString("ok");
}
 
 
//--------------------------------------------------------------
void I2C1_Deinit(void)
{
        GPIO_InitTypeDef  GPIO_InitStructure;
        UART1_PutString("\r\n I2C deinit...");
        I2C_GenerateStart(I2C1, DISABLE);
        I2C_GenerateSTOP(I2C1, ENABLE);
        VIC_ITCmd(I2C1_ITLine, DISABLE);
        I2C_State = I2C_STATE_OFF;
        I2C_ITConfig(I2C1, DISABLE);
        I2C_Cmd(I2C1, DISABLE);
        I2C_DeInit(I2C1);
        SCU_APBPeriphClockConfig(__I2C1, DISABLE);
 
        // set ports to input
        SCU_APBPeriphClockConfig(__GPIO2, ENABLE);
        GPIO_StructInit(&GPIO_InitStructure);
        GPIO_InitStructure.GPIO_Direction =     GPIO_PinInput;
        GPIO_InitStructure.GPIO_Pin =                   GPIO_Pin_2 | GPIO_Pin_3;
        GPIO_InitStructure.GPIO_Type =                  GPIO_Type_PushPull;
        GPIO_InitStructure.GPIO_IPInputConnected =      GPIO_IPInputConnected_Disable;
        GPIO_InitStructure.GPIO_Alternate =     GPIO_InputAlt1;
        GPIO_Init(GPIO2, &GPIO_InitStructure);
 
        // empty rx and tx buffer
        I2C_TxBufferSize = 0;
        I2C_RxBufferSize = 0;
 
        I2C1_Timeout = SetDelay(10*I2C1_TIMEOUT);
 
        UART1_PutString("ok");
}
 
 
//--------------------------------------------------------------
void I2C1_IRQHandler(void)
{
        static u8 Rx_Idx = 0, Tx_Idx = 0;
        u16 status;
 
        //IENABLE;  // do not enable IRQ nesting for I2C!!!!
 
        // detemine I2C State
        status = I2C_GetLastEvent(I2C1);
 
        if(status & (I2C_FLAG_AF|I2C_FLAG_BERR))  // if an acknowledge failure or bus error occured
        {       // Set and subsequently clear the STOP bit while BTF is set.
                while(I2C_GetFlagStatus (I2C1, I2C_FLAG_BTF) != RESET)
                {
                        I2C_GenerateSTOP (I2C1, ENABLE);  // free the bus
                        I2C_GenerateSTOP (I2C1, DISABLE); // free the bus
                }
                I2C_State = I2C_STATE_IDLE;
                VIC_ITCmd(I2C1_ITLine, DISABLE);
                LED_GRN_OFF;
                return;
        }
        else
        {       // depending on current i2c state
                switch(status)
                {
                        // the start condition was initiated on the bus
                        case I2C_EVENT_MASTER_MODE_SELECT:
                                LED_GRN_ON;
                                // update current bus state variable
                                // jump to rx state if there is nothing to send
                                switch(I2C_Direction)
                                {
                                        case I2C_MODE_TRANSMITTER:
                                                I2C_State = I2C_STATE_TX_PROGRESS;
                                                break;
 
                                        case I2C_MODE_RECEIVER:
                                                if (I2C_RxBufferSize == 0) // nothing to send?
                                                {
                                                        I2C_GenerateSTOP (I2C1, ENABLE);
                                                        VIC_ITCmd(I2C1_ITLine, DISABLE);
                                                        LED_GRN_OFF;
                                                        I2C_State = I2C_STATE_IDLE;
                                                        return;
                                                }
                                                else
                                                {
                                                        I2C_State = I2C_STATE_RX_PROGRESS;
                                                }
                                                break;
 
                                        default: // invalid direction
                                                I2C_GenerateSTOP (I2C1, ENABLE);
                                                VIC_ITCmd(I2C1_ITLine, DISABLE);
                                                LED_GRN_OFF;
                                                I2C_State = I2C_STATE_IDLE;
                                                return;
                                }
                                // enable acknowledge
                                I2C_AcknowledgeConfig (I2C1, ENABLE);
                                // send address/direction byte on the bus
                                I2C_Send7bitAddress(I2C1, I2C_SlaveAddress, I2C_Direction);
                                break;
 
                        // the address byte was send
                        case I2C_EVENT_MASTER_MODE_SELECTED:
                                // Clear EV6 by set again the PE bit
                                I2C_Cmd(I2C1, ENABLE);
                                switch(I2C_State)
                                {
                                        case I2C_STATE_TX_PROGRESS:
                                        // send 1st data byte
                                        Tx_Idx = 0;
                                        I2C_SendData(I2C1, I2C_Buffer[Tx_Idx]);
                                        Tx_Idx++;
                                        // reset timeout
                                        I2C1_Timeout = SetDelay(I2C1_TIMEOUT); // after inactivity the I2C1 bus will be reset
                                        break;
 
                                        case I2C_STATE_RX_PROGRESS:
                                        Rx_Idx = 0;
                                        // disable acknoledge if only one byte has to be read
                                        if(I2C_RxBufferSize == 1) I2C_AcknowledgeConfig (I2C1, DISABLE);               
                                        break;
 
                                        default: // unknown I2C state
                                        // should never happen
                                        I2C_GenerateSTOP (I2C1, ENABLE);
                                        LED_GRN_OFF;
                                        VIC_ITCmd(I2C1_ITLine, DISABLE);
                                        I2C_State = I2C_STATE_IDLE;
                                        return;
                                        break;
                                }
                                break;
 
                        // the master has transmitted a byte and slave has been acknowledged
                        case I2C_EVENT_MASTER_BYTE_TRANSMITTED:
 
                                // some bytes have to be transmitted
                                if(Tx_Idx < I2C_TxBufferSize)
                                {
                                        I2C_SendData(I2C1, I2C_Buffer[Tx_Idx]);
                                        Tx_Idx++;
                                }
                                else // last byte was send
                                {
                                        // generate stop or repeated start condition
                                        if (I2C_RxBufferSize > 0) // is any answer byte expected?
                                        {
                                                I2C_Direction = I2C_MODE_RECEIVER; // switch to master receiver after repeated start condition
                                                I2C_GenerateStart(I2C1, ENABLE);   // initiate repeated start condition on the bus
                                        }
                                        else
                                        {   // stop communication
                                                I2C_GenerateSTOP(I2C1, ENABLE); // generate stop condition to free the bus
                                                VIC_ITCmd(I2C1_ITLine, DISABLE);
                                                LED_GRN_OFF;
                                                I2C_State = I2C_STATE_IDLE;                     // ready for new actions        
                                        }
                                }
                                break;
 
                        // the master has received a byte from the slave
                        case I2C_EVENT_MASTER_BYTE_RECEIVED:
                                // some bytes have to be received
                                if ( Rx_Idx+1 < I2C_RxBufferSize)
                                {       // copy received byte  from the data register to the rx-buffer
                                        I2C_Buffer[Rx_Idx] = I2C_ReceiveData(I2C1);
                                }
                                else // if the last byte was received
                                {
                                        // generate a STOP condition on the bus before reading data register
                                        I2C_GenerateSTOP(I2C1, ENABLE);
                                        I2C_Buffer[Rx_Idx] = I2C_ReceiveData(I2C1);
                                        // call the rx handler function to process recieved data
                                        if(I2C_pRxHandler != NULL) (*I2C_pRxHandler)((u8*)I2C_Buffer, I2C_RxBufferSize);
                                        I2C1_Timeout = SetDelay(I2C1_TIMEOUT);
                                        DebugOut.Analog[15]++;
                                        VIC_ITCmd(I2C1_ITLine, DISABLE);
                                        LED_GRN_OFF;
                                        I2C_State = I2C_STATE_IDLE;
                                        return;
                                }
                                Rx_Idx++;
                                // if the 2nd last byte was received disable acknowledge for the last one
                                if ( (Rx_Idx + 1) == I2C_RxBufferSize )
                                {
                                        I2C_AcknowledgeConfig(I2C1, DISABLE);
                                }
                                break;
 
                        default:// unknown event
                                // should never happen
                                I2C_GenerateSTOP (I2C1, ENABLE);
                                LED_GRN_OFF;
                                VIC_ITCmd(I2C1_ITLine, DISABLE);
                                I2C_State = I2C_STATE_IDLE;
                                break;
                }
        }
        //IDISABLE;      // do not enable IRQ nesting for I2C!!!!
}
 
// ----------------------------------------------------------------------------------------
// wait for end of transmission
u8 I2C_WaitForEndOfTransmission(u32 timeout)
{
        u32 time = SetDelay(timeout);
        while(I2C_State != I2C_STATE_IDLE)
        {
                if(CheckDelay(time)) return(0);
        }
        return(1);
}
 
// ----------------------------------------------------------------------------------------
// try to get access to the transfer buffer      within a timeout limit
// returs 1 on success and 0 on error/timeout
u8 I2C_LockBuffer(u32 timeout)
{      
        if(I2C_WaitForEndOfTransmission(timeout))
        {
                I2C_State = I2C_STATE_BUFFBUSY;
                return(1);
        }
        else return(0);
}
// ----------------------------------------------------------------------------------------
// initate an i2c transmission
u8 I2C_Transmission(u8 SlaveAddr, u8 TxBytes, I2C_pRxHandler_t pRxHandler, u8 RxBytes)
{
        u8 retval = 0;
        if(I2C_State == I2C_STATE_BUFFBUSY)
        {
                if((RxBytes > I2C_BUFFER_LEN) || (TxBytes > I2C_BUFFER_LEN))
                {
                        I2C_State = I2C_STATE_IDLE;
                        return(retval);
                }      
                I2C_RxBufferSize = RxBytes;
                I2C_TxBufferSize = TxBytes;
                // set direction to master transmitter
                if( (I2C_TxBufferSize > 0) && (I2C_TxBufferSize < I2C_BUFFER_LEN) ) I2C_Direction = I2C_MODE_TRANSMITTER;
                else if (( I2C_RxBufferSize > 0 ) && (I2C_RxBufferSize < I2C_BUFFER_LEN) ) I2C_Direction = I2C_MODE_RECEIVER;
                else // nothing to send or receive
                {
                        I2C_State = I2C_STATE_IDLE;
                        I2C_TxBufferSize = 0;
                        I2C_RxBufferSize = 0;
                        return(retval);
                }
                // update slave address and rx data handler     funbction pointer
                I2C_SlaveAddress = SlaveAddr;
                I2C_pRxHandler = pRxHandler;
                // test on busy flag and clear it
                I2C_CheckEvent( I2C1, I2C_FLAG_BUSY );
                // enable I2C IRQ
                VIC_ITCmd(I2C1_ITLine, ENABLE);
                // initiate start condition on the bus
                I2C_GenerateStart(I2C1, ENABLE);
                retval = 1;
         }
         return(retval);
}
 

Rev 242	Rev 248
1	/#######################################################################################/	1	/#######################################################################################/
2	/* !!! THIS IS NOT FREE SOFTWARE !!! */	2	/* !!! THIS IS NOT FREE SOFTWARE !!! */
3	/#######################################################################################/	3	/#######################################################################################/
4	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	4	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5	// + Copyright (c) 2008 Ingo Busker, Holger Buss	5	// + Copyright (c) 2008 Ingo Busker, Holger Buss
6	// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY	6	// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
7	// + FOR NON COMMERCIAL USE ONLY	7	// + FOR NON COMMERCIAL USE ONLY
8	// + www.MikroKopter.com	8	// + www.MikroKopter.com
9	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	9	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10	// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),	10	// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
11	// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.	11	// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
12	// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt	12	// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
13	// + bzgl. der Nutzungsbedingungen aufzunehmen.	13	// + bzgl. der Nutzungsbedingungen aufzunehmen.
14	// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,	14	// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
15	// + Verkauf von Luftbildaufnahmen, usw.	15	// + Verkauf von Luftbildaufnahmen, usw.
16	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	16	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
17	// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,	17	// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
18	// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen	18	// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
19	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	19	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
20	// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts	20	// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
21	// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"	21	// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
22	// + eindeutig als Ursprung verlinkt werden	22	// + eindeutig als Ursprung verlinkt werden
23	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	23	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
24	// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion	24	// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
25	// + Benutzung auf eigene Gefahr	25	// + Benutzung auf eigene Gefahr
26	// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden	26	// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
27	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	27	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
28	// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur	28	// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
29	// + mit unserer Zustimmung zulässig	29	// + mit unserer Zustimmung zulässig
30	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	30	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
31	// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen	31	// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
32	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	32	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
33	// + Redistributions of source code (with or without modifications) must retain the above copyright notice,	33	// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
34	// + this list of conditions and the following disclaimer.	34	// + this list of conditions and the following disclaimer.
35	// + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived	35	// + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
36	// + from this software without specific prior written permission.	36	// + from this software without specific prior written permission.
37	// + * The use of this project (hardware, software, binary files, sources and documentation) is only permitted	37	// + * The use of this project (hardware, software, binary files, sources and documentation) is only permitted
38	// + for non-commercial use (directly or indirectly)	38	// + for non-commercial use (directly or indirectly)
39	// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted	39	// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
40	// + with our written permission	40	// + with our written permission
41	// + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be	41	// + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
42	// + clearly linked as origin	42	// + clearly linked as origin
43	// + * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed	43	// + * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
44	//	44	//
45	// + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"	45	// + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
46	// + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	46	// + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47	// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE	47	// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48	// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE	48	// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
49	// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR	49	// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
50	// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF	50	// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
51	// + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	51	// + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
52	// + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	52	// + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
53	// + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	53	// + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
54	// + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE	54	// + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
55	// + POSSIBILITY OF SUCH DAMAGE.	55	// + POSSIBILITY OF SUCH DAMAGE.
56	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	56	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
57	#include <string.h>	57	#include <string.h>
58	#include "91x_lib.h"	58	#include "91x_lib.h"
59	#include "i2c.h"	59	#include "i2c.h"
60	#include "uart1.h"	60	#include "uart1.h"
61	#include "timer1.h"	61	#include "timer1.h"
62	#include "config.h"	62	#include "config.h"
63	#include "led.h"	63	#include "led.h"
-		64
64		65
65	volatile u8 I2C_State = I2C_STATE_OFF; // only one byte, because of sync by nesting irqs	-
66		66	volatile u8 I2C_State = I2C_STATE_OFF; // only one byte, because of sync by nesting irqs
67	// rxbuffer	-
68	volatile u8 I2C_RxBufferSize;	-
69	volatile u8 I2C_RxBuffer[I2C_RXBUFFER_LEN];	67
-		68	// number of bytes to send
-		69	volatile u8 I2C_TxBufferSize;
-		70	// number of bytes to receive
70	// txbuffer	71	volatile u8 I2C_RxBufferSize;
71	volatile u8 I2C_TxBufferSize;	-
-		72	// the transfer buffer
72	volatile u8 I2C_TxBuffer[I2C_TXBUFFER_LEN];	73	volatile u8 I2C_Buffer[I2C_BUFFER_LEN];
-		74	// the transfer direction
73		75	volatile u8 I2C_Direction;
-		76	// the slave address
74	volatile u8 I2C_Direction;	77	volatile u8 I2C_SlaveAddress = 0x00;
75	volatile u8 I2C_SlaveAddress = 0x00;	-
-		78	// function pointer to process the received bytes
76	I2C_pRxHandler_t I2C_pRxHandler = NULL;	79	I2C_pRxHandler_t I2C_pRxHandler = NULL;
77		80	// goblal timeout
78	volatile u32 I2C1_Timeout = 0;	81	volatile u32 I2C1_Timeout = 0;
79		82
80	//--------------------------------------------------------------	83	//--------------------------------------------------------------
81	void I2C1_Init(void)	84	void I2C1_Init(void)
82	{	85	{
83	I2C_InitTypeDef I2C_Struct;	86	I2C_InitTypeDef I2C_Struct;
84	GPIO_InitTypeDef GPIO_InitStructure;	87	GPIO_InitTypeDef GPIO_InitStructure;
85		88
86	I2C_State = I2C_STATE_OFF;	89	I2C_State = I2C_STATE_OFF;
87		90
88	UART1_PutString("\r\n I2C init...");	91	UART1_PutString("\r\n I2C init...");
89	// enable Port 2 peripherie	92	// enable Port 2 peripherie
90	SCU_APBPeriphClockConfig(__GPIO2, ENABLE);	93	SCU_APBPeriphClockConfig(__GPIO2, ENABLE);
91	// disable a reset state	94	// disable a reset state
92	SCU_APBPeriphReset(__GPIO2, DISABLE);	95	SCU_APBPeriphReset(__GPIO2, DISABLE);
93		96
94	// free a busy bus	97	// free a busy bus
95		98
96	// At switch on I2C devices can get in a state where they	99	// At switch on I2C devices can get in a state where they
97	// are still waiting for a command due to all the bus lines bouncing	100	// are still waiting for a command due to all the bus lines bouncing
98	// around at startup have started clocking data into the device(s).	101	// around at startup have started clocking data into the device(s).
99	// Enable the ports as open collector port outputs	102	// Enable the ports as open collector port outputs
100	// and clock out at least 9 SCL pulses, then generate a stop	103	// and clock out at least 9 SCL pulses, then generate a stop
101	// condition and then leave the clock line high.	104	// condition and then leave the clock line high.
102		105
103	// configure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT to normal port operation	106	// configure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT to normal port operation
104	GPIO_StructInit(&GPIO_InitStructure);	107	GPIO_StructInit(&GPIO_InitStructure);
105	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;	108	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
106	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 \| GPIO_Pin_3;	109	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 \| GPIO_Pin_3;
107	GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector;	110	GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector;
108	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Disable;	111	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Disable;
109	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt1;	112	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt1;
110	GPIO_Init(GPIO2, &GPIO_InitStructure);	113	GPIO_Init(GPIO2, &GPIO_InitStructure);
111		114
112	u8 i;	115	u8 i;
113	u32 delay;	116	u32 delay;
114	// set SCL high and then SDA to low (start condition)	117	// set SCL high and then SDA to low (start condition)
115	GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET);	118	GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET);
116	delay = SetDelay(1);	119	delay = SetDelay(1);
117	while (!CheckDelay(delay));	120	while (!CheckDelay(delay));
118	GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_RESET);	121	GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_RESET);
119	// toggle SCL at least 10 times from high to low to high	122	// toggle SCL at least 10 times from high to low to high
120	for(i = 0; i < 10; i++)	123	for(i = 0; i < 10; i++)
121	{	124	{
122	delay = SetDelay(1);	125	delay = SetDelay(1);
123	while (!CheckDelay(delay));	126	while (!CheckDelay(delay));
124		127
125	GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_RESET);	128	GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_RESET);
126	delay = SetDelay(1);	129	delay = SetDelay(1);
127	while (!CheckDelay(delay));	130	while (!CheckDelay(delay));
128	GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET);	131	GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET);
129	}	132	}
130	delay = SetDelay(1);	133	delay = SetDelay(1);
131	while (!CheckDelay(delay));	134	while (!CheckDelay(delay));
132	// create stop condition setting SDA HIGH when SCL is HIGH	135	// create stop condition setting SDA HIGH when SCL is HIGH
133	GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_SET);	136	GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_SET);
134		137
135		138
136	// reconfigure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT	139	// reconfigure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT
137	GPIO_StructInit(&GPIO_InitStructure);	140	GPIO_StructInit(&GPIO_InitStructure);
138	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;	141	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
139	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 \| GPIO_Pin_3;	142	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 \| GPIO_Pin_3;
140	GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector;	143	GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector;
141	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;	144	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
142	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; //I2C1_CLKOUT, I2C1_DOUT	145	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; //I2C1_CLKOUT, I2C1_DOUT
143	GPIO_Init(GPIO2, &GPIO_InitStructure);	146	GPIO_Init(GPIO2, &GPIO_InitStructure);
144		147
145	// enable I2C peripherie	148	// enable I2C peripherie
146	SCU_APBPeriphClockConfig(__I2C1,ENABLE);	149	SCU_APBPeriphClockConfig(__I2C1,ENABLE);
147	// reset I2C peripherie	150	// reset I2C peripherie
148	SCU_APBPeriphReset(__I2C1,ENABLE);	151	SCU_APBPeriphReset(__I2C1,ENABLE);
149	SCU_APBPeriphReset(__I2C1,DISABLE);	152	SCU_APBPeriphReset(__I2C1,DISABLE);
150		153
151	I2C_DeInit(I2C1);	154	I2C_DeInit(I2C1);
152	I2C_StructInit(&I2C_Struct);	155	I2C_StructInit(&I2C_Struct);
153	I2C_Struct.I2C_GeneralCall = I2C_GeneralCall_Disable;	156	I2C_Struct.I2C_GeneralCall = I2C_GeneralCall_Disable;
154	I2C_Struct.I2C_Ack = I2C_Ack_Enable;	157	I2C_Struct.I2C_Ack = I2C_Ack_Enable;
155	I2C_Struct.I2C_CLKSpeed = I2C1_CLOCK;	158	I2C_Struct.I2C_CLKSpeed = I2C1_CLOCK;
156	I2C_Struct.I2C_OwnAddress = 0x00;	159	I2C_Struct.I2C_OwnAddress = 0x00;
157	I2C_Init(I2C1, &I2C_Struct);	160	I2C_Init(I2C1, &I2C_Struct);
158		161
159	// empty rx and tx buffer	162	// empty rx and tx buffer counters
160	I2C_TxBufferSize = 0;	163	I2C_TxBufferSize = 0;
161	I2C_RxBufferSize = 0;	164	I2C_RxBufferSize = 0;
162		165
163	I2C_Cmd(I2C1, ENABLE);	166	I2C_Cmd(I2C1, ENABLE);
164	I2C_ITConfig(I2C1, ENABLE);	167	I2C_ITConfig(I2C1, ENABLE);
165		168
166	VIC_Config(I2C1_ITLine, VIC_IRQ , PRIORITY_I2C1);	169	VIC_Config(I2C1_ITLine, VIC_IRQ , PRIORITY_I2C1);
167		170
168	I2C1_Timeout = SetDelay(10*I2C1_TIMEOUT);	171	I2C1_Timeout = SetDelay(10*I2C1_TIMEOUT);
169	I2C_GenerateSTOP(I2C1, ENABLE);	172	I2C_GenerateSTOP(I2C1, ENABLE);
170	I2C_State = I2C_STATE_IDLE;	173	I2C_State = I2C_STATE_IDLE;
-		174
-		175	// start some dummy transmissions cycles
-		176	// to get the irq routine to work
-		177	for(i=0;i<10;i++)
-		178	{
-		179	I2C_State = I2C_STATE_BUFFBUSY;
-		180	I2C_Transmission(0,1,0,1);
-		181	if(I2C_WaitForEndOfTransmission(10)) break;
-		182	UART1_Putchar('.');
171		183	}
172	UART1_PutString("ok");	184	UART1_PutString("ok");
173	}	185	}
174		186
175		187
176	//--------------------------------------------------------------	188	//--------------------------------------------------------------
177	void I2C1_Deinit(void)	189	void I2C1_Deinit(void)
178	{	190	{
179	GPIO_InitTypeDef GPIO_InitStructure;	191	GPIO_InitTypeDef GPIO_InitStructure;
180	UART1_PutString("\r\n I2C deinit...");	192	UART1_PutString("\r\n I2C deinit...");
181	I2C_GenerateStart(I2C1, DISABLE);	193	I2C_GenerateStart(I2C1, DISABLE);
182	I2C_GenerateSTOP(I2C1, ENABLE);	194	I2C_GenerateSTOP(I2C1, ENABLE);
183	VIC_ITCmd(I2C1_ITLine, DISABLE);	195	VIC_ITCmd(I2C1_ITLine, DISABLE);
184	I2C_State = I2C_STATE_OFF;	196	I2C_State = I2C_STATE_OFF;
185	I2C_ITConfig(I2C1, DISABLE);	197	I2C_ITConfig(I2C1, DISABLE);
186	I2C_Cmd(I2C1, DISABLE);	198	I2C_Cmd(I2C1, DISABLE);
187	I2C_DeInit(I2C1);	199	I2C_DeInit(I2C1);
188	SCU_APBPeriphClockConfig(__I2C1, DISABLE);	200	SCU_APBPeriphClockConfig(__I2C1, DISABLE);
189		201
190	// set ports to input	202	// set ports to input
191	SCU_APBPeriphClockConfig(__GPIO2, ENABLE);	203	SCU_APBPeriphClockConfig(__GPIO2, ENABLE);
192	GPIO_StructInit(&GPIO_InitStructure);	204	GPIO_StructInit(&GPIO_InitStructure);
193	GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;	205	GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
194	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 \| GPIO_Pin_3;	206	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 \| GPIO_Pin_3;
195	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;	207	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
196	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Disable;	208	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Disable;
197	GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1;	209	GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1;
198	GPIO_Init(GPIO2, &GPIO_InitStructure);	210	GPIO_Init(GPIO2, &GPIO_InitStructure);
199		211
200	// empty rx and tx buffer	212	// empty rx and tx buffer
201	I2C_TxBufferSize = 0;	213	I2C_TxBufferSize = 0;
202	I2C_RxBufferSize = 0;	214	I2C_RxBufferSize = 0;
203		215
204	I2C1_Timeout = SetDelay(10*I2C1_TIMEOUT);	216	I2C1_Timeout = SetDelay(10*I2C1_TIMEOUT);
205		217
206	UART1_PutString("ok");	218	UART1_PutString("ok");
207	}	219	}
208		-
209		220
210	//--------------------------------------------------------------	221	//--------------------------------------------------------------
211	void I2C1_IRQHandler(void)	222	void I2C1_IRQHandler(void)
212	{	223	{
213	static u8 Rx_Idx = 0, Tx_Idx = 0;	224	static u8 Rx_Idx = 0, Tx_Idx = 0;
214	u16 status;	225	u16 status;
215		226
216	//IENABLE; // do not enable IRQ nesting for I2C!!!!	227	//IENABLE; // do not enable IRQ nesting for I2C!!!!
217		-
218	// detemine I2C State	228	// detemine I2C State
219	status = I2C_GetLastEvent(I2C1);	229	status = I2C_GetLastEvent(I2C1);
220		230
221	if(status & (I2C_FLAG_AF\|I2C_FLAG_BERR)) // if an acknowledge failure or bus error occured	231	if(status & (I2C_FLAG_AF\|I2C_FLAG_BERR)) // if an acknowledge failure or bus error occured
222	{ // Set and subsequently clear the STOP bit while BTF is set.	232	{ // Set and subsequently clear the STOP bit while BTF is set.
223	while(I2C_GetFlagStatus (I2C1, I2C_FLAG_BTF) != RESET)	233	while(I2C_GetFlagStatus (I2C1, I2C_FLAG_BTF) != RESET)
224	{	234	{
225	I2C_GenerateSTOP (I2C1, ENABLE); // free the bus	235	I2C_GenerateSTOP (I2C1, ENABLE); // free the bus
226	I2C_GenerateSTOP (I2C1, DISABLE); // free the bus	236	I2C_GenerateSTOP (I2C1, DISABLE); // free the bus
227	}	237	}
228	I2C_State = I2C_STATE_IDLE;	238	I2C_State = I2C_STATE_IDLE;
229	VIC_ITCmd(I2C1_ITLine, DISABLE);	239	VIC_ITCmd(I2C1_ITLine, DISABLE);
230	LED_GRN_OFF;	240	LED_GRN_OFF;
231	return;	241	return;
232	}	242	}
233	else	243	else
234	{ // depending on current i2c state	244	{ // depending on current i2c state
235	switch(status)	245	switch(status)
236	{	246	{
237	// the start condition was initiated on the bus	247	// the start condition was initiated on the bus
238	case I2C_EVENT_MASTER_MODE_SELECT:	248	case I2C_EVENT_MASTER_MODE_SELECT:
239	LED_GRN_ON;	249	LED_GRN_ON;
240	// update current bus state variable	250	// update current bus state variable
241	// jump to rx state if there is nothing to send	251	// jump to rx state if there is nothing to send
242	switch(I2C_Direction)	252	switch(I2C_Direction)
243	{	253	{
244	case I2C_MODE_TRANSMITTER:	254	case I2C_MODE_TRANSMITTER:
245	I2C_State = I2C_STATE_TX_PROGRESS;	255	I2C_State = I2C_STATE_TX_PROGRESS;
246	break;	256	break;
247		257
248	case I2C_MODE_RECEIVER:	258	case I2C_MODE_RECEIVER:
249	if (I2C_RxBufferSize == 0) // nothingto send?	259	if (I2C_RxBufferSize == 0) // nothing to send?
250	{	260	{
251	I2C_GenerateSTOP (I2C1, ENABLE);	261	I2C_GenerateSTOP (I2C1, ENABLE);
252	VIC_ITCmd(I2C1_ITLine, DISABLE);	262	VIC_ITCmd(I2C1_ITLine, DISABLE);
253	LED_GRN_OFF;	263	LED_GRN_OFF;
254	I2C_State = I2C_STATE_IDLE;	264	I2C_State = I2C_STATE_IDLE;
255	return;	265	return;
256	}	266	}
257	else	267	else
258	{	268	{
259	I2C_State = I2C_STATE_RX_PROGRESS;	269	I2C_State = I2C_STATE_RX_PROGRESS;
260	}	270	}
261	break;	271	break;
262		272
263	default: // invalid direction	273	default: // invalid direction
264	I2C_GenerateSTOP (I2C1, ENABLE);	274	I2C_GenerateSTOP (I2C1, ENABLE);
265	VIC_ITCmd(I2C1_ITLine, DISABLE);	275	VIC_ITCmd(I2C1_ITLine, DISABLE);
266	LED_GRN_OFF;	276	LED_GRN_OFF;
267	I2C_State = I2C_STATE_IDLE;	277	I2C_State = I2C_STATE_IDLE;
268	return;	278	return;
269	}	279	}
270	// enable acknowledge	280	// enable acknowledge
271	I2C_AcknowledgeConfig (I2C1, ENABLE);	281	I2C_AcknowledgeConfig (I2C1, ENABLE);
272	// send address/direction byte on the bus	282	// send address/direction byte on the bus
273	I2C_Send7bitAddress(I2C1, I2C_SlaveAddress, I2C_Direction);	283	I2C_Send7bitAddress(I2C1, I2C_SlaveAddress, I2C_Direction);
274	break;	284	break;
275		285
276	// the address byte was send	286	// the address byte was send
277	case I2C_EVENT_MASTER_MODE_SELECTED:	287	case I2C_EVENT_MASTER_MODE_SELECTED:
278	// Clear EV6 by set again the PE bit	288	// Clear EV6 by set again the PE bit
279	I2C_Cmd(I2C1, ENABLE);	289	I2C_Cmd(I2C1, ENABLE);
280	switch(I2C_State)	290	switch(I2C_State)
281	{	291	{
282	case I2C_STATE_TX_PROGRESS:	292	case I2C_STATE_TX_PROGRESS:
283	// send 1st data byte	293	// send 1st data byte
284	Tx_Idx = 0;	294	Tx_Idx = 0;
285	I2C_SendData(I2C1, I2C_TxBuffer[Tx_Idx]);	295	I2C_SendData(I2C1, I2C_Buffer[Tx_Idx]);
286	Tx_Idx++;	296	Tx_Idx++;
287	// reset timeout	297	// reset timeout
288	I2C1_Timeout = SetDelay(I2C1_TIMEOUT); // after inactivity the I2C1 bus will be reset	298	I2C1_Timeout = SetDelay(I2C1_TIMEOUT); // after inactivity the I2C1 bus will be reset
289	break;	299	break;
290		300
291	case I2C_STATE_RX_PROGRESS:	301	case I2C_STATE_RX_PROGRESS:
292	Rx_Idx = 0;	302	Rx_Idx = 0;
293	// disable acknoledge if only one byte has to be read	303	// disable acknoledge if only one byte has to be read
294	if(I2C_RxBufferSize == 1) I2C_AcknowledgeConfig (I2C1, DISABLE);	304	if(I2C_RxBufferSize == 1) I2C_AcknowledgeConfig (I2C1, DISABLE);
295	break;	305	break;
296		306
297	default: // unknown I2C state	307	default: // unknown I2C state
298	// should never happen	308	// should never happen
299	I2C_GenerateSTOP (I2C1, ENABLE);	309	I2C_GenerateSTOP (I2C1, ENABLE);
300	LED_GRN_OFF;	310	LED_GRN_OFF;
301	VIC_ITCmd(I2C1_ITLine, DISABLE);	311	VIC_ITCmd(I2C1_ITLine, DISABLE);
302	I2C_State = I2C_STATE_IDLE;	312	I2C_State = I2C_STATE_IDLE;
303	return;	313	return;
304	break;	314	break;
305	}	315	}
306	break;	316	break;
307		317
308	// the master has transmitted a byte and slave has been acknowledged	318	// the master has transmitted a byte and slave has been acknowledged
309	case I2C_EVENT_MASTER_BYTE_TRANSMITTED:	319	case I2C_EVENT_MASTER_BYTE_TRANSMITTED:
310		320
311	// some bytes have to be transmitted	321	// some bytes have to be transmitted
312	if(Tx_Idx < I2C_TxBufferSize)	322	if(Tx_Idx < I2C_TxBufferSize)
313	{	323	{
314	I2C_SendData(I2C1, I2C_TxBuffer[Tx_Idx]);	324	I2C_SendData(I2C1, I2C_Buffer[Tx_Idx]);
315	Tx_Idx++;	325	Tx_Idx++;
316	}	326	}
317	else // last byte was send	327	else // last byte was send
318	{	328	{
319	// generate stop or repeated start condition	329	// generate stop or repeated start condition
320	if (I2C_RxBufferSize > 0) // is any answer byte expected?	330	if (I2C_RxBufferSize > 0) // is any answer byte expected?
321	{	331	{
322	I2C_Direction = I2C_MODE_RECEIVER; // switch to master receiver after repeated start condition	332	I2C_Direction = I2C_MODE_RECEIVER; // switch to master receiver after repeated start condition
323	I2C_GenerateStart(I2C1, ENABLE); // initiate repeated start condition on the bus	333	I2C_GenerateStart(I2C1, ENABLE); // initiate repeated start condition on the bus
324	}	334	}
325	else	335	else
326	{ // stop communication	336	{ // stop communication
327	I2C_GenerateSTOP(I2C1, ENABLE); // generate stop condition to free the bus	337	I2C_GenerateSTOP(I2C1, ENABLE); // generate stop condition to free the bus
328	VIC_ITCmd(I2C1_ITLine, DISABLE);	338	VIC_ITCmd(I2C1_ITLine, DISABLE);
329	LED_GRN_OFF;	339	LED_GRN_OFF;
330	I2C_State = I2C_STATE_IDLE; // ready for new actions	340	I2C_State = I2C_STATE_IDLE; // ready for new actions
331	}	341	}
332	}	342	}
333	break;	343	break;
334		344
335	// the master has received a byte from the slave	345	// the master has received a byte from the slave
336	case I2C_EVENT_MASTER_BYTE_RECEIVED:	346	case I2C_EVENT_MASTER_BYTE_RECEIVED:
337	// some bytes have to be received	347	// some bytes have to be received
338	if ( Rx_Idx+1 < I2C_RxBufferSize)	348	if ( Rx_Idx+1 < I2C_RxBufferSize)
339	{ // copy received byte from the data register to the rx-buffer	349	{ // copy received byte from the data register to the rx-buffer
340	I2C_RxBuffer[Rx_Idx] = I2C_ReceiveData(I2C1);	350	I2C_Buffer[Rx_Idx] = I2C_ReceiveData(I2C1);
341	}	351	}
342	else // if the last byte was received	352	else // if the last byte was received
343	{	353	{
344	// generate a STOP condition on the bus before reading data register	354	// generate a STOP condition on the bus before reading data register
345	I2C_GenerateSTOP(I2C1, ENABLE);	355	I2C_GenerateSTOP(I2C1, ENABLE);
346	I2C_RxBuffer[Rx_Idx] = I2C_ReceiveData(I2C1);	356	I2C_Buffer[Rx_Idx] = I2C_ReceiveData(I2C1);
347	// call the rx handler function to process recieved data	357	// call the rx handler function to process recieved data
348	if(I2C_pRxHandler != NULL) (I2C_pRxHandler)((u8)I2C_RxBuffer, I2C_RxBufferSize);	358	if(I2C_pRxHandler != NULL) (I2C_pRxHandler)((u8)I2C_Buffer, I2C_RxBufferSize);
349	I2C1_Timeout = SetDelay(I2C1_TIMEOUT);	359	I2C1_Timeout = SetDelay(I2C1_TIMEOUT);
350	DebugOut.Analog[15]++;	360	DebugOut.Analog[15]++;
351	VIC_ITCmd(I2C1_ITLine, DISABLE);	361	VIC_ITCmd(I2C1_ITLine, DISABLE);
352	LED_GRN_OFF;	362	LED_GRN_OFF;
353	I2C_State = I2C_STATE_IDLE;	363	I2C_State = I2C_STATE_IDLE;
354	return;	364	return;
355	}	365	}
356	Rx_Idx++;	366	Rx_Idx++;
357	// if the 2nd last byte was received disable acknowledge for the last one	367	// if the 2nd last byte was received disable acknowledge for the last one
358	if ( (Rx_Idx + 1) == I2C_RxBufferSize )	368	if ( (Rx_Idx + 1) == I2C_RxBufferSize )
359	{	369	{
360	I2C_AcknowledgeConfig(I2C1, DISABLE);	370	I2C_AcknowledgeConfig(I2C1, DISABLE);
361	}	371	}
362	break;	372	break;
363		373
364	default:// unknown event	374	default:// unknown event
365	// should never happen	375	// should never happen
366	I2C_GenerateSTOP (I2C1, ENABLE);	376	I2C_GenerateSTOP (I2C1, ENABLE);
367	LED_GRN_OFF;	377	LED_GRN_OFF;
368	VIC_ITCmd(I2C1_ITLine, DISABLE);	378	VIC_ITCmd(I2C1_ITLine, DISABLE);
369	I2C_State = I2C_STATE_IDLE;	379	I2C_State = I2C_STATE_IDLE;
370	break;	380	break;
371	}	381	}
372	}	382	}
373	//IDISABLE; // do not enable IRQ nesting for I2C!!!!	383	//IDISABLE; // do not enable IRQ nesting for I2C!!!!
374	}	384	}
-		385
-		386	// ----------------------------------------------------------------------------------------
-		387	// wait for end of transmission
-		388	u8 I2C_WaitForEndOfTransmission(u32 timeout)
-		389	{
-		390	u32 time = SetDelay(timeout);
-		391	while(I2C_State != I2C_STATE_IDLE)
-		392	{
-		393	if(CheckDelay(time)) return(0);
-		394	}
-		395	return(1);
-		396	}
-		397
-		398	// ----------------------------------------------------------------------------------------
-		399	// try to get access to the transfer buffer within a timeout limit
-		400	// returs 1 on success and 0 on error/timeout
-		401	u8 I2C_LockBuffer(u32 timeout)
-		402	{
-		403	if(I2C_WaitForEndOfTransmission(timeout))
-		404	{
-		405	I2C_State = I2C_STATE_BUFFBUSY;
-		406	return(1);
-		407	}
-		408	else return(0);
-		409	}
375	// ----------------------------------------------------------------------------------------	410	// ----------------------------------------------------------------------------------------
376	// initate an i2c transmission	411	// initate an i2c transmission
377	u8 I2C_Transmission(u8 SlaveAddr, I2C_pRxHandler_t pRxHandler, u8 RxBytes)	412	u8 I2C_Transmission(u8 SlaveAddr, u8 TxBytes, I2C_pRxHandler_t pRxHandler, u8 RxBytes)
378	{	413	{
379	u8 retval = 0;	414	u8 retval = 0;
-		415	if(I2C_State == I2C_STATE_BUFFBUSY)
380		416	{
381	if(I2C_State == I2C_STATE_IDLE)	417	if((RxBytes > I2C_BUFFER_LEN) \|\| (TxBytes > I2C_BUFFER_LEN))
382	{	418	{
-		419	I2C_State = I2C_STATE_IDLE;
-		420	return(retval);
-		421	}
383	I2C_RxBufferSize = RxBytes;	422	I2C_RxBufferSize = RxBytes;
-		423	I2C_TxBufferSize = TxBytes;
384	// set direction to master transmitter	424	// set direction to master transmitter
385	if( (I2C_TxBufferSize > 0) && (I2C_TxBufferSize < I2C_TXBUFFER_LEN) ) I2C_Direction = I2C_MODE_TRANSMITTER;	425	if( (I2C_TxBufferSize > 0) && (I2C_TxBufferSize < I2C_BUFFER_LEN) ) I2C_Direction = I2C_MODE_TRANSMITTER;
386	else if (( I2C_RxBufferSize > 0 ) && (I2C_RxBufferSize < I2C_RXBUFFER_LEN) ) I2C_Direction = I2C_MODE_RECEIVER;	426	else if (( I2C_RxBufferSize > 0 ) && (I2C_RxBufferSize < I2C_BUFFER_LEN) ) I2C_Direction = I2C_MODE_RECEIVER;
387	else // nothing to send or receive	427	else // nothing to send or receive
388	{	428	{
-		429	I2C_State = I2C_STATE_IDLE;
389	I2C_TxBufferSize = 0;	430	I2C_TxBufferSize = 0;
390	I2C_RxBufferSize = 0;	431	I2C_RxBufferSize = 0;
391	return(retval);	432	return(retval);
392	}	433	}
393	// update slave address and rx data handler funbction pointer	434	// update slave address and rx data handler funbction pointer
394	I2C_SlaveAddress = SlaveAddr;	435	I2C_SlaveAddress = SlaveAddr;
395	I2C_pRxHandler = pRxHandler;	436	I2C_pRxHandler = pRxHandler;
396	// test on busy flag and clear it	437	// test on busy flag and clear it
397	I2C_CheckEvent( I2C1, I2C_FLAG_BUSY );	438	I2C_CheckEvent( I2C1, I2C_FLAG_BUSY );
398	// enable I2C IRQ	439	// enable I2C IRQ
399	VIC_ITCmd(I2C1_ITLine, ENABLE);	440	VIC_ITCmd(I2C1_ITLine, ENABLE);
400	// initiate start condition on the bus	441	// initiate start condition on the bus
401	I2C_GenerateStart(I2C1, ENABLE);	442	I2C_GenerateStart(I2C1, ENABLE);
402	retval = 1;	443	retval = 1;
403	}	444	}
404	return(retval);	445	return(retval);
405	}	446	}
406		447

Subversion Repositories NaviCtrl

(root)/tags/V0.30h/i2c.c @ 457 - Rev 242 → 248