PIC18F4550 (esclave) – OpenMV (maître) – mode lecture/ecriture – I2C

from pyb import I2C
import utime

i2c = I2C(2) # creation du bus I2C
i2c.init(I2C.MASTER, baudrate=100000) # initialisation du maître sur 100Khz

# 0x02 >> 1 : +1 bit à droite (décalage vers la gauche de l'adresse donne 0x04 pour PIC)
cAdrr = 0x02 >> 1
# si cAdrr = 0x02 côté cam OpenMV alors mettre cAdrr = 0x04 côté PIC18F4550 pour compatibilité !

utime.sleep_ms(500)# On attend un peu la fin de l'initialisation du bus I2C.

# Vérifie si l'esclave répond à cette adresse:
# -> renvoi True si l'esclave répond
# -> renvoi False si l'escalve ne répond pas
validation = i2c.is_ready(cAdrr)

if (validation == True):

    Buffer = bytearray(8)  # Création du Buffer (1 octet = 8bits)
    print("Nettoyage Buffer !! -> " + str(i2c.recv(Buffer,cAdrr)))

    while (True):

        # Ecriture
        i2c.send(0x00, addr = cAdrr)  # bit 0

        utime.sleep_ms(500) # -> Temp Min : utime.sleep_us(50)
        i2c.send(0x01, addr = cAdrr)  # bit 1

        utime.sleep_ms(500) # -> Temp Min : utime.sleep_us(50)
        i2c.send(0x02, addr = cAdrr)  # bit 2

        utime.sleep_ms(500) # -> Temp Min : utime.sleep_us(50)
        i2c.send(0x03, addr = cAdrr)  # bit 3

        utime.sleep_ms(500) # -> Temp Min : utime.sleep_us(50)
        i2c.send(0x04, addr = cAdrr)  # bit 4

        utime.sleep_ms(500) # -> Temp Min : utime.sleep_us(50)
        i2c.send(0x05, addr = cAdrr)  # bit 5

        utime.sleep_ms(500) # -> Temp Min : utime.sleep_us(50)
        i2c.send(0x06, addr = cAdrr)  # bit 6

        utime.sleep_ms(500) # -> Temp Min : utime.sleep_us(50)
        i2c.send(0x07, addr = cAdrr)  # bit 7

        # Lecture
        utime.sleep_ms(500) # -> Temp Min : utime.sleep_us(50)
        print(i2c.recv(Buffer,cAdrr))

        break # Supprimer "break" pour boucle en continue !

elif (validation == False):
    print("PIC 18F4550 non reconnu")

const cAdrr = 0x02; // cAdrr = 0x02 correspond à l'adresse de l'esclave
// Si cAdrr = 0x04 côté PIC alors mettre cAddr = 0x02 côté cam OpemMV pour compatibilité !

unsigned char iCount_Ecriture;
unsigned char iCount_Lecture;
unsigned char Data;
unsigned char VideBuffer;

// Tableau 2 dimensions pour envoyer donner vars cam OpenMV
unsigned char Buffer[8][1] = {
                                {0x00},  // bit 0
                                {0x00},  // bit 1
                                {0x00},  // bit 2
                                {0x00},  // bit 3
                                {0x00},  // bit 4
                                {0x00},  // bit 5
                                {0x00},  // bit 6
                                {0x00},  // bit 7
                              };

// Tableau 1 dimension pour envoyer donner vars cam OpenMV
//unsigned char Buffer[8] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07};

void interrupt() // On contrôle chaque interruptions
{
  if (PIR1.SSPIF == 1)
  {
    // SSPSTAT.R_W  -> bit0 = 1: Lecture  ou  bit0 = 0: Ecriture
    if (SSPSTAT.R_W == 1)
    {
      if (BF_bit == 1)
      {
        // Lecture -> Esclave vers Maître
        SSPBUF = Buffer[0][iCount_Lecture]; // Ajout Buffer pour lecture
        ++iCount_Lecture;
      }
    }
    else if (SSPSTAT.R_W == 0)
    {
      // Ecriture -> Maître vers Esclave
      Data = iCount_Ecriture >> 2;
      Buffer[0][Data] = SSPBUF; // On ajoute les données dans un tableau
      LATD = Buffer[0][Data]; // On affiche les données sur le PORTD
      ++iCount_Ecriture;
    }
  }

  SSPCON1.CKP = 1; // On relache l'horloge pour lancer la suite
  PIR1.SSPIF = 0;  // On remet à zéro le drapeau d'interruption et on attent la prochaine !
}


