Arrays Syntax

Maik15

Neues Mitglied
06. Sep. 2009
55
0
0
Sprachen
Hallo zusammen

Kann es sein das die „C“ Syntax bei Objektorientierter Programmierung anders ist???

Code:
char file2[16] 	 = {0xFA,0x89,0x11,0x23,0xAA,0x02,0x00,0x1F,	
 				0x1D,0xBA,0xA6,0x24,0x99,0x2D,0x1E,0x1F};

Was soll den daran falsch sein?
Aber Studio 4 meckert mal wieder
../VDIP_1.c:63: error: two or more data types in declaration specifiers

gruß
Maik
 
Hallo Maik,

ich sehe jetzt keinen Fehler. Kannst du mal ein bisschen mehr Code posten, der eigentliche Fehler liegt bestimmt irgendwo in der Nähe.

Dirk
 
Hier ist mal der Code
mittlerweile sind es nur noch 26 Fehler und 14 Warnungen.

Kann das sein das die Funktionsnamen zu lang sind?
Da bekomm ich immer diese Meldung
../VDIP_1.c:361: error: stray '\337' in program

Und bei dem Original Code wurde der SCLK dem Pin 6 vom Port1 zugewiesen
#define SCLK P1_6
Aber das will mein Studio so nicht unterstützen.
Wie macht man das denn Richtig?

gruß
Maik

Code:
//************************************************************************
// ATmega644 zu VDIP1 über SPI
//************************************************************************

#include <avr/io.h>
#include <string.h>						// Stringfunktion
#include <stdio.h>						// Standartfunktion
#include <stdlib.h>
//#include <conio.h>
//#include <delay.h>						// Pausenfuktion

//************************************************************************
// Definebereich VDIP1
//************************************************************************
#define SCLK        P1_6							// SCLK   Port 1 Pin 6  Taktsignal			vom VDIP1
#define SDI         P1_7							// SDI    Port 1 Pin 7	Serial Daten Input  vom VDIP1
#define SDO         P1_5							// SDO    Port 1 Pin 5	Serial Daten Output vom VDIP1
#define CS_VDIP     P1_0							// CS_VNC Port 1 Pin 0	Chip Select Input	vom VDIP1
#define RE_VDIP     P1_1							// RE_VNC Port 1 Pin 1	Hardware Reset 		vom VDIP1


//************************************************************************
// Statische Variablen
//************************************************************************
static char 			vdip1_check 	= 0x02;		// 1 = Prüfung Programmier-Port und Fehlermeldungen
													// 2 = Prüfung nur Programmier-Port
													// verwendet in main zum aufruf "vdip1_prüfe_anwesenheit"

static char vdip1_Programmier_Port_ok 	= 0x01;		// verwendet in main zum überprüfen des zustandes des VDIP1 Moduls
													// verwendet in "vdip1_bin_file_bescheiben"

//static char				vdip1_check		= 0x01;		// verwendet in "vdip1_bin_file_bescheiben" Zustandsabfrage

static char				file_neu		= 0x00;		// Neue Datei erzeugen 
static char 			file_erweitern 	= 0x01;		// Inhalt an Datei anhängen
													// verwendet in main bei Datenablage VDIP1 Modul 
													// neue Datei erzeugen oder in Datei ablegen


//************************************************************************
// Global veränderbare Variablen
//************************************************************************
volatile char lese_buffer[10];       					// Empfangsbuffer (10Byte groß)
														// verwendet in der Funktion "vdip1_byte_lesen"

volatile char sende_buffer[20];      					// Sendebuffer    (20Byte groß)


volatile char vdip1_status;               				// Status Bit für die Empfangs-Daten
														// verwendet in der Funktion "vdip1_byte_lesen"

//************************************************************************
// Binärer Datensätz für VDIP1
//************************************************************************

char file2[] 	 = {0xFA,0x89,0x11,0x23,0xAA,0x02,0x00,0x1F,	
	  				0x1D,0xBA,0xA6,0x24,0x99,0x2D,0x1E,0x1F,
  					0x0D,0x0C,0xA0,0x55,0x30,0x1F,0x16,0xEF,
  					0x04,0x22,0x00,0x00,0xCF,0x12,0x5F,0xDF,
  					0x69,0x00,0x00,0x1F,0xEF,0x15,0x3F,0xCF,
  					0x5F,0x44,0x1F,0x1F,0xBF,0x16,0x13,0x7F,
  					0x00,0x10,0x1F,0xDF,0x1F,0x8F,0x16,0xDF,
  					0x1F,0x32,0x3F,0x56,0x1F,0x19,0x17,0xFF,
  					0x3F,0x42,0xFE,0x46,0x6F,0x99,0x10,0xAF,
  					0x6F,0x62,0x36,0x66,0x10,0xAA,0xBB,0xCC};


//************************************************************************
// Funktionen Deklaration
//************************************************************************
void vdip1_init(void);											// VDIP1 Initialisierung
void vdip1_byte_lesen(char);									// aus VDIP1 ein Byte lesen
char vdip1_pr(char);											// VDIP1 Prüfen
char vdip1_byte_schreiben(char);								// VDIP1 Byte schreiben
void vdip1_cmd_schreiben(char);									// VDIP1 Befehl schreiben
void vdip1_bin_file_bescheiben(char, char, int); 				// in VDIP1 ein Binäre Datei beschreiben
void vdip1_txtfile_schreiben(char, char, char); 				// in VDIP1 eine Textdatei schreiben

//************************************************************************
// Hauptprogramm
//************************************************************************
int main (void) 
...
...
..
 
Ich konnte alles bis main() fehlerfrei kompilieren, conio.h habe ich nicht, habe es dann nicht eingebunden.

Hmmm, jetzt bin ich auch ratlos.
 
Die Fehler werden immer in den Funktionen gemeldet.
../VDIP_1.c:170: error: 'P1_5' undeclared (first use in this function)

Und bezieht sich auf die einzelnen Aufrufe wie zB. CS_VDIP
Code:
void vdip1_init(void) 
	{
  		CS_VDIP  = 0;    						// SPI-Interface inaktiv
	  	SCLK     = 0;    						// Ruhezustand der SPI-Leitungen herstellen
  		SDI      = 1;						// RW-Bit (0=Write)
  		SDO      = 0;				//*****************
  		RE_VDIP  = 0;    						// Hardware-Reset VNC1L
  		delay_ms(100); 						// Pause
  		RE_VDIP  = 1;    						// VNC1L starten
	}

Wenn ich die Kanäle zB. CS_VDIP über
#define CS_VDIP PortB; 0
zuweise werden aus 24Fehler 56.
Hab ich da schon wieder was falsch gemacht



