Не съм записал нищо, което да вкарва D в i2c бизнеса, тъй като не знам, какво.

Предполагам - "I2C_slaveWriteData = D;" или "EEPROM_Buffer[0] =D;".......

Твоят код не можах да го натъкмя така, че компилаторът да не ме плюе Иначе той ми е доста по-разбираем в сравнение с това, което генерира MCC.

Странното е и това, че докато викам някоя от i2c функциите на master - ра, не виждам никакви признаци на живот по SCL или SDA линиите. Седят си високи и не мигват дори.

void main(void)
{
// initialize the device
SYSTEM_Initialize();
I2C_Initialize();
unsigned int D;
while (1)

{
RXbuffer_forslave_1=0xee;
I2C_MasterRead(RXbuffer_forslave_1,10,1,&statusReadSlave1);
while ((statusReadSlave1!=I2C_MESSAGE_COMPLETE)
&&
((statusReadSlave1!=I2C_MESSAGE_FAIL))
{ //////wait here

};

D=RXbuffer_forslave_1[0];
if(D==11)
LATA4=1;
if(D==0)
LATA4=0;
};



Не виждам да викаш I2C_Initialize();
Друг труден въпрос
void I2C_ISR ( void ) e дефинирана,
а другата само е "проектирана"
void I2C_BusCollisionISR( void )
{
// enter bus collision handling code here
}

Тези двете функции за прекъсване -кой ги вика? Къде в кода ти се споменават -
предполагам - щом са дадени имена с "ISR", трябва да имаш обработчик на
прекъсванията - който да ги вика,

По тоя повод, познат, старо куче програмист, препоръчва синтаксисът да е обърнат:
if (11==D)
Така, при изписване if (11=D), се получава съобщение за грешка, което няма как да не бъде забелязано, докато if (D=11) евентуално би генерирало уърнинг...

I2C_Initialize(); e в списъка на SYSTEM_Initialize();

void SYSTEM_Initialize(void)
{

PIN_MANAGER_Initialize();
OSCILLATOR_Initialize();
WDT_Initialize();
I2C_Initialize();
}

ISR функцията не се ли стартира от самото прекъсване за което има вдигнат флаг SSP1IE = 1?

За I2C_BusCollisionISR понятие си нямам

Благодаря за кода! Ще тествам и ще пиша резултата.

while (1)

{
RXbuffer_forslave_1=0xee;
I2C_MasterRead(RXbuffer_forslave_1,10,1,&statusReadSlave1);
while ((statusReadSlave1!=I2C_MESSAGE_COMPLETE)
&&
((statusReadSlave1!=I2C_MESSAGE_FAIL))
{ //////wait here

};

D=RXbuffer_forslave_1[0];
if(D==11)
LATA4=1;
if(D==0)
LATA4=0;
};

Това не ми го приема компилаторът. Мисля, че има една скоба в повече и я махнах, но пак не става.
Декларациите за RXbuffer_forslave_1 и statusReadSlave1 съм направил, като unsigned int. Не знам дали е правилно.

while ((statusReadSlave1!=I2C_MESSAGE_COMPLETE) && (statusReadSlave1!=I2C_MESSAGE_FAIL))
{
//////wait here
}

Защо се пъне компилаторът, ще го открия все някак. Важното е, че от последната насока на Стефан разбах значението на аргументите на функцията за четене и как да се отработва флага.

Благодаря, че ми помагате

Сега не ми се чете шита на твоя процесор,
но самата декларация на ISR функцията не указва нито, че е интеръпт-функция , нито за кой флаг се отнася .
Обвързаността флаг - функция (вектор по флаг).... я няма при всички МЦУта. Предполагам , че твоят проц има един - два вектора за прекъсване , при доста много потенциални източници . Тоест на кое да е прекъсване се вика една и съща функция - обработчик/хандлер.
Тоя обработчик(ти го пишеш) проверява възможните флагове за прекъсване и за съответен флаг - вика подходяща функция.
Тоест - всичко това го програмираш ти - и проверката на флаговете, и подходящите функции. В повечето случаи трябва да нулираш и флага, който предизвиква прекъсването - чрез директно нулиране флагХ=0.
Тези готови И2Ц конструкции ,които ползваш, са силно обвързани с прекъсванията.
Така че - време е да почетеш - как ,какво и кога става в проца при прекъсване. И как това се организира в твоята среда/компилатор.

В общи линии е неправилно и може оттам компилаторът да се сърди.
Функцията ще чете данни от тип байт, unsigned int - вероятно е двубайтов тип при тебе.
Ако със специални директиви за преобразувне на типа заобиколиш грешката,
то четецът ще запише два байта от слейва в един елемент на твоя масив от двубайтови числа.
После трябва работата с масива да е съобразена с това .
Възможно е , но трябва да имаш много специална причина да го направиш.
RXbuffer_forslave_1 трябва да е от типа uint8_t, а
statusReadSlave1 - от тип I2C_MESSAGE_STATUS.
Както е в декларацията на функцията.

Промених типовете, защото тез двата твои са специфични и им нямам дефинициите- иначе стандартен Ц компилатор щеше да се сърди


ПС.
Всъщност те излъгах. Доста приични може да има да ползваш преобразуване на тип.
Например слейвът изработва 5 резултата от 12битово АЦП- това са 10 байта.
И2Ц функцията може да достави тези 10 байта, тя е написана да достава байтове.
Така първите 2 байта може да ги прати в двубайтов елемент на масива ти от unsigned int.
После -
if (RXbuffer_forslave_2[0]>0x120) {......};
ще проверява коректно истински резултат от АЦП.
За да стане това - прочети за type casting.

Предполагам компилаторът се сърди, заради несъвпадение на типовете - от декларацията и от извикването.

Правилно предполагаш

Оправих декларациите, както каза:

uint8_t RXbuffer_forslave_1[];
I2C_MESSAGE_STATUS statusReadSlave1;

и компилаторът миряса.

Но комуникацията все още не работи.

Преработих while(1), както следва:

while (1)

{
RXbuffer_forslave_1[0]=0xee;
I2C_MasterRead(RXbuffer_forslave_1,10,1,&statusReadSlave1);


while ((statusReadSlave1!=I2C_MESSAGE_COMPLETE)
&&
(statusReadSlave1!=I2C_MESSAGE_FAIL))

{
//////wait here
}

LATA4=1;

}


само за да видя, докъде стига. LATA4 не се пали, т.е - мисля, че цикли на флаговете I2C_MESSAGE_COMPLETE и I2C_MESSAGE_FAIL.

В тази връзка, не разбирам, защо I2C_MESSAGE_COMPLETE е включено в условието? Не трябва ли да цикли само ако е вдигнат I2C_MESSAGE_FAIL?

Както и да е - пробвах и само с по едно от всяко от условията и пак цикли там.

Това, за прекъсванията ми е малко "тъмна Индия" и единствено знам, че въпросният пик е само с един вектор на прекъсване.

В тази връзка може би трябваше да покажа и това, което е генерирал MCC по въпроса:

За Master - а




и за Slave:

Да не би да трябва и функцията I2C_MasterReadTRBBuild() да се изпълнява в цикъла?

Пробвах да я вкарам там с някакви измислени аргументи (не знам, какви да и задам):



и така вече се забелязва нещо по шината:

Това ,което виждаш е нещо като старт/стоп.
MasterRead вика
...Build и ...Insert.
Както го разбрах - Insert задейства комуникцията и стои в очакване , докато не свърши обмена по някакъв начин.
Тоест просто викаш Read и после обработваш данните - няма нужда от while .
Защо обаче не тръгва - не можах да предположа.

uint8_t RXbuffer_forslave_1[10]; е по-правилно



void interrupt INTERRUPT_InterruptManager (void)
{

//сложи тукнякакво цъкане на някой порт - да видиш сосцилоскопа, че се вика тоя хандлер
// interrupt handler
if(INTCONbits.PEIE == 1
//тоя бит някой рзрешав ли го ???

Дадох прост пример с четенето на стойността на една променлива само за да наблегна върху същинския проблем - този с I2C комуникацията.
Може би сега е моментът да уточня, че всъщност е удачно при всяка транзакция да се четат блокове от байтове, вместо отделни байтове.

Накратко - идеята е някакъв master, който държи LCD индикация, да сканира малките пикове и да чете от тях по около 40 байта накуп за да ги визуализира.

uint8_t RXbuffer_forslave_1[];
е доста хай-текдекларация и трябва да знаеш защо я правиш. Струва ми се ,че не знаеш.

Не само ти се струва

Компилаторът упорито плюеше червени редове докато не сложих тези скоби.