קודם כל שלום לכלום.
בעזרת הארדויאנו שלי אני מנסה לכתוב ספרייה שכותבת או קוראת מכרטיס SD.
אני בכוונה מנסה לממש את זה בעצמי כי אני מאמין שאם אני עושה הכל בעצמי אני מבין.

אז אני מכיר את ארבעת ההדקים שבפרוטוקל הSPI ואת תפקידם. אני רוצה לשאול כמה שאלות:
1) האם SCK צריך להיות מופעל תמיד?
2) כאשר הSS / CS מקבל HIGH ה-Slave נחשב לפעיל או דווקא למכובה? התבלבלתי כי קראתי במקום מסוים ככה ובמקום שני אחרת.
3)מהו טווח התדרים שבו הארדואינו והכרטיס SD עובדים? אני מאמין שיש טווח רחב שבחלקו גם הארדויאנו תומך וגם כרטיס הSD.
4)שאלה שקשורה לתדרים:

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://img96.imageshack.us/img96/944/20500110.png]


Uploaded with ImageShack.us
האם התדר בתמונה הנ"ל הוא 5 הרץ?
5)בארדויאנו שלי יש X יציאות PWM, האם ע"י הוצאת HIGH/LOW בתדר מסויים ביציאה שהיא לא PWM אני בעצם יקבל את אותו האפקט? ניסתי זאת על לד והוא ואכן זה הצליח. מה שאני מנסה לשאול פה: אז מה ההבדל בעצם?

אם מישהו ממכם מכיר מקורות מידע טובים שאתם ממליצים עליהם ללמוד מהם את נושא הSPI, אשמח אם תשתפו אותי.
עריכה: אין לי בעיה עם מקורות באנגלית.

מצטער על כמות השאלות, פשוט אין לי את מי לשאול את הדברים האלו חוץ ממכם.
תודה רבה!

4. כן זה PWM בתדר 5 הרץ. בעל דיוטי סייקל של 50%.

5. לטעמי ( סורי אני לא סגור על זה לגמרי) ברגע שאתה נותן לפין "PWM" ערך הוא יתן את הפולסים בצורה מחזורית.ואח"כ אתה פנוי לפקודות אחרות. בעוד שלפין רגיל, אתה כל הזמן צריך לשחק למעלה למטה ואתה לא יכול לעשות שום דבר אחר.