Und was ist das für ein Fehler
../VDIP_1.c:369: error: stray '\337' in program

Die Fehler kommen bei Funktionsnamen wie hier zB.
Code:
void vdip1_bin_file_bescheiben(char *filename, char *fileinhalt, int groeße)

Ich wollt eigentlich das ganze Programm einfügen aber das sprengt die Zeichengrenze der Beiträge.

gruß
Maik
 
Hallo Maik,

du kann den Soucecode ja vielleicht mal an einen Beitrag anhängen. Wenn es sich um mehrere Files handelt, dann am besten vorher ein Zip-Archiv erstellen.

Ich kann mal versuchen, den Code bei mir zu kompilieren, vielleicht finde ich ja etwas.

Grüße,
Dirk
 
Ich teile mal das Programm.
So müsste es jetzt eigentlich klappen.

Teil 1
Code:
//************************************************************************
// ATmega644 zu VDIP1 über SPI
//************************************************************************


#include <avr/io.h>
#include <string.h>									// Stringfunktion
#include <stdio.h>									// Standartfunktion
#include <stdlib.h>
//#include <conio.h>
//#include <delay.h>								// Pausenfuktion


//************************************************************************
// Definebereich VDIP1
//************************************************************************
#define SCLK 	P1_6 	// SCLK Port 1 Pin 6 Taktsignal vom VDIP1 
#define SDI 	P1_7 	// SDI Port 1 Pin 7 Serial Daten Input vom VDIP1 
#define SDO 	P1_5 	// SDO Port 1 Pin 5 Serial Daten Output vom VDIP1 
#define CS_VDIP P1_0 	// CS_VNC Port 1 Pin 0 Chip Select Input vom VDIP1 
#define RE_VDIP P1_1 	// RE_VNC Port 1 Pin 1 Hardware Reset vom VDIP1 

/*
#define SCLK    P1_1	//(PortB, 0);							// SCLK   Port 1 Pin 6  Taktsignal			vom VDIP1
#define SDI     P1_2	//(PortB, 1);							// SDI    Port 1 Pin 7	Serial Daten Input  vom VDIP1
#define CS_VDIP	P1_3	//(PortB, 2);							// CS_VNC Port 1 Pin 0	Chip Select Input	vom VDIP1
#define RE_VDIP P1_4	//(PortB, 3);							// RE_VNC Port 1 Pin 1	Hardware Reset 		vom VDIP1
#define SDO     P1_5	//(PortB, 4);							// SDO    Port 1 Pin 5	Serial Daten Output vom VDIP1
*/

//************************************************************************
// Statische Variablen
//************************************************************************
static char 			vdip1_check 	= 0x02;		// 1 = Prüfung Programmier-Port und Fehlermeldungen
													// 2 = Prüfung nur Programmier-Port
													// verwendet in main zum aufruf "vdip1_prüfe_anwesenheit"

static char vdip1_Programmier_Port_ok 	= 0x01;		// verwendet in main zum überprüfen des zustandes des VDIP1 Moduls
													// verwendet in "vdip1_bin_file_bescheiben"

//static char				vdip1_check		= 0x01;		// verwendet in "vdip1_bin_file_bescheiben" Zustandsabfrage

static char				file_neu		= 0x00;		// Neue Datei erzeugen 
static char 			file_erweitern 	= 0x01;		// Inhalt an Datei anhängen
													// verwendet in main bei Datenablage VDIP1 Modul 
													// neue Datei erzeugen oder in Datei ablegen


//************************************************************************
// Global veränderbare Variablen
//************************************************************************
volatile char lese_buffer[10];       				// Empfangsbuffer (10Byte groß)
													// verwendet in der Funktion "vdip1_byte_lesen"

volatile char sende_buffer[20];      				// Sendebuffer    (20Byte groß)


volatile char vdip1_status;               			// Status Bit für die Empfangs-Daten
													// verwendet in der Funktion "vdip1_byte_lesen"

//************************************************************************
// Binärer Datensätz für VDIP1
//************************************************************************

char file2[] 	 = {0xFA,0x89,0x11,0x23,0xAA,0x02,0x00,0x1F,	
	  				0x1D,0xBA,0xA6,0x24,0x99,0x2D,0x1E,0x1F,
  					0x0D,0x0C,0xA0,0x55,0x30,0x1F,0x16,0xEF,
  					0x04,0x22,0x00,0x00,0xCF,0x12,0x5F,0xDF,
  					0x69,0x00,0x00,0x1F,0xEF,0x15,0x3F,0xCF,
  					0x5F,0x44,0x1F,0x1F,0xBF,0x16,0x13,0x7F,
  					0x00,0x10,0x1F,0xDF,0x1F,0x8F,0x16,0xDF,
  					0x1F,0x32,0x3F,0x56,0x1F,0x19,0x17,0xFF,
  					0x3F,0x42,0xFE,0x46,0x6F,0x99,0x10,0xAF,
  					0x6F,0x62,0x36,0x66,0x10,0xAA,0xBB,0xCC};


//************************************************************************
// Funktionen Deklaration
//************************************************************************
void vdip1_init(void);											// VDIP1 Initialisierung
void vdip1_byte_lesen(char);									// aus VDIP1 ein Byte lesen
char vdip1_pr(char);											// VDIP1 Prüfen
char vdip1_byte_schreiben(char);								// VDIP1 Byte schreiben
void vdip1_cmd_schreiben(char);									// VDIP1 Befehl schreiben
void vdip1_bin_file_bescheiben(char, char, int); 				// in VDIP1 ein Binäre Datei beschreiben
void vdip1_txtfile_schreiben(char, char, char); 				// in VDIP1 eine Textdatei schreiben

