WebSVN - NaviCtrl - Blame - Rev 228

Rev	Author	Line No.	Line
1	ingob	1	/#######################################################################################/
		2	/* !!! THIS IS NOT FREE SOFTWARE !!! */
		3	/#######################################################################################/
		4	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		5	// + Copyright (c) 2008 Ingo Busker, Holger Buss
171	ingob	6	// + Nur f�r den privaten Gebrauch / NON-COMMERCIAL USE ONLY
1	ingob	7	// + FOR NON COMMERCIAL USE ONLY
		8	// + www.MikroKopter.com
		9	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
37	killagreg	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.
		12	// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
		13	// + bzgl. der Nutzungsbedingungen aufzunehmen.
1	ingob	14	// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Best�ckung und Verkauf von Platinen oder Baus�tzen,
		15	// + Verkauf von Luftbildaufnahmen, usw.
		16	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
37	killagreg	17	// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder ver�ffentlicht,
1	ingob	18	// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright m�ssen dann beiliegen
		19	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		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"
		22	// + eindeutig als Ursprung verlinkt werden
		23	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		24	// + Keine Gew�hr auf Fehlerfreiheit, Vollst�ndigkeit oder Funktion
		25	// + Benutzung auf eigene Gefahr
		26	// + Wir �bernehmen keinerlei Haftung f�r direkte oder indirekte Personen- oder Sachsch�den
		27	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
171	ingob	28	// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
1	ingob	29	// + mit unserer Zustimmung zul�ssig
		30	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		31	// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
		32	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
37	killagreg	33	// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
1	ingob	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
		36	// + from this software without specific prior written permission.
37	killagreg	37	// + * The use of this project (hardware, software, binary files, sources and documentation) is only permitted
1	ingob	38	// + for non-commercial use (directly or indirectly)
37	killagreg	39	// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
1	ingob	40	// + with our written permission
37	killagreg	41	// + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
		42	// + clearly linked as origin
171	ingob	43	// + * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
1	ingob	44	//
		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
		47	// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		48	// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
		49	// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		50	// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		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
		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
37	killagreg	55	// + POSSIBILITY OF SUCH DAMAGE.
1	ingob	56	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
41	ingob	57	#include <string.h>
		58	#include "91x_lib.h"
		59	#include "i2c.h"
		60	#include "uart1.h"
119	killagreg	61	#include "timer1.h"
136	killagreg	62	#include "config.h"
1	ingob	63	#include "main.h"
41	ingob	64	#include "led.h"
		65	#include "spi_slave.h"
1	ingob	66
189	killagreg	67	#define I2C_SLAVE_ADDRESS 0x50
1	ingob	68
189	killagreg	69	// I2C states
		70	#define I2C_UNDEF 0
		71	#define I2C_IDLE 1
		72	#define I2C_TX_PROGRESS 2
		73	#define I2C_RX_PENDING 3
		74	#define I2C_RX_PROGRESS 4
		75	#define I2C_OFF 5
41	ingob	76
189	killagreg	77	volatile u8 I2C_State = I2C_OFF; // only on byte! because of sync by nesting irqs
		78	u8 I2C_StopPolling = 1;
		79
41	ingob	80	// rxbuffer
		81	volatile u8 I2C_RxBufferSize;
		82	volatile u8 *I2C_RxBuffer;
		83	// txbuffer
		84	volatile u8 I2C_TxBufferSize;
		85	volatile u8 *I2C_TxBuffer;
		86
		87	volatile u8 I2C_Direction;
		88	volatile u8 I2C_Command;
189	killagreg	89	// I2C Transfer buffers
41	ingob	90	volatile I2C_Heading_t I2C_Heading;
		91	volatile I2C_WriteAttitude_t I2C_WriteAttitude;
		92	volatile I2C_Mag_t I2C_Mag;
		93	volatile I2C_Version_t MK3MAG_Version;
		94	volatile I2C_Cal_t I2C_WriteCal;
		95	volatile I2C_Cal_t I2C_ReadCal;
		96
