1: /************************** 2: * Arlotto 23 01 04 3: * Dialogue i2c avec le SFR08 4: * Quartz à 4 Mhz 5: * 6: ****************************/ 7: #include 8: #include "biosdem.h" 9: /******************************** 10: * 11: * Notation : 12: * S : start , rS : Repeated Start, St : Stop 13: * AdW : @ i2c en écriture ex : E0 14: * AdR : @ i2c en lecture ex : E1 15: * DWx : donnée écrite n° x 16: * DRx : donnée lue n° x 17: ** Principe de l'échange : 18: * Envoi de la demande de ranging : S E0 00 51 St 19: * ^ ^ 20: * positionne le pointeur @module en 0 21: * (Ecriture @i2c E0 à @module 0 (cmd register) de la valeur 0x51 (cm) 22: * Attente de 70 ms (65mini) 23: * Lecture à partir de l'@module 2 : S E0 02 rS E1 dh dl St 24: * ^ ^ 25: * positionne le pointeur @module en 2 26: * Conclusion : 27: * Avec avoir positionné le pointeur d'@module en X par une séquence 28: * de la forme S AdW X on peut : 29: * - soit continuer l'écriture qui se fait alors 30: * à partir de l'adresse module X en continuant à envoyer des données et en 31: * terminant par un St : Ex : S AdW X DW0 DW1 DW2 ... St 32: * - soit faire une lecture en inversant le sens de transfert sans libérer 33: * le bus par un rS suivi de AdR et d'autant de lectures que l'on veut suivies d'un St 34: * Ex : S AdW X rS AdR DR0 DR1 DR2 ... St 35: * A priori le pointeur X conserve sa valeur et une séquence de lecture 36: * de la forme S AdR DR0 DR1 ... St devrait démarrer la lecture à partir 37: * de la valeur de X positionner par la lecture/écriture précédente (non vérifié). 38: */ 39: int read_distance(void) 40: { 41: char dh,dl; 42: int d ; 43: SEN = 1; // send start bit 44: while(SEN); // and wait for it to clear 45: ACKDT = 0; // acknowledge bit 46: 47: ACKSTAT=1; 48: SSPIF = 0; 49: SSPBUF = 0xE0; // 11100000 - write command 50: while(!SSPIF); // wait for interrupt 51: SSPIF = 0; 52: #ifdef __DEBUG_SONAR 53: ACKLED=!ACKSTAT; 54: ACKSTAT=1; 55: #endif 56: SSPIF = 0; 57: SSPBUF = 0x00; // adress of cmd register 58: while(!SSPIF); // wait for interrupt 59: SSPIF = 0; 60: #ifdef __DEBUG_SONAR 61: ACKLED=!ACKSTAT; 62: ACKSTAT=1; 63: #endif 64: SSPIF = 0; 65: SSPBUF = 0x51; // start ranging cm result 66: while(!SSPIF); // wait for interrupt 67: SSPIF = 0; // then clear it. 68: #ifdef __DEBUG_SONAR 69: ACKLED=!ACKSTAT; 70: ACKSTAT=1; 71: #endif 72: PEN = 1; // send stop bit 73: while(PEN); // 74: 75: DelayMs(70); // wait 65ms mini 76: 77: SEN = 1; // send start bit 78: while(SEN); // and wait for it to clear 79: ACKDT = 0; // acknowledge bit 80: 81: ACKSTAT=1; 82: SSPIF = 0; 83: SSPBUF = 0xE0; // 11100000 - write command 84: while(!SSPIF); // wait for interrupt 85: SSPIF = 0; 86: #ifdef __DEBUG_SONAR 87: ACKLED=!ACKSTAT; 88: ACKSTAT=1; 89: #endif 90: SSPIF = 0; 91: SSPBUF = 0x02; // adress of 1st Echo register 92: while(!SSPIF); // wait for interrupt 93: SSPIF = 0; 94: #ifdef __DEBUG_SONAR 95: ACKLED=!ACKSTAT; 96: ACKSTAT=1; 97: #endif 98: 99: RSEN = 1; // send start bit 100: while(RSEN); // and wait for it to clear 101: SSPIF = 0; 102: SSPBUF = 0xE1; // 11000001 - read command 103: while(!SSPIF); // wait for interrupt 104: SSPIF = 0; // then clear it. 105: 106: RCEN = 1; // start receiving 107: while(!STAT_BF); // wait for data 108: dh = SSPBUF; // and get it 109: ACKEN = 1; // start acknowledge sequence 110: while(ACKEN); // wait for ack. sequence to end 111: 112: RCEN = 1; // start receiving 113: while(!STAT_BF); // wait for data 114: dl = SSPBUF; // and get it 115: ACKDT=1; // very important ?? 116: ACKEN = 1; // start acknowledge sequence 117: while(ACKEN); // wait for ack. sequence to end 118: 119: PEN = 1; // send stop bit 120: while(PEN); // 121: d = (dh<<8) + dl ; 122: return d ; 123: }