//************************************************************************
// Hauptprogramm
//************************************************************************
int main (void) 
	{
		vdip1_init();     											// VNC1L-Initialisierung
		
		DDRB = 0x0F;												// PortB die oberen 4 Bit als eingang die unteren 4 Bit als Ausgang
//***************************
  // Hauptschleife
//***************************
  	while(1) 														// Endlosschleife
  		{	
			char vdip1_ok = 0x00;
			char batch 	  = 0x00;

			vdip1_ok = vdip1_pr(vdip1_check);			// VDIP1 Zustand abfragen

    		if ( vdip1_ok == vdip1_Programmier_Port_ok)				// Prüfung auf Programmier Port Zustand
				{ 													// VDIP1 Zustand OK und kann jetzt neue Kommandos annehmen
      				
      				switch (batch) 														// Batchprozess
						{ 
        					case 0: vdip1_cmd_schreiben("ECS"); 						// Erweiterte Kommando Set einstellen
                					break;	
								
							case 1: vdip1_cmd_schreiben("IPA"); 						// Alle Zeichen werden als ASCII Zeichen gesendet
                					break;
        
							case 2: vdip1_cmd_schreiben("FWV"); 						// FWV Firmwareversion anzeigen
                					break;
								
							case 3: vdip1_cmd_schreiben("DIR");							// Anzeige des USB_Stick inhaltes
                					break;
								
					//		case 4: vdip1_txtfile_schreiben("VNCFILE1.TXT",file1[0],file_neu);    // Textfile auf USB-Stick erzeugen
                	//				break;
								
        
					//		case 5: vdip1_txtfile_schreiben("VNCFILE1.TXT",file1[0],file_erweitern); // gleiches Textfile auf USB-Stick anhängen
                	//				break;
									
        
							case 6: vdip1_bin_file_bescheiben("VNCFILE2.BIN",file2,80);	 // Binärfile auf USB-Stick erzeugen
                					break;
							
        
					//		case 7: vnc_rd_file("VNCFILE1.TXT",test_buffer,20);          // File (Teil) von USB-Stick in Speicher einlesen
                	//				break;
      					}
      
	  				delay_ms(1000); 													 // Pause
      				batch++;        													 // nächster Schritt
      				
					if (batch == 8) 
						{
							batch = 3; 													 // Funktionen wiederholen für Testzwecke
						}
    			}
  		}
	return 0;
	}
 
Teil 2
Code:
//************************************************************************
// Funktionen (Unterprogramme)
//************************************************************************


// ***********************************************************************
// VDIP1 - USB HOST CONTROLLER - SPI-MODE (µC: Master, VDIP1: SLAVE)
// VDIP1: Jumper-Set: J3 - Pulldown / J4 - Pullup
//        VDAP Firmware muss installiert sein, mit Version 3.66 getestet
// ***********************************************************************

// ***********************************************************************
// VDIP1 - Intialisierung SPI-Interface für VDIP1 über SPI Mode
// ***********************************************************************
void vdip1_init(void) 
	{
  		CS_VDIP  = 0;    							// SPI-Interface inaktiv
	  	SCLK     = 0;    								// Ruhezustand der SPI-Leitungen herstellen
  		SDI      = 1;								// RW-Bit (0=Write)
  		SDO      = 0;				//*****************
  		RE_VDIP  = 0;    							// Hardware-Reset VNC1L
  		delay_ms(100); 								// Pause
  		RE_VDIP  = 1;    							// VNC1L starten
	}


// ***********************************************************************
// VDIP1 1Byte auslesen

// Übergabe: lese_funktion 0=Datenbyte, 1=Statusbyte
// Rückgabe: Datenbyte/Statusbit über die Globale VDIP1_Status Variable
// ***********************************************************************
void vdip1_byte_lesen(char lese_funktion) 
	{
		char daten;									// Daten definieren
		char stelle;								// Stelle definieren

		daten   = 0;									// definierter Start
		stelle  = 0;									// definierter Start

  		CS_VDIP = 1;           						// SPI-Interface aktiv
		SDI     = 1;           						// Startbit
		SCLK    = 1; 									// L/H/L Flanke
  		SCLK    = 0; 									// L/H/L Flanke
		SDI     = 1;           						// RW-Bit (1=Read)
  		SCLK    = 1; 									// L/H/L Flanke
  		SCLK    = 0; 									// L/H/L Flanke
  
  		if (lese_funktion)
  			{ 
  				SDI = 1;							// wenn lese Funkton !=0 dann Statusbyte lesen
			} 
  		else
  			{ 
  				SDI = 0; 							// ansonsten Daten lesen
  			}
		
		SCLK = 1; 										// L/H/L Flanke
		SCLK = 0; 										// L/H/L Flanke

//------------------------------------------------------------------------
 
		for ( stelle = 0x80; stelle; stelle >> 1 )	// 8 Datenbits empfangen (MSB zuerst)
			{
    			if (SDO) 
					{
						daten |= stelle;			// wenn SD0 == 1 dann verodere Daten mit Stelle
    				}

				SCLK = 1; 								// L/H/L Flanke
				SCLK = 0; 								// L/H/L Flanke		
  			}
//------------------------------------------------------------------------
  // Statusbit einlesen
  	vdip1_status = SDO;     						// Statusbit (0=Neue Daten, 1=alte Daten)
  	SCLK    = 1; 										// L/H/L Flanke
	SCLK    = 0; 										// L/H/L Flanke
//------------------------------------------------------------------------
  // End Sequenz
  	CS_VDIP = 0;           							// SPI-Interface inaktiv
  	SCLK    = 1; 										// L/H/L Flanke
	SCLK    = 0; 										// L/H/L Flanke
  	SDO     = 1;           	//*******				// Datenlatch freigeben (8051-Spezifik)
  	
	if (vdip1_status == 0)							// empfangenes Zeichen ist ein neues Zeichen
		{
    		for ( stelle = 9; stelle; stelle-- ) 	// Empfangsbuffer um eine Stelle verschieben
				{
					lese_buffer[stelle] = lese_buffer[stelle - 1];
    			}

			lese_buffer[0] = daten; 				// neues Zeichen an 1. Stelle speichern
  		}
	} 

//************************************************************************
// von VDIP1 Auf Antwortstring warten und analysieren

// Übergabe: 1 = Prüfung auf Programmier-Port und Fehlermeldungen
//           2 = Prüfung nur auf Programmier-Port
// Rückgabe: 1 = Programmier-Port empfangen
//           2 = Kommando File empfangen
//************************************************************************
char vdip1_pr(char buffer_check) 
	{
		char antw = 0;
  		
		while(1) 
			{
    			vdip1_byte_lesen(0); 								// Ein Zeichen per SPI von VNC1L lesen (0) == Daten lesen
    			
				switch (buffer_check) 
					{
        				case 1: 									// Kommando File
                			if ((lese_buffer[2] == 'l') && (lese_buffer[1] == 'e') && (lese_buffer[0] == 'd')) 
								{
									antw = 2;						
																	// kein break; hier!!!
                				}			
        				case 2: 									// nur Prompt Check
                			if ((lese_buffer[2] == 0x5C) && (lese_buffer[1] == '>') && (lese_buffer[0] == 0x0D)) 
								{
                  													// Test auf \> und CR war ok
                  					antw = 1;
                  					lese_buffer[0] = 0; 			// lese Buffer letzes Zeichen löschen
                				}
    				}
    	
				if (antw == 2)
					{
						vdip1_byte_schreiben(0x0D); 				// zusätzliches CR um Fehler zu bestätigen, 
																	// dann kommt wieder ein Programmier Port Test
					}

    			if (antw) 							//********		//??? while ende???
					{
						break;
  					}
			}
  	return antw;
	}