146	killagreg	97	#define I2C1_TIMEOUT 500 // 500 ms
41	ingob	98	volatile u32 I2C1_Timeout = 0;
1	ingob	99
		100	//--------------------------------------------------------------
		101	void I2C1_Init(void)
		102	{
41	ingob	103	I2C_InitTypeDef I2C_Struct;
		104	GPIO_InitTypeDef GPIO_InitStructure;
149	killagreg	105
		106	I2C_State = I2C_OFF;
37	killagreg	107
110	killagreg	108	UART1_PutString("\r\n I2C init...");
41	ingob	109	// enable Port 2 peripherie
		110	SCU_APBPeriphClockConfig(__GPIO2, ENABLE);
		111	// disable a reset state
		112	SCU_APBPeriphReset(__GPIO2, DISABLE);
1	ingob	113
41	ingob	114	// free a busy bus
1	ingob	115
41	ingob	116	// At switch on I2C devices can get in a state where they
		117	// are still waiting for a command due to all the bus lines bouncing
		118	// around at startup have started clocking data into the device(s).
		119	// Enable the ports as open collector port outputs
		120	// and clock out at least 9 SCL pulses, then generate a stop
		121	// condition and then leave the clock line high.
37	killagreg	122
41	ingob	123	// configure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT to normal port operation
		124	GPIO_StructInit(&GPIO_InitStructure);
		125	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
		126	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 \| GPIO_Pin_3;
		127	GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector;
196	killagreg	128	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Disable;
41	ingob	129	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt1;
		130	GPIO_Init(GPIO2, &GPIO_InitStructure);
37	killagreg	131
41	ingob	132	u8 i;
		133	u32 delay;
		134	// set SCL high and then SDA to low (start condition)
		135	GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET);
		136	delay = SetDelay(1);
		137	while (!CheckDelay(delay));
		138	GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_RESET);
		139	// toggle SCL at least 10 times from high to low to high
		140	for(i = 0; i < 10; i++)
		141	{
		142	delay = SetDelay(1);
		143	while (!CheckDelay(delay));
1	ingob	144
41	ingob	145	GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_RESET);
		146	delay = SetDelay(1);
		147	while (!CheckDelay(delay));
		148	GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET);
		149	}
		150	delay = SetDelay(1);
		151	while (!CheckDelay(delay));
		152	// create stop condition setting SDA HIGH when SCL is HIGH
		153	GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_SET);
37	killagreg	154
		155
41	ingob	156	// reconfigure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT
		157	GPIO_StructInit(&GPIO_InitStructure);
		158	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
		159	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 \| GPIO_Pin_3;
		160	GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector;
196	killagreg	161	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
41	ingob	162	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; //I2C1_CLKOUT, I2C1_DOUT
		163	GPIO_Init(GPIO2, &GPIO_InitStructure);
		164
		165	// enable I2C peripherie
		166	SCU_APBPeriphClockConfig(__I2C1,ENABLE);
		167	// reset I2C peripherie
		168	SCU_APBPeriphReset(__I2C1,ENABLE);
		169	SCU_APBPeriphReset(__I2C1,DISABLE);
		170
		171	I2C_DeInit(I2C1);
		172	I2C_StructInit(&I2C_Struct);
		173	I2C_Struct.I2C_GeneralCall = I2C_GeneralCall_Disable;
		174	I2C_Struct.I2C_Ack = I2C_Ack_Enable;
136	killagreg	175	I2C_Struct.I2C_CLKSpeed = I2C1_CLOCK;
41	ingob	176	I2C_Struct.I2C_OwnAddress = 0x00;
		177	I2C_Init(I2C1, &I2C_Struct);
		178
		179	I2C_TxBuffer = NULL;
		180	I2C_TxBufferSize = 0;
		181
		182	I2C_RxBuffer = NULL;
		183	I2C_RxBufferSize = 0;
		184
		185	I2C_Cmd(I2C1, ENABLE);
		186	I2C_ITConfig(I2C1, ENABLE);
		187
136	killagreg	188	VIC_Config(I2C1_ITLine, VIC_IRQ , PRIORITY_I2C1);
41	ingob	189
189	killagreg	190	I2C1_Timeout = SetDelay(10*I2C1_TIMEOUT);
41	ingob	191	I2C_GenerateSTOP(I2C1, ENABLE);
		192	I2C_State = I2C_IDLE;
		193
154	killagreg	194	I2C_StopPolling = 0; // start polling
		195
110	killagreg	196	UART1_PutString("ok");
1	ingob	197	}
		198