3. תווך תדרים, של מי ? של מה.. אגב רק שתדע ששינוי פין מ היי ל לאו, (בארדיו בשפת "C" לוקח הרבה זמן ! לטעמי משהו כמו 60 מחזורי שעון ( קלוקים). אבל ניתן לשלב קוד אסמבלר ולעשות זאת במחזור אחד,גג שתיים.או אפילו לשנות כמה פינים בוא זמנית..מה שבשפת "C" ארדיוני לא ניתן לעשות.

2. עוד פעם אני לא סגור על זה לגמרי, אבל מה שקובע כאן, זה מול איזה רכיב אתה מדבר. תסתכל מה רשום בדף מפרט של הרכיב שאתה מנסה להפעיל.

1. לא.
2. תלוי ברכיב ה SLAVE. יש כאלו שפעילים ב H ואחרים שפעילים ב L.
3. לרוב תקשורת SPI פועלת בטווח של מאות קילוהרץ עד כמה מגהרץ. תלוי ביכולות ה MASTER ויכולות ה SLAVE (הנמוך מבינהם).

אתה לא יכול לתת סתם שעון מיציאת PWM שכן פיני ה DATA צריכים להיות מסונכרנים לשעון.
שתי דרכים אפשריות:
1. שימוש בחומרת SPI יעודית (במידה וקיימת בבקר שלך).
2. מימוש הפרוטוקול ע"י נדנוד פיני I/O באופן מסונכרן.

Elim

כמו שאמר ELIM, מצב ה SS/CSB תלוי ברכיב. לרוב בSPI הוא יהיה ACTIVE LOW, כלומר מתח נמוך בקו יפעיל את ה SLAVE.

לענ"ד תדר העבודה בSPI לא קריטי, כלומר יש תדר מקסימלי שהמעבד יכול להחליף מצבים בפורט אבל אין תדר מינימלי (השעון של הMASTER הוא היחיד שרלוונטי ובצד הSLAVE יש מכונת מצבים שמקבלת את הנתונים).

אם תשתמש באפיק SPI מובנה בבקר, הוא יוציא לך אות שעון מתוך מתנד פנימי.
אם תשתמש ביציאות דיגיטליות ע"י BIT-BANGING, תצטרך להוציא אות שעון בעצמך.

אם תצטרך עזרה במימוש אפיק SPI ע"י BIT-BANGING, אשמח לעזור. דוגמאות ב-C תוכל למצוא בחיפוש בגוגל.

"אני כותב על מה שאני יודע, וגם על מה שאני לא יודע."
את כל הנכתב יש לקחת בערבון מוגבל.

תודה רבה לכם, בניתי קוד (נעזרתי גם באינטרנט) שאמור לשלוח/לקבל מידע מהslave.
אין לי דרך לדעת אם מיממשתי את הפרוטוקול כמו שצריך מפני שאני לא יכול לבנות מחלקה שמטפלת בכרטיסי SD כשהיא נשענת על המחלקה SPI שלא בטוח עובדת.
אשמח לעזרה

קוד:

class SPI
{
	private:
	unsigned char	MOSI,
					MISO,
					SCK,
					CS;
					
	void CS_Enable()
	{
		digitalWrite(this->CS, HIGH);
	}
	
	void CS_Disable()
	{
		digitalWrite(this->CS, LOW);
	}
	
	
	public:
	SPI(unsigned char MOSI, unsigned char MISO, unsigned char SCK, unsigned char CS)
	{
		this->MOSI	= MOSI;
		this->MISO	= MISO;
		this->SCK	= SCK;
		this->CS	= CS;
		
		pinMode(MOSI, OUTPUT);
		pinMode(MISO, INPUT);
		pinMode(SCK, OUTPUT);
		pinMode(CS, OUTPUT);
	}
	
	void sendData(unsigned data)
	{
		unsigned char MSB = 0x80; /*Send data from MSB to LSB. 0x80 = 10000000b. */
		unsigned char i = 0;	/*Loops. */
		
		CS_Disable(); /*Activates the slave. When CS is low, the slave work. */
		
		for (i = 0; i < 8; ++i)
		{
			if ((data & 0x80) == 0x80)
			{
				digitalWrite(this->MOSI, HIGH);
			}
			else
			{
				digitalWrite(this->MOSI, LOW);
			}
			
			/*Send a clock pulse.*/
			digitalWrite(this->SCK, HIGH);
			digitalWrite(this->SCK, LOW);
			
			data = data << 1;
			
		}
		
		CS_Enable(); /*Turns off the slave. */
	}
	
	unsigned char receiveData()
	{
		unsigned char MSB = 0x80; /*Receive data from MSB to LSB. 0x80 = 10000000b. */
		unsigned char data = 0;
		unsigned char i = 0;	/*Loops. */

		CS_Disable(); /*Activates the slave. When CS is low, the slave work. */
		
		for (i = 0; i < 8; ++i)
		{
			/*Clock signal start. */
			digitalWrite(this->SCK, HIGH);
			
			if (digitalRead(this->MISO) == HIGH)
			{
				data += MSB;
			}
			
			MSB = MSB >> 1;
			
			/*Clock signal end. */
			digitalWrite(this->SCK, LOW);
		}

		
		CS_Enable(); /*Turns off the slave. */
		
		return data;
	}
};

SPI tmp(2, 5, 4, 3);

void setup()
{
	Serial.begin(9600);
}

void loop()
{
	tmp.sendData(0x40);
	Serial.println(tmp.receiveData());
}