// ***********************************************************************
// VNC1L - Senden eines Zeichens im SPI Mode

// Übergabe: daten:		Auszugebendes Zeichen
// Rückgabe: statusbit:	0= OK 	
//						1= nicht OK
// ***********************************************************************
char vdip1_byte_schreiben(char daten) 
	{
		char stelle;
		char status;

  		CS_VDIP = 1;									// SPI-Interface aktiv
  		SDI     = 1;           						// Startbit (immer 1)
		SCLK    = 1; 									// L/H/L Flanke
		SCLK    = 0; 									// L/H/L Flanke
  		SDI     = 0;           						// RW-Bit (0=Write)
		SCLK    = 1; 									// L/H/L Flanke
		SCLK    = 0; 									// L/H/L Flanke
  		SDI     = 0;           						// ADDR (0=Daten)
		SCLK    = 1; 									// L/H/L Flanke
		SCLK    = 0;									// L/H/L Flanke

 //------------------------------------------------------------------------
  // Datenbyte senden
  		for ( stelle = 0x80; stelle; stelle >> 1 ) 	// 8 Datenbits senden (MSB zuerst)
			{
    			SDI  = daten & stelle;				// Bitmaskierung (Bits einzelnt senden) 
    			SCLK = 1; 								// L/H/L Flanke
				SCLK = 0; 								// L/H/L Flanke
  			}	

 //------------------------------------------------------------------------
  // Statusbit einlesen
 		status = SDO;								// Statusbit (0=OK, 1=nicht OK)
  		SCLK   = 1; 									// L/H/L Flanke
		SCLK   = 0;										// L/H/L Flanke
  
  //------------------------------------------------------------------------
  // End Sequenz
  		CS_VDIP = 0;           						// SPI-Interface inaktiv
  		SCLK    = 1; 									// L/H/L Flanke
		SCLK    = 0;									// L/H/L Flanke
  		SDO     = 1;           //*********			// Datenlatch freigeben (8051-Spezifik)

	return status;
	} 

// ***********************************************************************
// VDIP1 - Senden eines Kommandos
// Übergabe: schreibe_cmd : Kommando (Adresse)
// ***********************************************************************
void vdip1_cmd_schreiben(char *schreibe_cmd) 
	{
		char i;
  		
		for(i = strlen(char*schreibe_cmd); i; i--) 	// Stringlänge an schleife übergeben
			{
    			vdip1_byte_schreiben(*schreibe_cmd);// Kommandobefehl ins VDIP1 schreiben
				schreibe_cmd ++;					// Kommandozeiger ++
  			}

  		vdip1_byte_schreiben(0x0D);					// Ende Zeichen
  		delay_ms(200); 								// Pause, um VDIP1 Zeit zur Antwort zu geben
	}




// ***********************************************************************
// VNC1L - Erzeugen eines Binär-Files auf dem USB-Stick
// Übergabe: filename   : Adresse des Filenamen
//           fileinhalt : Adresse des Datenblockes
//           groeße		: Anzahl der Bytes
// ***********************************************************************
void vdip1_bin_file_bescheiben(char *filename, char *fileinhalt, int groeße) 
	{
		int i;
		char batch = 0;
 
  		do 
			{
    			switch (batch) 													// Batchprozess
					{ 
      					case 0: sprintf (&sende_buffer[0],"OPW %s",filename);//********	// File Öffnen bzw. Erstellen
               					vdip1_cmd_schreiben(sende_buffer);
 	              				break;
      
	  					case 1:	vdip1_cmd_schreiben("SEK 0");  					// File Position immer auf Anfang setzen 
								break;											// (könnte man auch auf jede Pos. setzen!)
    	           			
	  					case 2: sprintf (&sende_buffer[0],"WRF %d",groeße);//**********	// File Byteanzahl
               					vdip1_cmd_schreiben(sende_buffer);
               				
								for(i = 0; i < groeße; i++) 
									{
                 						vdip1_byte_schreiben(*fileinhalt);
                 						fileinhalt++;
               						}
               					break;
      
	  					case 3: sprintf (&sende_buffer[0],"CLF %s",filename);//********	// File schließen
               					vdip1_cmd_schreiben(sende_buffer);
               					break;
    				}
    
				delay_ms(500); 													// Pause
		    	batch++;    													// nächster Schritt
    			
				if (batch == 4) 
					{
						return; 												// Fertig
  					}
  			} 

		while (vdip1_pr(vdip1_check) == vdip1_Programmier_Port_ok); // Prüfung auf VDIP1 Zustand
	}




// ***********************************************************************
// VNC1L - Erzeugen eines Text-Files auf dem USB-Stick
// Übergabe: filename   : Adresse des Filenamen
//           fileinhalt : Adresse des Textblockes
//           funktion   : File 0=Neu oder 1=Inhalt anhängen
// ***********************************************************************
void vdip1_txtfile_schreiben(char *filename, char *fileinhalt, char funktion) 
	{
		int  i;
		int  file_laenge;
		int  file_null;
		char *datenadresse;
		char batch   = 0;
		char abfrage = 0;
		char x;

		datenadresse = fileinhalt;			
  		file_laenge = 0;
  		file_null   = 0;
  		
		while (*datenadresse != 0xFF) 
			{
    			if (*datenadresse) 
					{
						file_laenge++;
					}
				 else 
				 	{
						file_null++;
					}

    			datenadresse++;
  			}
  // 1. Promptzeichen liegt bereits vor
  		do 
			{
    			switch (batch) 														// Batchprozess
					{ 
      					case 0: sprintf (&sende_buffer[0],"OPW %s",filename);//********	// File Öffnen bzw. Erstellen
               					vdip1_cmd_schreiben(sende_buffer);
               					break;
      
	  					case 1:  if (!funktion)										// File Position bei Bedarf auf Anfang setzen
									{
    	             					vdip1_cmd_schreiben("SEK 0");
										break;
            	   					}
								else 
									{
										batch++;  									// Nun wird sofort auch noch case 2: ausgeführt
      								}
									
						case 2: sprintf (&sende_buffer[0],"WRF %d",file_laenge);//******** // File Byteanzahl
               					vdip1_cmd_schreiben(sende_buffer);
               					datenadresse = fileinhalt;
               						
								for(i = 0; i < (file_laenge + file_null); i++) 
									{
                 						if (*datenadresse) 							// NULL-Terminierung ausblenden
											{	
												vdip1_byte_schreiben(*datenadresse); 		
                 							}

										datenadresse++;
               						}
               					break;
      
	  					case 3: sprintf (&sende_buffer[0],"CLF %s",filename);	//******** 	// File schließen
           						vdip1_cmd_schreiben(sende_buffer);
           						break;
    				} 																// Switch Klammer

				delay_ms(500); 														// Pause
    			batch++;    														// nächster Schritt
    			
				if (batch == 4) 
					{
						return; 													// Fertig
  					}
				x = vdip1_check;
				abfrage = vdip1_pr(x);
  			} 																		// do Klammer
  		while (abfrage == vdip1_Programmier_Port_ok);								// Prüfung auf nächstes Promptzeichen >
	}
 