void init()
{

  ADCON1 = 0xFF;      // On configure toutes les broches en numérique (0 ou 1)

  ADCON0.ADON = 0;   // On désactive le module de convertisseur analogique numérique

  CMCON = 0x07;      // On désactive le mode comparateur

  ADCON1.VCFG0 = 0;  // Bien penser à desactiver les tensions de références !
  ADCON1.VCFG1 = 0;

  TRISA = 0xFF;      // Config Entrée PORTA -> (RA0 à RA7)
  PORTA = 0x00;
  LATA = 0x00;

  TRISB = 0x3F;      // Config les broches du PORTB - RB0 à RB5 comme entrée (SDA/SCL)
  PORTB = 0x00;
  LATB = 0x00;

  TRISD = 0x00;      // Config PORTD en sortie pour la lecture
  PORTD = 0x00;
  LATD = 0x00;

  TRISE = 0x00;      // Config MCLR
  PORTE = 0x00;
  LATE = 0x00;

  INTCON.GIE = 1;    // On active les interruptions globales 
  INTCON.PEIE = 1;   // On active les interruptions périphériques 
 
  PIE1.SSPIE = 1;    // On active le MSSP ( Module port série synch principal I2C ou SPI) 
  PIR1.SSPIF = 0;    // On met le drapeau d'interruption à zéro pour commencer 
 
  SSPCON1.SSPEN = 1; // On active les broches RB0 et RB1 en mode SDA et SCL
 
  // On active le mode 7 bits (0 à 7 = 8 bits) avec interruptions sur bit Start et Bit Stop 
  SSPCON1.SSPM0 = 0;
  SSPCON1.SSPM1 = 1;
  SSPCON1.SSPM2 = 1;
  SSPCON1.SSPM3 = 1;

  SSPADD = cAdrr;    // Configuration de l'adresse de l'esclave du PIC 18F4550

  SSPSTAT.SMP = 1;   //  vitesse de communication 100 Khz (standard)

  SSPCON2.SEN = 1;   // On active l'étirement de l'horloge

  SSPCON2.SEN = 1;   // On active l'étirement de l'horloge

  iCount_Ecriture = 0;

  iCount_Lecture = 0;

  Data = 0;

  VideBuffer = SSPBUF;  // On vide le Buffer correctement !

  Delay_ms(100);       // On attend un peu la fin de l'initialisation
}

void main()
{
  init(); // Initialisation du PIC18F4550

  while (1)
  {
    if ((P_bit == 1) && (Data >= 8))
    {
      iCount_Ecriture = 0;  // On remet à "0" le comptage de l'écriture
      iCount_Lecture = 0;   // On remet à "0" le comptage de lecture
      Data = 0;             // et on receommence le cycle !
      VideBuffer = SSPBUF;  // on vide correctement le Buffer !
    }

    if ((P_bit == 1) && (iCount_Lecture >= 8))
    {
      iCount_Ecriture = 0;  // On remet à "0" le comptage de l'écriture
      iCount_Lecture = 0;   // On remet à "0" le comptage de lecture
      Data = 0;             // et on receommence le cycle !
      VideBuffer = SSPBUF;  // on vide correctement le Buffer !
    }

    // Lecture du tableau et affichage des données sur le PORTD
    if (PORTA.B0 == 1){ LATD = Buffer[0][0]; }

    if (PORTA.B1 == 1){ LATD = Buffer[0][1]; }

    if (PORTA.B2 == 1){ LATD = Buffer[0][2]; }

    if (PORTA.B3 == 1){ LATD = Buffer[0][3]; }

    if (PORTB.B2 == 1){ LATD = Buffer[0][4]; }

    if (PORTB.B3 == 1){ LATD = Buffer[0][5]; }

    if (PORTB.B4 == 1){ LATD = Buffer[0][6]; }

    if (PORTB.B5 == 1){ LATD = Buffer[0][7]; }

  }
}