41	ingob	199
1	ingob	200	//--------------------------------------------------------------
41	ingob	201	void I2C1_Deinit(void)
1	ingob	202	{
79	killagreg	203	GPIO_InitTypeDef GPIO_InitStructure;
154	killagreg	204	I2C_StopPolling = 1;// stop polling
110	killagreg	205	UART1_PutString("\r\n I2C deinit...");
41	ingob	206	I2C_GenerateStart(I2C1, DISABLE);
		207	I2C_GenerateSTOP(I2C1, ENABLE);
		208	VIC_ITCmd(I2C1_ITLine, DISABLE);
154	killagreg	209	I2C_State = I2C_OFF;
41	ingob	210	I2C_ITConfig(I2C1, DISABLE);
		211	I2C_Cmd(I2C1, DISABLE);
		212	I2C_DeInit(I2C1);
		213	SCU_APBPeriphClockConfig(__I2C1, DISABLE);
79	killagreg	214
41	ingob	215	// set ports to input
		216	SCU_APBPeriphClockConfig(__GPIO2, ENABLE);
		217	GPIO_StructInit(&GPIO_InitStructure);
		218	GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
79	killagreg	219	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 \| GPIO_Pin_3;
		220	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
196	killagreg	221	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Disable;
79	killagreg	222	GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1;
		223	GPIO_Init(GPIO2, &GPIO_InitStructure);
1	ingob	224
41	ingob	225	I2C_TxBuffer = NULL;
		226	I2C_TxBufferSize = 0;
1	ingob	227
41	ingob	228	I2C_RxBuffer = NULL;
		229	I2C_RxBufferSize = 0;
37	killagreg	230
189	killagreg	231	I2C1_Timeout = SetDelay(10*I2C1_TIMEOUT);
228	holgerb	232	I2C_Heading.Heading = -2;
37	killagreg	233
110	killagreg	234	UART1_PutString("ok");
41	ingob	235	}
1	ingob	236
41	ingob	237
		238	//--------------------------------------------------------------
		239	void I2C1_IRQHandler(void)
		240	{
189	killagreg	241	static u8 Rx_Idx = 0, Tx_Idx = 0, crc = 0;
		242	static u8 I2C_PrimRxBuffer[10]; // must be larger than any of the secondary rx buffers
41	ingob	243	u16 status;
189	killagreg	244
195	killagreg	245	//IENABLE; // do not enable IRQ nesting for I2C!!!!
		246
41	ingob	247	// detemine I2C State
		248	status = I2C_GetLastEvent(I2C1);
		249
		250	if(status & (I2C_FLAG_AF\|I2C_FLAG_BERR)) // if an acknowledge failure or bus error occured
79	killagreg	251	{ // Set and subsequently clear the STOP bit while BTF is set.
41	ingob	252	while(I2C_GetFlagStatus (I2C1, I2C_FLAG_BTF) != RESET)
		253	{
189	killagreg	254	I2C_GenerateSTOP (I2C1, ENABLE); // free the bus
41	ingob	255	I2C_GenerateSTOP (I2C1, DISABLE); // free the bus
		256	}
		257	I2C_State = I2C_IDLE;
189	killagreg	258	VIC_ITCmd(I2C1_ITLine, DISABLE);
41	ingob	259	LED_GRN_OFF;
189	killagreg	260	return;
41	ingob	261	}
		262	else
		263	{ // depending on current i2c state
		264	switch (status)
		265	{
		266	// the start condition was initiated on the bus
		267	case I2C_EVENT_MASTER_MODE_SELECT:
		268	LED_GRN_ON;
		269	// update current bus state variable
		270	switch(I2C_Direction)
		271	{
		272	case I2C_MODE_TRANSMITTER:
		273	I2C_State = I2C_TX_PROGRESS;
		274	break;
79	killagreg	275
41	ingob	276	case I2C_MODE_RECEIVER:
		277	if ((I2C_RxBuffer == NULL) \|\| (I2C_RxBufferSize == 0))
		278	{
		279	I2C_GenerateSTOP (I2C1, ENABLE);
189	killagreg	280	VIC_ITCmd(I2C1_ITLine, DISABLE);
		281	LED_GRN_OFF;
41	ingob	282	I2C_State = I2C_IDLE;
		283	return;
		284	}
		285	else
		286	{
		287	I2C_State = I2C_RX_PROGRESS;
		288	}
		289	break;
79	killagreg	290
41	ingob	291	default: // invalid direction
		292	I2C_GenerateSTOP (I2C1, ENABLE);
189	killagreg	293	VIC_ITCmd(I2C1_ITLine, DISABLE);
		294	LED_GRN_OFF;
41	ingob	295	I2C_State = I2C_IDLE;
		296	return;
		297	}
		298	// enable acknowledge
		299	I2C_AcknowledgeConfig (I2C1, ENABLE);
		300	// send address/direction byte on the bus
		301	I2C_Send7bitAddress(I2C1, I2C_SLAVE_ADDRESS, I2C_Direction);
		302	break;
79	killagreg	303
41	ingob	304	// the address byte was send
		305	case I2C_EVENT_MASTER_MODE_SELECTED:
		306	// Clear EV6 by set again the PE bit
79	killagreg	307	I2C_Cmd(I2C1, ENABLE);
41	ingob	308	// reset checksum
		309	crc = 0;
		310	switch(I2C_State)
		311	{
		312	case I2C_TX_PROGRESS:
79	killagreg	313	// send command 1st data byte (allways the command id)
41	ingob	314	I2C_SendData(I2C1, I2C_Command);
		315	crc += I2C_Command;
		316	Tx_Idx = 0;
		317	// reset timeout
189	killagreg	318	I2C1_Timeout = SetDelay(I2C1_TIMEOUT); // after inactivity the I2C1 bus will be reset
41	ingob	319	break;
79	killagreg	320
41	ingob	321	case I2C_RX_PROGRESS:
		322	Rx_Idx = 0;
		323	break;
79	killagreg	324
41	ingob	325	default: // unknown I2C state
		326	// should never happen
		327	I2C_GenerateSTOP (I2C1, ENABLE);
189	killagreg	328	LED_GRN_OFF;
		329	VIC_ITCmd(I2C1_ITLine, DISABLE);
41	ingob	330	I2C_State = I2C_IDLE;
189	killagreg	331	return;
41	ingob	332	break;
		333	}
		334	break;
79	killagreg	335
41	ingob	336	// the master has transmitted a byte and slave has been acknowledged
		337	case I2C_EVENT_MASTER_BYTE_TRANSMITTED:
79	killagreg	338
41	ingob	339	// some bytes have to be transmitted
		340	if(Tx_Idx < I2C_TxBufferSize)
		341	{
		342	if(I2C_TxBuffer != NULL)
		343	{
		344	I2C_SendData(I2C1, I2C_TxBuffer[Tx_Idx]);
		345	crc += I2C_TxBuffer[Tx_Idx];
		346	}
		347	else
		348	{
		349	I2C_SendData(I2C1, 0x00);
		350	}
		351	}
189	killagreg	352	else if(Tx_Idx == I2C_TxBufferSize) // the last tx buffer byte was send
41	ingob	353	{
		354	// send crc byte at the end
137	killagreg	355	crc = ~crc; // flip all bits in the checksum
41	ingob	356	I2C_SendData(I2C1, crc);
189	killagreg	357	}
		358	else if(Tx_Idx == (I2C_TxBufferSize+1) )
		359	{
		360	I2C_SendData(I2C1, 0xAA); // send a dummybyte
		361	}
		362	else // last byte was send
		363	{
41	ingob	364	// generate stop or repeated start condition
		365	if ((I2C_RxBuffer != NULL) && (I2C_RxBufferSize > 0)) // is any answer byte expected?
		366	{
79	killagreg	367	I2C_Direction = I2C_MODE_RECEIVER; // switch to master receiver after repeated start condition
		368	I2C_GenerateStart(I2C1, ENABLE); // initiate repeated start condition on the bus
41	ingob	369	}
		370	else
		371	{ // stop communication
		372	I2C_GenerateSTOP(I2C1, ENABLE); // generate stop condition to free the bus
189	killagreg	373	VIC_ITCmd(I2C1_ITLine, DISABLE);
41	ingob	374	LED_GRN_OFF;
		375	DebugOut.Analog[15]++;
189	killagreg	376	I2C_State = I2C_IDLE; // ready for new actions
		377
41	ingob	378	}
		379	}
79	killagreg	380	Tx_Idx++;
41	ingob	381	break;
79	killagreg	382
41	ingob	383	// the master has received a byte from the slave
79	killagreg	384	case I2C_EVENT_MASTER_BYTE_RECEIVED:
41	ingob	385	// some bytes have to be received
		386	if (Rx_Idx < I2C_RxBufferSize)
		387	{ // copy received byte from the data register to the rx-buffer
		388	I2C_PrimRxBuffer[Rx_Idx] = I2C_ReceiveData(I2C1);
		389	// update checksum
		390	crc += I2C_PrimRxBuffer[Rx_Idx];
		391	}
		392	// if the last byte (crc) was received
79	killagreg	393	else if ( Rx_Idx == I2C_RxBufferSize)
41	ingob	394	{
		395	// generate a STOP condition on the bus before reading data register
		396	I2C_GenerateSTOP(I2C1, ENABLE);
		397	// compare last byte with checksum
137	killagreg	398	crc = ~crc;// flip all bits in calulated checksum
41	ingob	399	if(crc == I2C_ReceiveData(I2C1))
189	killagreg	400	{
		401	// copy primary rx buffer content to rx buffer if exist
41	ingob	402	if(I2C_RxBuffer != NULL)
		403	{
		404	memcpy((u8 )I2C_RxBuffer, (u8 )I2C_PrimRxBuffer, I2C_RxBufferSize);
		405	}
189	killagreg	406	I2C1_Timeout = SetDelay(I2C1_TIMEOUT);
41	ingob	407	DebugOut.Analog[15]++;
		408	}
		409	else // checksum error detected
		410	{
189	killagreg	411	DebugOut.Analog[14]++;
41	ingob	412	}
189	killagreg	413	VIC_ITCmd(I2C1_ITLine, DISABLE);
		414	LED_GRN_OFF;
41	ingob	415	I2C_State = I2C_IDLE;
189	killagreg	416	return;
41	ingob	417	}
		418	Rx_Idx++;
		419	// if the 2nd last byte was received disable acknowledge for the last one
		420	if ( Rx_Idx == I2C_RxBufferSize )
		421	{
		422	I2C_AcknowledgeConfig (I2C1, DISABLE);
		423	}
		424	break;
79	killagreg	425
41	ingob	426	default:
		427	break;
		428	}
		429	}
195	killagreg	430
		431	//IDISABLE; // do not enable IRQ nesting for I2C!!!!
1	ingob	432	}
		433	//----------------------------------------------------------------