Zur Erklärung das Programm soll Daten über eine SPI Schnittelle an ein VDIP1 Modul senden das die Daten (file2) auf einem USB-Stick speichert.

im Augenblick hab ich nicht nur die Fehler die ich nicht verstehe.
Sondern auch die sprintf Anweisung in den beiden Funktionen.
vdip1_bin_file_bescheiben
vdip1_txtfile_schreiben

Eigentlich soll die Anweisung an das VDIP Modul gesendet werden.
Aber über sprintf wird ja wahrscheinlich das Display angesteuert das es bei mir nicht gibt.

Ich bin für jede Hilfe dankbar.

gruß
Maik
 
Hallo Maik,

ändere vielleicht erst einmal den Sourcecode bezüglich der Portpins. Ich gehe davon aus, dass PortB richtig ist.
Alle Pinzugriffe in deinem Code so ändern, wie in der Routine vdip1_init



CodeBox C

//************************************************************************
// Definebereich VDIP1
//************************************************************************
#define CLR_SCLK PORTB &= ~(1<<PIN6) //P1_6 // SCLK Port 1 Pin 6 Taktsignal vom VDIP1
#define SET_SCLK PORTB |= (1<<PIN6)
#define CLR_SDI PORTB &= ~(1<<PIN7) //P1_7 // SDI Port 1 Pin 7 Serial Daten Input vom VDIP1
#define SET_SDI PORTB |= (1<<PIN7)
#define CLR_SDO PORTB &= ~(1<<PIN5) //P1_5 // SDO Port 1 Pin 5 Serial Daten Output vom VDIP1
#define SET_SDO PORTB |= (1<<PIN5)
#define CLR_CS_VDIP PORTB &= ~(1<<PIN0) //PORT1 // CS_VNC Port 1 Pin 0 Chip Select Input vom VDIP1
#define SET_CS_VDIP PORTB |= (1<<PIN0)
#define CLR_RE_VDIP PORTB &= ~(1<<PIN1) //P1_1 // RE_VNC Port 1 Pin 1 Hardware Reset vom VDIP1
#define SET_RE_VDIP PORTB |= (1<<PIN1)

// ...
// Alle Pinzugriffe in deinem Code so ändern, wie in der Routine vdip1_init
void vdip1_init(void)
{
CLR_CS_VDIP; // SPI-Interface inaktiv
CLR_SCLK; // Ruhezustand der SPI-Leitungen herstellen
SET_SDI; // RW-Bit (0=Write)
CLR_SDO; //*****************
CLR_RE_VDIP; // Hardware-Reset VNC1L
delay_ms(100); // Pause
SET_RE_VDIP; // VNC1L starten
}

 
Das ist natürlich auch eine Idee.
Danke erstmal.

Ich werd es gleich mal ausprobieren.

gruß
Maik
 
Hallo Dirk

So das hat erst mal funktioniert und wenn man groeße mit Doppel s schreibt.
Dann sind sograr lustige ; fehler und fehler '336' weg.

Ein Problem hab ich jetzt noch mit dem Delay


Und die sprintf Kommandos erzeugen noch eine menge an Warnungen.
Aber da schau ich noch der Arbeit mal nach ob ich die überhaupt brauche.

P.S. kann das sein das Fehler erst erkannt werden wenn die anderen behoben sind?

ich hatte ein fehler bei char und char*
da wurde kein Delayfehler erkannt

Zeigerfehler behoben Delayfehler da.
Muss man ja nicht verstehen oder?

Code:
//************************************************************************
// ATmega644 zu VDIP1 über SPI
//************************************************************************


#include <avr/io.h>
#include <string.h>									// Stringfunktion
#include <stdio.h>									// Standartfunktion
#include <stdlib.h>
//#include <conio.h>
//#include <delay.h>								// Pausenfuktion
#include <delay.h>

//************************************************************************
// Definebereich VDIP1
//************************************************************************
//*
#define R_SCLK    PORTB &= ~(1<<PIN0) 	//P1_0 		// SCLK 	Port 1 Pin 0 	Taktsignal 			für VDIP1
#define S_SCLK    PORTB |= (1<<PIN0)

#define R_RE_VDIP PORTB &= ~(1<<PIN1)  	//P1_1		// RE_VNC 	Port 1 Pin 1 	Hardware Reset 		für VDIP1
#define S_RE_VDIP PORTB |= (1<<PIN1)

#define R_CS_VDIP PORTB &= ~(1<<PIN2)  	//P1_2		// CS_VNC 	Port 1 Pin 2 	Chip Select Input 	vom VDIP1
#define S_CS_VDIP PORTB |= (1<<PIN2)

#define R_SDI     PORTB &= ~(1<<PIN3) 	//P1_3		// SDI 	 	Port 1 Pin 3 	Serial Daten Input 	vom VDIP1
#define S_SDI     PORTB |= (1<<PIN3)

#define SDO_VDIP   PINB &= (1<<PIN4) 	//P1_4		// SDO	 	Port 1 Pin 4 	Serial Daten Output vom VDIP1
		
//************************************************************************
// Statische Variablen
//************************************************************************
static char 			vdip1_check 	= 0x02;		// 1 = Prüfung Programmier-Port und Fehlermeldungen
													// 2 = Prüfung nur Programmier-Port
													// verwendet in main zum aufruf "vdip1_prüfe_anwesenheit"

static char vdip1_Programmier_Port_ok 	= 0x01;		// verwendet in main zum überprüfen des zustandes des VDIP1 Moduls
													// verwendet in "vdip1_bin_file_bescheiben"

static char				vdip1_ch		= 0x01;		// VDIP1_CECK 
													// verwendet in "vdip1_bin_file_bescheiben" Zustandsabfrage

static char				file_neu		= 0x00;		// Neue Datei erzeugen 
static char 			file_erweitern 	= 0x01;		// Inhalt an Datei anhängen
													// verwendet in main bei Datenablage VDIP1 Modul 
													// neue Datei erzeugen oder in Datei ablegen


