Delay_ns

Guten Tag erstmal.

Wir programmieren auf einen PIC 16F877A. Von diesem aus wollen wir diverse Daten auf ein EEPROM (M95256) f=5Mhz schreiben.

Also das Problem ist das ich keine Ahnung habe wie ich ein Delay_ns realisieren kann.Da unser Compiler dies nicht kennt und wir es brauchen (wegen der hohen Frequenz).

Hier sonst mal der Code:

int8 Read_memory(int16 adresse) //Interuptsubrroutine wird alle 1ms aufgerufen
{
bool Bit[7];
int8 Wert=0;

S=0; // S = Chip Select
if(C==1) // C = Clock
{
D=0; //
delay_ns(900); //
D=1; //
delay_ns(400); //

D=A15; //
delay_ns(200); //
D=A14; //
delay_ns(200); //
D=A13; //
delay_ns(200); //
D=A12; //
delay_ns(200); //
D=A11; //
delay_ns(200); //
D=A10; //
delay_ns(200); //
D=A9; //
delay_ns(200); //
D=A8; //
delay_ns(200); //
D=A7; //
delay_ns(200); //
D=A6; //
delay_ns(200); //
D=A5; //
delay_ns(200); //
D=A4; //
delay_ns(200); //
D=A3; //
delay_ns(200); //
D=A2; //
delay_ns(200); //
D=A1; //
delay_ns(200); //
D=A0; //
delay_ns(200); //

Bit[7]=Q;
delay_ns(200); //
Bit[6]=Q;
delay_ns(200); //
Bit[5]=Q;
delay_ns(200); //
Bit[4]=Q;
delay_ns(200); //
Bit[3]=Q;
delay_ns(200); //
Bit[2]=Q;
delay_ns(200); //
Bit[1]=Q;
delay_ns(200); //
Bit[0]=Q;

S=1; //

for(int i=0;i !=8 ;i++)
{
wert=bit[i];
wert==>wert;
}

return wert;
}

Ich würde ja sagen, das ist eine typische Timeraufgabe. Ich weiß nicht mehr sicher, welche Taktrate der Controller hat, aber wenn ich davon ausgehe, das er auf 20MHz (wenn ich mich recht entsinne) läuft müsstest du einen Timer mit Presc. 1 auf 4 Schritte programmieren. Dann hast du deine 5 MHz - ergo 200ns realisiert!

pointercrash**

Was Dir die <time.h> dazu anbietet, ist eindeutig zu grobschlächtig. Also entweder baust Du Dir einen Automaten, den Du per Timer- Interrupt z.B. alle 100 ns aufrufst:

switch (state) // 100 ns timer- Interrupt
		{
			case 0:	// start condition
				{
					if (c==1)
					{
						d = 0;
						count = 8;
					}		
				}
				break;
			case 1:	// Delay 900 ns, Init Sequence
				{
					if (count)
						count--;
					else
					{
						d = 1;
						count = 3;
						state = 2;
					}
				}
				break;

			case 2:	// Delay 400 ns, A15
				{
					if (count)
						count--;
					else
					{
						d = a15;
						count = 1;
						state = 3;
					}
				}
				break;

			case 3:	// ... usw.
				{
				}
				break;
		}

Wenn der PIC dafür zu langsam ist , mußt Du mit Leerschleifen das passende Timing basteln - andere Möglichkeiten sehe ich nicht.

EDIT: Schnellschüsse umpff, Die if- Abfragen solltest Du umbauen, aber das Prinzip ist klar, oder?

Hmm habe gerade bemerkt dass ein befehl 200ns dauert.. dann könnte ich es ja auch mit nopes machen oder nicht?

nur die nicht durch 200ns teilbaren werden ein Problem...

wieso brauchst du diese unterschiedlichen delays? normalerweise ist die clock-frequenz bei spi-geräten konstant. spi-transfer eines bytes über GPIOs könnte etwa so aussehen:

uint8_t spi_rxtx (uint8_t out) // 'out' ist das byte, das gesendet werden soll
{
  int s;
  uint8_t in = 0;              // 'in' ist der empfangene wert
  for (s=0; s<8; s++)          // schleife, bit0 ... bit7
  {
      mosi = !!(out & 0x80);   // höherwertigstes bit ausgeben 
      clock = 1;               // clock hoch
      delay (__const1);        // festes delay
      in |= miso;              // höherwertigstes bit einlesen
      clock = 0;               // clock runter
      delay (__const2);        // festes delay
      in <<= 1;                // eingelesene bits weiterschieben
      out <<= 1;               // ausgabewert weiterschieben
  }
  return in;                   // eingelesenen wert zurückgeben
}

^^ so kann man ein byte senden und empfangen. vor einer transaktion (also mehrere bytes) muss natürlich noch der /SS-pin auf 0 gezogen werden. die clockfrequenz errechnet sich hauptsächlich durch die delays und die laufzeit des restlichen codes. so wie der (pseudo)code da steht, ist er (glaube ich) für spi mode #1, also CPHA und CPOL = 0. für andere spi modes musste die position der zeilen mit 'miso' und 'mosi' in der schleife verschieben. wie es bei deinem chip genau ist, entnimmst du den timing-diagrammen im datenblatt.

btw, ich wette der PIC hat ein hardware-spi, dann kannst du dir das alles sowieso sparen

pointercrash**

Mit SPI hat aber pipois Code nichts zu tun, da würde die Clock fehlen. Dieser PIC hat tatsächlich eine Hardware- SPI. Wohl dem, der auch die Pins verwendet hat, die daran hängen.
Ein strammes Timing erfordert der 1- Wire- Bus von Dallas Semi, allerdings im Bereich der absoluten Gemütlichkeit und nicht bei Nanosekunden.

Schlage vor, poiupoi erzählt uns, was er wirklich machen will, so fehlt mir die Brücke zum Sinn

pointercrash() schrieb:

Mit SPI hat aber pipois Code nichts zu tun, da würde die Clock fehlen.

ich hab nur den namen seines EEPROMs bei google eingegeben, dann erscheint:

STMicroelectronics | 256 Kbit serial SPI bus EEPROM

aber stimmt schon, sein ursprünglicher code würde jeden SPI-slave kalt lassen.