41	ingob	434	void I2C1_SendCommand(u8 command)
1	ingob	435	{
189	killagreg	436	// disable I2C IRQ to check state
		437	VIC_ITCmd(I2C1_ITLine, DISABLE);
41	ingob	438	// If I2C transmission is in progress
189	killagreg	439	if(I2C_State == I2C_IDLE)
41	ingob	440	{
189	killagreg	441	// update current command id
		442	I2C_Command = command;
		443	// set pointers to data area with respect to the command id
		444	switch (command)
		445	{
		446	case I2C_CMD_VERSION:
		447	I2C_RxBuffer = (u8 *)&MK3MAG_Version;
		448	I2C_RxBufferSize = sizeof(MK3MAG_Version);
		449	I2C_TxBuffer = NULL;
		450	I2C_TxBufferSize = 0;
		451	break;
		452	case I2C_CMD_WRITE_CAL:
		453	I2C_RxBuffer = (u8 *)&I2C_ReadCal;
		454	I2C_RxBufferSize = sizeof(I2C_ReadCal);
		455	I2C_TxBuffer = (u8 *)&I2C_WriteCal;
		456	I2C_TxBufferSize = sizeof(I2C_WriteCal);
		457	break;
		458	case I2C_CMD_READ_MAG:
		459	I2C_RxBuffer = (u8 *)&I2C_Mag;
		460	I2C_RxBufferSize = sizeof(I2C_Mag);
		461	I2C_TxBuffer = NULL;
		462	I2C_TxBufferSize = 0;
		463	break;
		464	case I2C_CMD_READ_HEADING:
		465	I2C_RxBuffer = (u8 *)&I2C_Heading;
		466	I2C_RxBufferSize = sizeof(I2C_Heading);
		467	I2C_TxBuffer = (u8 *)&I2C_WriteAttitude;
		468	I2C_TxBufferSize = sizeof(I2C_WriteAttitude);
		469	// update attitude from spi rx buffer
		470	VIC_ITCmd(SSP0_ITLine, DISABLE); // avoid spi buffer update during copy
		471	I2C_WriteAttitude.Roll = FromFlightCtrl.AngleRoll;
		472	I2C_WriteAttitude.Nick = FromFlightCtrl.AngleNick;
		473	VIC_ITCmd(SSP0_ITLine, ENABLE);
		474	break;
		475	default: // unknown command id
		476	I2C_RxBuffer = NULL;
		477	I2C_RxBufferSize = 0;
		478	I2C_TxBuffer = NULL;
		479	I2C_TxBufferSize = 0;
		480	break;
		481	}
		482	// set direction to master transmitter
		483	I2C_Direction = I2C_MODE_TRANSMITTER;
		484	// test on busy flag and clear it
		485	I2C_CheckEvent( I2C1, I2C_FLAG_BUSY );
		486	// enable I2C IRQ again
		487	VIC_ITCmd(I2C1_ITLine, ENABLE);
		488	// initiate start condition on the bus
		489	I2C_GenerateStart(I2C1, ENABLE);
		490	// to be continued in the I2C1_IRQHandler() above
		491	} // EOF I2C_State == I2C_IDLE
		492	else // I2C_State != I2C_IDLE
		493	{
		494	// re-enable I2C IRQ again
		495	VIC_ITCmd(I2C1_ITLine, ENABLE);
		496	}
41	ingob	497	}
1	ingob	498
41	ingob	499	//----------------------------------------------------------------
		500	void I2C1_GetMK3MagVersion(void)
		501	{
78	holgerb	502	u8 msg[64];
154	killagreg	503	u8 repeat;
149	killagreg	504	u32 timeout;
150	killagreg	505
154	killagreg	506	UART1_PutString("\r\n Getting Version from MK3MAG");
		507	// stop polling of other commands
150	killagreg	508	I2C_StopPolling = 1;
1	ingob	509
41	ingob	510	MK3MAG_Version.Major = 0xFF;
		511	MK3MAG_Version.Minor = 0xFF;
		512	MK3MAG_Version.Patch = 0xFF;
		513	MK3MAG_Version.Compatible = 0xFF;
150	killagreg	514	// polling of version info
154	killagreg	515	repeat = 0;
		516	do
41	ingob	517	{
79	killagreg	518	I2C1_SendCommand(I2C_CMD_VERSION);
154	killagreg	519	timeout = SetDelay(250);
		520	do
		521	{
		522	if (MK3MAG_Version.Major != 0xFF) break; // break loop on success
		523	}while (!CheckDelay(timeout));
		524	UART1_PutString(".");
		525	repeat++;
		526	}while ((MK3MAG_Version.Major == 0xFF) && (repeat < 12)); // 12*250ms=3s
		527	// if we got it
41	ingob	528	if (MK3MAG_Version.Major != 0xFF)
79	killagreg	529	{
154	killagreg	530	sprintf(msg, "\r\n MK3MAG V%d.%d%c", MK3MAG_Version.Major, MK3MAG_Version.Minor, 'a' + MK3MAG_Version.Patch);
110	killagreg	531	UART1_PutString(msg);
41	ingob	532	sprintf(msg, " Compatible: %d", MK3MAG_Version.Compatible);
110	killagreg	533	UART1_PutString(msg);
41	ingob	534	}
154	killagreg	535	else UART1_PutString("\n\r No version information from MK3Mag.");
150	killagreg	536
154	killagreg	537	I2C_StopPolling = 0; // enable polling of heading command
146	killagreg	538	}
1	ingob	539
146	killagreg	540
		541	//----------------------------------------------------------------
		542	void I2C1_UpdateCompass(void)
		543	{
		544	static u32 TimerCompassUpdate = 0;
		545
154	killagreg	546	if( (I2C_State == I2C_OFF) \|\| I2C_StopPolling ) return;
149	killagreg	547
		548	if(CheckDelay(TimerCompassUpdate))
146	killagreg	549	{
149	killagreg	550	// check for incomming compass calibration request
		551	// update CalByte from spi input queue
		552	fifo_get(&CompassCalcStateFiFo, (u8 *)&(I2C_WriteCal.CalByte));
		553	// send new calstate
		554	if(I2C_ReadCal.CalByte != I2C_WriteCal.CalByte)
146	killagreg	555	{
149	killagreg	556	I2C1_SendCommand(I2C_CMD_WRITE_CAL);
146	killagreg	557	}
149	killagreg	558	else // request current heading
		559	{
		560	I2C1_SendCommand(I2C_CMD_READ_HEADING);
		561	}
195	killagreg	562	TimerCompassUpdate = SetDelay(20); // every 20 ms are 50 Hz
146	killagreg	563	}
1	ingob	564	}

Subversion Repositories NaviCtrl

(root)/tags/V0.24b/i2c.c @ 811 - Rev 228