//************************************************************************
// Global veränderbare Variablen
//************************************************************************
volatile char lese_buffer[10];       				// Empfangsbuffer (10Byte groß)
													// verwendet in der Funktion "vdip1_byte_lesen"

volatile char sende_buffer[20];      				// Sendebuffer    (20Byte groß)


volatile char vdip1_status;               			// Status Bit für die Empfangs-Daten
													// verwendet in der Funktion "vdip1_byte_lesen"

//************************************************************************
// Binärer Datensätz für VDIP1
//************************************************************************

char file2[] 	 = {0xFA,0x89,0x11,0x23,0xAA,0x02,0x00,0x1F,	
	  				0x1D,0xBA,0xA6,0x24,0x99,0x2D,0x1E,0x1F,
  					0x0D,0x0C,0xA0,0x55,0x30,0x1F,0x16,0xEF,
  					0x04,0x22,0x00,0x00,0xCF,0x12,0x5F,0xDF,
  					0x69,0x00,0x00,0x1F,0xEF,0x15,0x3F,0xCF,
  					0x5F,0x44,0x1F,0x1F,0xBF,0x16,0x13,0x7F,
  					0x00,0x10,0x1F,0xDF,0x1F,0x8F,0x16,0xDF,
  					0x1F,0x32,0x3F,0x56,0x1F,0x19,0x17,0xFF,
  					0x3F,0x42,0xFE,0x46,0x6F,0x99,0x10,0xAF,
  					0x6F,0x62,0x36,0x66,0x10,0xAA,0xBB,0xCC};


//************************************************************************
// Funktionen Deklaration
//************************************************************************
void vdip1_init(void);								// VDIP1 Initialisierung
void vdip1_byte_lesen(char);						// aus VDIP1 ein Byte lesen
char vdip1_pr(char);								// VDIP1 Prüfen
char vdip1_byte_schreiben(char);					// VDIP1 Byte schreiben
void vdip1_cmd_schreiben(char*);					// VDIP1 Befehl schreiben
void vdip1_bin_file_bescheiben(char*, char*, int); 	// in VDIP1 ein Binäre Datei beschreiben
void vdip1_txtfile_schreiben(char*, char*, char); 	// in VDIP1 eine Textdatei schreiben

//************************************************************************
// Hauptprogramm
//************************************************************************
int main (void) 
	{
		vdip1_init();     							// VNC1L-Initialisierung
		
		DDRB = 0x0F;								// PortB die oberen 4 Bit als eingang die unteren 4 Bit als Ausgang
//***************************
  // Hauptschleife
//***************************
  	while(1) 										// Endlosschleife
  		{	
			char vdip1_ok = 0x00;
			char batch 	  = 0x00;

			vdip1_ok = vdip1_pr(vdip1_check);		// VDIP1 Zustand abfragen

    		if ( vdip1_ok == vdip1_Programmier_Port_ok)		// Prüfung auf Programmier Port Zustand
				{ 											// VDIP1 Zustand OK und kann jetzt neue Kommandos annehmen
      				
      				switch (batch) 							// Batchprozess
						{ 
        					case 0: vdip1_cmd_schreiben("ECS"); 	// Erweiterte Kommando Set einstellen
                					break;	
								
							case 1: vdip1_cmd_schreiben("IPA"); 	// Alle Zeichen werden als ASCII Zeichen gesendet
                					break;
        
							case 2: vdip1_cmd_schreiben("FWV"); 	// FWV Firmwareversion anzeigen
                					break;
								
							case 3: vdip1_cmd_schreiben("DIR");		// Anzeige des USB_Stick inhaltes
                					break;
								
					//		case 4: vdip1_txtfile_schreiben("VNCFILE1.TXT",file1[0],file_neu);    // Textfile auf USB-Stick erzeugen
                	//				break;
								
        
					//		case 5: vdip1_txtfile_schreiben("VNCFILE1.TXT",file1[0],file_erweitern); // gleiches Textfile auf USB-Stick anhängen
                	//				break;
									
        
							case 6: vdip1_bin_file_bescheiben("FILE2.BIN", file2, 80);	 // Binärfile auf USB-Stick erzeugen
                					break;
							
        
					//		case 7: vnc_rd_file("VNCFILE1.TXT",test_buffer,20);          // File (Teil) von USB-Stick in Speicher einlesen
                	//				break;
      					}
      
	  				delay_ms(1000); //5													 // Pause
      				batch++;        													 // nächster Schritt
      				
					if (batch == 8) 
						{
							batch = 3; 													 // Funktionen wiederholen für Testzwecke
						}
    			}
  		}
	return 0;
	}

Hier noch mal mein Code.
Vielleicht kannst Du mir ja noch einen Tipp geben.

gruß
Maik
 
Teil 2

Code:
//************************************************************************
// Funktionen (Unterprogramme)
//************************************************************************


// ***********************************************************************
// VDIP1 - USB HOST CONTROLLER - SPI-MODE (µC: Master, VDIP1: SLAVE)
// VDIP1: Jumper-Set: J3 - Pulldown / J4 - Pullup
//        VDAP Firmware muss installiert sein, mit Version 3.66 getestet
// ***********************************************************************

// ***********************************************************************
// VDIP1 - Intialisierung SPI-Interface für VDIP1 über SPI Mode
// ***********************************************************************
void vdip1_init(void) 
	{
		R_CS_VDIP;    								// SPI-Interface inaktiv
		R_SCLK;    									// Ruhezustand der SPI-Leitungen herstellen
		S_SDI;										// RW-Bit (0=Write)
		R_RE_VDIP;    								// Hardware-Reset VNC1L
		delay_ms(100); 	//1							// Pause
		S_RE_VDIP;		    						// VNC1L starten
	}

// ***********************************************************************
// VDIP1 1Byte auslesen

// Übergabe: lese_funktion 0=Datenbyte, 1=Statusbyte
// Rückgabe: Datenbyte/Statusbit über die Globale VDIP1_Status Variable
// ***********************************************************************
void vdip1_byte_lesen(char lese_funktion) 
	{
		char daten;									// Daten definieren
		char stelle;								// Stelle definieren

		daten   = 0;									// definierter Start
		stelle  = 0;									// definierter Start
//------------------------------------------------------------------------
		S_CS_VDIP;									// SPI-Interface aktiv
		S_SDI;           							// Startbit
		S_SCLK; 										// L/H/L Flanke
		R_SCLK; 										// L/H/L Flanke
		S_SDI;           							// RW-Bit (1=Read)
		S_SCLK; 										// L/H/L Flanke
		R_SCLK; 										// L/H/L Flanke

  		if (lese_funktion)
  			{ 
  				S_SDI;								// wenn lese Funkton !=0 dann Statusbyte lesen
			} 
  		else
  			{ 
  				R_SDI; 								// ansonsten Daten lesen
  			}

		S_SCLK; 										// L/H/L Flanke
		R_SCLK;		 									// L/H/L Flanke
//------------------------------------------------------------------------
 
		for ( stelle = 0x80; stelle; stelle >> 1 )	// 8 Datenbits empfangen (MSB zuerst)
			{
    			if (SDO_VDIP) 
					{
						daten |= stelle;			// wenn SD0 == 1 dann verodere Daten mit Stelle
    				}

				S_SCLK; 								// L/H/L Flanke
				R_SCLK; 								// L/H/L Flanke		
  			}
//------------------------------------------------------------------------
  // Statusbit einlesen
  	vdip1_status = SDO_VDIP;     					// Statusbit (0=Neue Daten, 1=alte Daten)

	S_SCLK; 											// L/H/L Flanke
	R_SCLK; 											// L/H/L Flanke
//------------------------------------------------------------------------
  // End Sequenz
	R_CS_VDIP;           							// SPI-Interface inaktiv
	S_SCLK; 											// L/H/L Flanke
	R_SCLK;												// L/H/L Flanke

	if (vdip1_status == 0)							// empfangenes Zeichen ist ein neues Zeichen
		{
    		for ( stelle = 9; stelle; stelle-- ) 	// Empfangsbuffer um eine Stelle verschieben
				{
					lese_buffer[stelle] = lese_buffer[stelle - 1];
    			}

			lese_buffer[0] = daten; 				// neues Zeichen an 1. Stelle speichern
  		}
	} 

//************************************************************************
// von VDIP1 Auf Antwortstring warten und analysieren

// Übergabe: 1 = Prüfung auf Programmier-Port und Fehlermeldungen
//           2 = Prüfung nur auf Programmier-Port
// Rückgabe: 1 = Programmier-Port empfangen
//           2 = Kommando File empfangen
//************************************************************************
char vdip1_pr(char buffer_check) 
	{
		char antw = 0;
  		
		while(1) 
			{
    			vdip1_byte_lesen(0); 								// Ein Zeichen per SPI von VNC1L lesen (0) == Daten lesen
    			
				switch (buffer_check) 
					{
        				case 1: 									// Kommando File
                			if ((lese_buffer[2] == 'l') && (lese_buffer[1] == 'e') && (lese_buffer[0] == 'd')) 
								{
									antw = 2;						
																	// kein break; hier!!!
                				}			
        				case 2: 									// nur Prompt Check
                			if ((lese_buffer[2] == 0x5C) && (lese_buffer[1] == '>') && (lese_buffer[0] == 0x0D)) 
								{
                  													// Test auf \> und CR war ok
                  					antw = 1;
                  					lese_buffer[0] = 0; 			// lese Buffer letzes Zeichen löschen
                				}
    				}
    	
				if (antw == 2)
					{
						vdip1_byte_schreiben(0x0D); 				// zusätzliches CR um Fehler zu bestätigen, 
																	// dann kommt wieder ein Programmier Port Test
					}

    			if (antw) 							//********		//??? while ende???
					{
						break;
  					}
			}
  	return antw;
	}

// ***********************************************************************
// VNC1L - Senden eines Zeichens im SPI Mode

// Übergabe: daten:		Auszugebendes Zeichen
// Rückgabe: statusbit:	0= OK 	
//						1= nicht OK
// ***********************************************************************
char vdip1_byte_schreiben(char daten) 
	{
		char stelle;
		char status;
//------------------------------------------------------------------------
		S_CS_VDIP;									// SPI-Interface aktiv
		S_SDI;           							// Startbit (immer 1)
		S_SCLK; 										// L/H/L Flanke
		R_SCLK;											// L/H/L Flanke
		R_SDI;           							// RW-Bit (0=Write)
		S_SCLK; 										// L/H/L Flanke
		R_SCLK; 										// L/H/L Flanke
		R_SDI;           							// ADDR (0=Daten)
		S_SCLK; 										// L/H/L Flanke
		R_SCLK;											// L/H/L Flanke
 //------------------------------------------------------------------------
  // Datenbyte senden
  		for ( stelle = 0x80; stelle; stelle >> 1 ) 	// 8 Datenbits senden (MSB zuerst)
			{
    			if (daten & stelle)					// Datenbit übertragen		
    				{
						S_SDI;
					}
				else
					{
						R_SDI;
					}	
				S_SCLK;									// L/H/L Flanke
				R_SCLK;									// L/H/L Flanke

  			}	
 //------------------------------------------------------------------------
  // Statusbit einlesen
		status = SDO_VDIP;							// Statusbit (0=OK, 1=nicht OK)
		S_SCLK;											// L/H/L Flanke
		R_SCLK;											// L/H/L Flanke
  //------------------------------------------------------------------------
  // End Sequenz
  		R_CS_VDIP;									// SPI-Interface inaktiv
		S_SCLK;											// L/H/L Flanke
		R_SCLK;											// L/H/L Flanke

	return (status);
	} 

// ***********************************************************************
// VDIP1 - Senden eines Kommandos
// Übergabe: schreibe_cmd : Kommando (Adresse)
// ***********************************************************************
void vdip1_cmd_schreiben(char *schreibe_cmd) 
	{
		int i;
  		
		for(i = strlen(*schreibe_cmd); i; i--)		// Stringlänge an schleife übergeben
			{
    			vdip1_byte_schreiben(*schreibe_cmd);// Kommandobefehl ins VDIP1 schreiben
				schreibe_cmd ++;					// Kommandozeiger ++
  			}

  		vdip1_byte_schreiben(0x0D);					// Ende Zeichen
  		delay_ms(200); 	//2							// Pause, um VDIP1 Zeit zur Antwort zu geben
	}

// ***********************************************************************
// VNC1L - Erzeugen eines Binär-Files auf dem USB-Stick
// Übergabe: filename   : Adresse des Filenamen
//           fileinhalt : Adresse des Datenblockes
//           groeße		: Anzahl der Bytes
// ***********************************************************************
void vdip1_bin_file_bescheiben(char *filename, char *fileinhalt, int groesse)
	{
		int i;
		char batch = 0;
 
  		do 
			{
    			switch (batch) 													// Batchprozess
					{ 
      					case 0: sprintf (&sende_buffer[0],"OPW %s",filename);//********	// File Öffnen bzw. Erstellen
               					vdip1_cmd_schreiben(sende_buffer);
 	              				break;
      
	  					case 1:	vdip1_cmd_schreiben("SEK 0");  					// File Position immer auf Anfang setzen 
								break;											// (könnte man auch auf jede Pos. setzen!)
    	           			
	  					case 2: sprintf (&sende_buffer[0],"WRF %d",groesse);//**********	// File Byteanzahl
               					vdip1_cmd_schreiben(sende_buffer);
               				
								for(i = 0; i < groesse; i++) 
									{
                 						vdip1_byte_schreiben(*fileinhalt);
                 						fileinhalt++;
               						}
               					break;
      
	  					case 3: sprintf (&sende_buffer[0],"CLF %s",filename);//********	// File schließen
               					vdip1_cmd_schreiben(sende_buffer);
               					break;
    				}
    
				delay_ms(500); 	//4												// Pause
		    	batch++;    													// nächster Schritt
    			
				if (batch == 4) 
					{
						return; 												// Fertig
  					}
  			} 
		while (vdip1_pr(vdip1_ch) == vdip1_Programmier_Port_ok); 				// Prüfung auf VDIP1 Zustand
	}

// ***********************************************************************
// VNC1L - Erzeugen eines Text-Files auf dem USB-Stick
// Übergabe: filename   : Adresse des Filenamen
//           fileinhalt : Adresse des Textblockes
//           funktion   : File 0=Neu oder 1=Inhalt anhängen
// ***********************************************************************
void vdip1_txtfile_schreiben(char *filename, char *fileinhalt, char funktion) 
	{
		int  i;
		int  file_laenge;
		int  file_null;
		char *datenadresse;
		char batch   = 0;

		datenadresse = fileinhalt;			
  		file_laenge = 0;
  		file_null   = 0;
  		
		while (*datenadresse != 0xFF) 
			{
    			if (*datenadresse) 
					{
						file_laenge++;
					}
				 else 
				 	{
						file_null++;
					}

    			datenadresse++;
  			}

  		do 
			{
    			switch (batch) 														// Batchprozess
					{ 
      					case 0: sprintf (&sende_buffer[0],"OPW %s",filename);//********	// File Öffnen bzw. Erstellen
               					vdip1_cmd_schreiben(sende_buffer);
               					break;
      
	  					case 1:  if (!funktion)										// File Position bei Bedarf auf Anfang setzen
									{
    	             					vdip1_cmd_schreiben("SEK 0");
										break;
            	   					}
								else 
									{
										batch++;  									// Nun wird sofort auch noch case 2: ausgeführt
      								}
									
						case 2: sprintf (&sende_buffer[0],"WRF %d",file_laenge);//******** // File Byteanzahl
               					vdip1_cmd_schreiben(sende_buffer);
               					datenadresse = fileinhalt;
               						
								for(i = 0; i < (file_laenge + file_null); i++) 
									{
                 						if (*datenadresse) 							// NULL-Terminierung ausblenden
											{	
												vdip1_byte_schreiben(*datenadresse); 		
                 							}

										datenadresse++;
               						}
               					break;
      
	  					case 3: sprintf (&sende_buffer[0],"CLF %s",filename);	//******** 	// File schließen
           						vdip1_cmd_schreiben(sende_buffer);
           						break;
    				} 																// Switch Klammer

				delay_ms(500); 	//3													// Pause
    			batch++;    														// nächster Schritt
    			
				if (batch == 4) 
					{
						return; 													// Fertig
  					}
  			} 																		// do Klammer
  		while (vdip1_pr(vdip1_ch) == vdip1_Programmier_Port_ok);					// Prüfung auf nächstes Promptzeichen >
	}
 
Hi Maik,

P.S. kann das sein das Fehler erst erkannt werden wenn die anderen behoben sind?
am besten, du behebst immer den als erstes angezeigten Fehler und kompilierst jedesmal neu, oft wirkt sich das auf die folgenden angezeigten Fehler aus. Dein Programm schaue ich mir später nocheinmal an.

Könntest du den Sourcecode bitte mal als .zip oder .c anhängen, das kann man dann besser verarbeiten. Du machst das mit dem Button "Anhänge verwalten" unterhalb des Editors, wenn du einen Beitrag schreibst.

Grüße,
Dirk
 
So bin von der Arbeit zurück.

gruß
Maik
 

Anhänge

  • VDIP_1.c
    17,7 KB · Aufrufe: 0
So jetzt sind es nur noch 5 Delay Fehler und 3 dumme Warnungen.

Die Warnungen find ich erst mal nicht so schlimm.
Irgend was von nicht effektiv

Aber auch wieder ein Delay Warnung.
Ich weiß nicht bin ich vielleicht zu blöd für sowas einfaches wie Delay?

Init hab ich es mit
#include <util/delay.h>

Takt Definiert mit
#define F_CPU 1000000UL

und aufgerufen mit
delay_ms(1000);

Als Error bekomm ich im Augenblick undefiniertes Referenz 'delay ms'

So genug für Heute- (morgen) später geht es weiter.

gruß
Maik
 

Anhänge

  • VDIP_1.c
    19,1 KB · Aufrufe: 1
Hallo Maik,

ändere in deinem Programm überall

delay_ms(200);

in

_delay_ms(200);


Die Parameter natürlich beibehalten.

Grüße,
Dirk
 
Dank dir jetzt ist das Programm soweit erst mal Fehler frei.
Aber bei der Hardware wird noch keine Datei erzeugt.
Aber da muss ich mir noch mal in einer ruhigen Stunde die Abläufe anschauen.

DANKE noch mal

gruß
Maik
 

Über uns

  • Makerconnect ist ein Forum, welches wir ausschließlich für einen Gedankenaustausch und als Diskussionsplattform für Interessierte bereitstellen, welche sich privat, durch das Studium oder beruflich mit Mikrocontroller- und Kleinstrechnersystemen beschäftigen wollen oder müssen ;-)
  • Dirk
  • Du bist noch kein Mitglied in unserer freundlichen Community? Werde Teil von uns und registriere dich in unserem Forum.
  •  Registriere dich

User Menu

 Kaffeezeit

  • Wir arbeiten hart daran sicherzustellen, dass unser Forum permanent online und schnell erreichbar ist, unsere Forensoftware auf dem aktuellsten Stand ist und der Server regelmäßig gewartet wird. Auch die Themen Datensicherheit und Datenschutz sind uns wichtig und hier sind wir auch ständig aktiv. Alles in allem, sorgen wir uns darum, dass alles Drumherum stimmt :-)

    Dir gefällt das Forum und unsere Arbeit und du möchtest uns unterstützen? Unterstütze uns durch deine Premium-Mitgliedschaft!
    Wir freuen uns auch über eine Spende für unsere Kaffeekasse :-)
    Vielen Dank! :ciao:


     Spende uns! (Paypal)