Sunteți pe pagina 1din 18

Universitatea Tehnică “Gheorghe Asachi” din Iași

Facultatea de Automatică și Calculatoare


Domeniul Ingineria Sistemelor
Specializarea Sisteme de control încorporate

PROIECT NOD 11
Reţele de sisteme încorporate

Masterand:
Măgdălini Andrei

Grupa 1B
Cuprins
1. Tema proiectului
2. Descrierea succintă a kitului și identificarea butoanelor (pinii la care
sunt conectate)
3. Programarea Timer-ului 0 (întrerupere la 1 ms)
4. Codul sursă și descrierea funcțiilor driverului MCO (mcohwSKCAN.c):
a. Structurile de date pentru accesul la registrele controlerului CAN
81C9x.
b. Funcția MCOHW_Init()
c. Funcția MCOHW_PushMessage ()
d. Funcția MCOHW_PullMessage ()
e. Funcția MCOHW_SetCANFilter ()
5. Codul sursă și descrierea funcțiilor aplicației (main_SKCAN,
user_SKCAN)
a. Funcția main ()
b. Funcția MCOUSER_ResetCommunication ()
6. Rezultate și concluzii Bibliografie
1. Tema proiectului

Pentru implementarea proiectului se va ține cont de specificațiile nodului


11.

Nodul 11
• adresa nod CANOpen = 11, viteza = 125 kbps, heartbeat la
1,5 secunde
• afişează pe LCD mesaje privind inițializarea plăcii și a stivei
MicroCANOpen
• transmite în rețea, folosind TPDO1, starea fiecărui buton (4
butoane – 4 octeți) (parametri TPDO1: ID implicit, time-
event=300ms, inhibit-time = 15ms)
• transmite în rețea, folosind TPDO2, două variabile de 16 biți
care se incrementează, una la fiecare 600 de pași, iar cealaltă
la fiecare 1000 de pași efectuați în bucla principală (infinită) a
programului (parametri TPDO2: ID implicit,
timeevent=275ms, inhibit-time = 75ms).
• afișează pe prima linie starea celor 4 butoane ale nodului 6,
primită prin intermediul RPDO1 (parametri RPDO1: ID egal
cu ID-ul TPDO1 al nodului 6).
• afișează pe a doua linie valoarea celor două variabile de 16
biți primite de la nodul 7 prin intermediul RPDO2 (parametri
RPDO2: ID egal cu ID-ul TPDO2 al nodului 7).
2. Descrierea succintă a kitului și identificarea butoanelor (pinii la
care sunt conectate)s

KitCON-CAN/LCD drom PHYTEC conține două controlere CAN 81C90


și 81C91, integrat pe placă găsim și un afișaj LCD cu memorie de 16
caractere, 8 LED-uri care pot fi conectate fie la portul 0 sau la portul 1 a
controlerului CAN sau pot fi conectate la portul 1 și la portul 3 de la
microcontroler.

Controlerul SAE 81C90 are două porturi paralele în plus față de SAE
81C91. SAE 81C80 poate să lucreze cu 16 obiecte de tip mesaj, unde
fiecare obiect poate fi definit să gestioneze cadre de date sau cadre de
cerere. Obiectele de la 0 la 7 au posibilitatea să memoreze un time-stamp
atunci când sunt folosite pentru recepție.

Alte facilități ale controlerului

• două tipuri de interfețe serială și paralelă (noi o folosim pe cea


paralelă);
• ieșiri configurabile ;
• unitate de verificare a transmisiei
• identificatori de mesaje care pot fi reconfigurați in timpul
funcționării;
• gestionare multiplă a sarcinilor de transmisie care vin de la
programul utilizatorului cu o singură comanda se poate genera
transmisia pe mai multe obiecte;
• clock programabil la ieșire;
• linie de întrerupere către controlerul gazdă.

Port.bit Buton
P5^7 B1
P5^6 B2
P5^1 B3
P5^0 B4
Identificarea butoanelor

3. Programarea Timer-ului 0 (întrerupere la 1 ms)

După generarea protocolului de cumunicație CAN generat cu


ajutorul programului DavE urmează configurarea Timer-ului 0.
Din meniul Timer-ului 0 selectăm 16-bit timer, îi spunem să ruleze
(Run Timer TR0) și validam întreruperea (Enable Timer 0 interrupt ET0).
Următorul pas este să mergem la meniul Functions și activăm funcția de
inițializare (T01_vInit) .
/**************************************************************************
DOES: Functia de intrerupere a timerului
Incrementeaza numaratorul global de milisecunde
Aceasta functie trebuie apelata o data la fiecare milisecunda
RETURNS: nimic
**************************************************************************/
void MCOHW_TimerISR
(
void
) interrupt 1
{

/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/
// stop timer 0
TR0 = 0;

#if (BOARDTYPE == SKCAN)


TH0 = 0xF9;
TL0 = 0x94; //0x8E; -adaugat "94" pt compensarea calculului la butoane
#endif
// start timer 0
TR0 = 1;
/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/
// incrementeaza contorul global
gTimCnt++;
}

• inițializare întrerupere timer 0

/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/
// initializare intrerupere T0
// MCOHW_TimerISR trebuie sa se execute la fiecare ms
// stop timer 0
TR0 = 0;
// mode 1
TMOD |= 1;
// reincarcare la 1ms pentru 10MHz, X2 mode
TH0 = 0xF9;
TL0 = 0x8E;

// start timer 0
TR0 = 1;
// enable timer 0
ET0 = 1;
/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/
// rezultatul initializarii
return baudrateok;
}

4. Codul sursă și descrierea funcțiilor driverului MCO


(mcohwSKCAN.c):

a. Structurile de date pentru accesul la registrele controlerului


CAN 81C9x.

#include <reg515C.h>
#include <mcohwSKCAN.h>

// Placa de dezvoltare suportata de acest driver


#define SKCAN 1 // SK-CAN board

// precizeaza tipul placii utilizate


#define BOARDTYPE SKCAN

// definesc offset-ul pentru CAN intern


#define CAN_OFFSET 0xFD00
// variabila globala timer/conter, incrementata la fiecare milisecunda
UNSIGNED16 MEM_NEAR gTimCnt = 0;

// Numara filtrele folosite(obiectele de tip mesaj CAN)


UNSIGNED8 MEM_FAR gCANFilter = 0;

#define CAN_OFFSET_81 0xFD00

struct can_con_81
{
UNSIGNED8 BL1; //Bit-length register
UNSIGNED8 BL2; //
UNSIGNED8 OC; //Output-control register
UNSIGNED8 BRPR; //Baud-rate prescaler
UNSIGNED8 RRR1; // marchiază obiectul care s-a primit
UNSIGNED8 RRR2;
UNSIGNED8 RIMR1; // regiștri de mascare a întreruperilor
// sau de validare pentru fiecare obiect in parte
UNSIGNED8 RIMR2;
UNSIGNED8 TRSR1; // regiștri transmitere comenzi de trimitere a fiecarui obiect
UNSIGNED8 TRSR2;
UNSIGNED8 IMSK; // registru de mascare general
UNSIGNED8 res0B;
UNSIGNED8 res0C; // spații libere neutilizate / locații rezervate dar trebuiesc puse
UNSIGNED8 res0D; // și acestea pentru a putea sări peste ele chiar dacă nu sunt folosite în
UNSIGNED8 res0E; // structura controlerului CAN
UNSIGNED8 res0F;

UNSIGNED8 MOD; //Mode/status register


UNSIGNED8 INT; //Interrupt register
UNSIGNED8 CTRL; //Control register
UNSIGNED8 res13; // un alt registru rezervat
UNSIGNED8 CC; //Clock-control register
UNSIGNED8 TCEC; //Transmit-check error counter
UNSIGNED8 TCD; //Transmit-check data register
UNSIGNED8 res17; //
UNSIGNED8 TRR1; //Transmit-request-reset register
UNSIGNED8 TRR2; //
UNSIGNED8 RRPR1; //Remote-request-pending register
UNSIGNED8 RRPR2; // registre în care sunt indicate mesaje tip cerere de la obiect
UNSIGNED8 TSCH; //Time-Stamp counter
UNSIGNED8 TSCL; // copierea bufferului de date
UNSIGNED8 res1E; //
UNSIGNED8 res1F; //

UNSIGNED8 res20; // locații neutilizate


UNSIGNED8 res21;
UNSIGNED8 res22;
UNSIGNED8 res23;
UNSIGNED8 res24; // locații neutilizate
UNSIGNED8 res25;
UNSIGNED8 res26; Registre care ține de cele două
UNSIGNED8 res27;
porturi (port 0 și port 1) cu
struct {
registrele care indică direcția,
UNSIGNED8 PDR; //port-direction register
starea pinului, starea latch-ului,
UNSIGNED8 PR; //pin register
UNSIGNED8 LR; //latch register încă unul care este rezervat. O
UNSIGNED8 resP; // structură în care putem accesa
}Port[2]; // ledurile .
struct {
UNSIGNED8 H; TRS [8] - cu doi octeți ( conțin
UNSIGNED8 L; valorile aferente primelor 8 obiecte
}TSR[8]; //Time-Stamp Register de la 0 la 7 )
struct {
UNSIGNED8 H; DR [16] - tot cu doi octeți ( conțin
UNSIGNED8 L; identificatorii celor 16 obiecte )
}DR[16]; //Descriptor Register
UNSIGNED8 res60_7F[32]; O zonă de locații neutilizate (32
struct { locații)
UNSIGNED8 Data[8];
O zonă de 128 de locații care conțin
}MsgObj[16]; //Data Register
datele (bufferele [8] de date care
}; fiecare conțin cele 16 obiecte).

#define CAN_CON ((struct can_con_81 volatile xdata *) (CAN_OFFSET_81)) //pointer la o


structură de memorie

b. Funcția MCOHW_Init()

/**************************************************************************
DOES: Initializeaza controlerul CAN.
CAUTION: Nu initializeaza filtrele - nimic nu se receptioneaza inca
RETURNS: 0 daca initializarea esueaza, 1 pentru succes
**************************************************************************/

UNSIGNED8 MCOHW_Init
(
UNSIGNED16 BaudRate // viteza dorita in kbps
)
{
// UNSIGNED8 i;
UNSIGNED8 baudrateok = 0;
/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/

// -------------- CAN Mode/Status Register ---------------


// start the initialization of the CAN Module
CAN_CON[0].MOD = 0x001;

// -------------- Output-Control Register ----------------


// Output Mode: Normal Mode
// TX0: The Output is driven directly with CAN data
// The high and low side transistor T0P/T0N are enable
// TX1: The Output is driven directly with CAN data
// The high and low side transistor T1P/T1N are enable
CAN_CON[0].OC = 0x0D8;

// --------------- CAN Control Register ------------------


CAN_CON[0].CTRL = 0x000;

// ---------------- Interrupt Register -------------------


CAN_CON[0].INT = 0x000; //reset all interrupt request bits
CAN_CON[0].IMSK = 0x000; //enable Receive Interrupt (Interrupt mask register) <====

CAN_CON[0].RRR1 = 0x000; //reset receive-Ready Register


CAN_CON[0].RRR2 = 0x000; // -"-
CAN_CON[0].RIMR1 = 0x000; //enable receive Bit Message 1 (Receive-Interrupt-Mask Register)
CAN_CON[0].RIMR2 = 0x000;

/// ------------ Bit Timing Register ---------------------


/// baudrate = 125.000 KBaud
/// there are 5 time quanta before sample point
/// there are 4 time quanta after sample point
/// the (re)synchronization jump width is 2 time quanta
CAN_CON[0].BL1 = 0x023;
CAN_CON[0].BL2 = 0x041;
CAN_CON[0].BRPR = 0x009;

gCANFilter=0;

// ================== Descriptor Registers ===============

// Message-Object 0
CAN_CON[0].DR[0].H = 0xFF;
CAN_CON[0].DR[0].L = 0x0E8;

// Message-Object 1
// This message operates as a data frame
// Identifier = 0x7
CAN_CON[0].DR[1].H = 0xFF;
CAN_CON[0].DR[1].L = 0x0E8;
// Message-Object 2-15
CAN_CON[0].DR[2].H = 0xFF;
CAN_CON[0].DR[2].L = 0x0E8;

CAN_CON[0].DR[3].H = 0xFF;
CAN_CON[0].DR[3].L = 0x0E8;

CAN_CON[0].DR[4].H = 0xFF;
CAN_CON[0].DR[4].L = 0x0E8;

CAN_CON[0].DR[5].H = 0xFF;
CAN_CON[0].DR[5].L = 0x0E8;

CAN_CON[0].DR[6].H = 0xFF;
CAN_CON[0].DR[6].L = 0x0E8;

CAN_CON[0].DR[7].H = 0xFF;
CAN_CON[0].DR[7].L = 0x0E8;

CAN_CON[0].DR[8].H = 0xFF;
CAN_CON[0].DR[8].L = 0x0E8;

CAN_CON[0].DR[9].H = 0xFF;
CAN_CON[0].DR[9].L = 0x0E8;

CAN_CON[0].DR[10].H = 0xFF;
CAN_CON[0].DR[10].L = 0x0E8;

CAN_CON[0].DR[11].H = 0xFF;
CAN_CON[0].DR[11].L = 0x0E8;

CAN_CON[0].DR[12].H = 0xFF;
CAN_CON[0].DR[12].L = 0x0E8;

CAN_CON[0].DR[13].H = 0xFF;
CAN_CON[0].DR[13].L = 0x0E8;

CAN_CON[0].DR[14].H = 0xFF;
CAN_CON[0].DR[14].L = 0x0E8;

CAN_CON[0].DR[15].H = 0xFF;
CAN_CON[0].DR[15].L = 0x0E8;

/// ------------ CAN Control/Status Register --------------


// reset INIT
// ...
CAN_CON[0].MOD = 0x000;
/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/
// initializare intrerupere T0
// MCOHW_TimerISR trebuie sa se execute la fiecare ms
// stop timer 0
TR0 = 0;
// mode 1
TMOD |= 1;
// reincarcare la 1ms pentru 10MHz, X2 mode
TH0 = 0xF9;
TL0 = 0x8E;

// start timer 0
TR0 = 1;
// enable timer 0
ET0 = 1;
/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/

// rezultatul initializarii
return baudrateok;
}

c. Funcția MCOHW_PushMessage ()

DOES: Transmite un mesaj CAN


RETURNS: 0 daca messajul nu a putut fi transmis, 1 daca mesajul a fost transmis
**************************************************************************/
UNSIGNED8 MCOHW_PushMessage
(
CAN_MSG MEM_FAR *pTransmitBuf // pointer la buffer-ul ce contine mesajul CAN de transmis
)
{
// Identificatorul mesajului CAN
UNSIGNED32 Identifier;
// numarul de octeti de date
UNSIGNED8 Length;
// contor local
char i;

// Pregateste DLC si ID-ul CAN


Length = pTransmitBuf->LEN;
Identifier = pTransmitBuf->ID;

/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/
// pune bitii CAN ID 0 - 10
CAN_CON[0].DR[gCANFilter].L = (Identifier<<5)| Length;
CAN_CON[0].DR[gCANFilter].H = (Identifier>>3)&(0xFF);

// pune datele in buffer-ul de transmisie


for (i=Length-1; i >= 0; i--)
{
CAN_CON[0].MsgObj[gCANFilter].Data[i] = pTransmitBuf->BUF[i];
}

CAN_CON[0].TRSR1=(1<<gCANFilter);

/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/

// mesaj transmis (s-a solicitat transmisia)


return 1;
}

d. Funcția MCOHW_PullMessage ()

DOES: Preia urmatorul mesaj CAN receptionat si il depune intr-un buffer de receptie
RETURNS: 0 daca nu s-a primit nici un mesaj, 1 daca mesajul primit a fost copiat in buffer
-corectat-
**************************************************************************/
UNSIGNED8 MCOHW_PullMessage
(
CAN_MSG MEM_FAR *pReceiveBuf // pointer la un buffer pentru un singur mesaj de stocat
)
{
// declaratii de variabile
UNSIGNED32 Identifier; // variabile locale pentru identificator
UNSIGNED8 Length; // variabile locale pentru lungime
UNSIGNED8 i,j, mask;
//testeaza obiectele de receptie definite
for (j=0, mask=0x01; j<gCANFilter; j++,mask=mask<<1) // începem de la j=0 deoarece obiectele
noastre încep cu 0 (de la 0 la 15)
{

/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/
// verifica daca a fost primit vreun mesaj (dacă există date în j)
if (((CAN_CON[0].RRR1) & mask) == mask)
{
// formeaza ID-ul mesajului si DLC
Identifier = (CAN_CON[0].DR[j].L>>5)|( CAN_CON[0].DR[j].H<<3);
Length = CAN_CON[0].DR[j].L & 0x0F; //Message configuration register

// pune CAN ID si DLC in bufferul aplicatiei


pReceiveBuf->ID = Identifier;
pReceiveBuf->LEN = Length;
// copie datele mesajului in bufferul aplicatiei
for (i=0; i<8; i++)
{
*(UNSIGNED8 *)(pReceiveBuf->BUF+7-i) = CAN_CON[0].MsgObj[j].Data[7-i];
}

CAN_CON[0].RRR1 &=(~mask);
//OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOO*/

// return 1 message received


return (1);
}
}

// return 0;//no message received


return (0);
}

e. Funcția MCOHW_SetCANFilter ()

DOES: Initializeaza urmatorul filtru disponibil


RETURNS: 0 pentru esec, 1 pentru succes
**************************************************************************/
UNSIGNED8 MCOHW_SetCANFilter
(
UNSIGNED16 CANID // identificatorul mesajului de receptionat
)
{

/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/
if ( gCANFilter > 12)
{

return 0;
}
// obiect disponibil
else
{
CAN_CON[0].DR[gCANFilter].L = (CANID<<5)|(0x08);
CAN_CON[0].DR[gCANFilter].H = (CANID>>3)&(0x0FF);

gCANFilter++;
return 1;
}

5. Codul sursă și descrierea funcțiilor aplicației (main_SKCAN,


user_SKCAN)

a. Funcția main ()

DOES: Functia main


RETURNS: nimic
**************************************************************************/
void main
(
void
)
{

/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/
// Reseteaza/Initializeaza SK-CAN
LCD_vInit();
LCD_vClear();
LCD_vDisplayString("Init SKCAN - Done");
/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO*/

// Reseteaza/Initializeaza communicatia CANopen


MCOUSER_ResetCommunication();
LCD_vClear();
LCD_vDisplayString("Init MCO - Done");

// Valideaza intreruperile
EAL = 1;

// Bucla infinita
while(1)
{
// Actualizeaza datele de proces
// Primele intrari numerice sunt citite de la switch-uri
// gProcImg[IN_digi_1] = read_dip_switches();

// Comanda primele iesiri digitale (pe led-uri)


// switch_leds(gProcImg[OUT_digi_1]);

LCD_vWrite_ubyteXY(0x00,0, gProcImg[OUT_digi_1]); //afișare catre LCD


LCD_vWrite_ubyteXY(0x04,0, gProcImg[OUT_digi_2]); //afișare catre LCD
LCD_vWrite_ubyteXY(0x08,0, gProcImg[OUT_digi_3]); //afișare catre LCD
LCD_vWrite_ubyteXY(0x0C,0, gProcImg[OUT_digi_4]); //afișare catre LCD

LCD_vUword2Hexstring ((gProcImg[OUT_ana_1] << 8) +


gProcImg[OUT_ana_1+1],buffer,4);
LCD_vDisplayStringPos(2,1,buffer);

LCD_vUword2Hexstring ((gProcImg[OUT_ana_1] << 8) +


gProcImg[OUT_ana_2+1],buffer,4);
LCD_vDisplayStringPos(2,8,buffer);

gProcImg[IN_digi_1]=b1_old; // valorile care trebuiesc luate în considerare


gProcImg[IN_digi_2]=b2_old;
gProcImg[IN_digi_3]=b3_old;
gProcImg[IN_digi_4]=b4_old;

counter++;
counter2++; // Am folosit două counter-uri deoarece cele doua volori nu sunt multiple
una față de celalaltă

if(counter % 600==0){
gProcImg[IN_ana_1+1]++; //octet mai puțin semnificativ
if (gProcImg[IN_ana_1+1]==0) // în urma depașirii
{
gProcImg[IN_ana_1]++; //implementare celălalt
}
counter=0;
}

if(counter2 % 1000==0){
gProcImg[IN_ana_2+1]++;
if (gProcImg[IN_ana_2+1]==0)
{
gProcImg[IN_ana_2]++;
}
counter2=0;
}

//trimite in ecou toate celelalte valori de la intrare la iesire

// digitale

gProcImg[IN_digi_1] = b1_old;
gProcImg[IN_digi_2] = b2_old;
gProcImg[IN_digi_3] = b3_old;
gProcImg[IN_digi_4] = b4_old;

if (( counter % 600) == 0)
{
gProcImg[IN_ana_1+1]++;
if( gProcImg[IN_ana_1+1] == 0)
{
gProcImg[IN_ana_1+1]++;
}
}

if (( counter2 % 1000) == 0)
{
gProcImg[IN_ana_2+1]++;
if( gProcImg[IN_ana_2+1] == 0)
{
gProcImg[IN_ana_2+1]++;
}
}

// analogice
// gProcImg[IN_ana_1] = gProcImg[OUT_ana_1];
// gProcImg[IN_ana_1+1] = gProcImg[OUT_ana_1+1];
// gProcImg[IN_ana_2] = gProcImg[OUT_ana_2];
// gProcImg[IN_ana_2+1] = gProcImg[OUT_ana_2+1];

// Lanseaza prelucarea specifica retelei CANOpen


MCO_ProcessStack();

} // end of while(1)
} // end of main
b. Funcția MCOUSER_ResetCommunication ()

DOES: Aceasta functie reseteaza si initializeaza controlerul CAN si stiva CANOpen.


Este apelata de catre stiva CANOpen, daca un mesaj NMT solicita resetarea
comunicatiei.
This function both resets and initializes both the CAN interface
Aceasta functie trebuie sa apeleze MCO_Init si MCO_InitTPDO/MCO_InitRPDO.
RETURNS: nothing
**************************************************************************/
void MCOUSER_ResetCommunication
(
void
)
{
UNSIGNED8 i;

EAL = 0;

// Initializeaza (cu 0) variabilele de proces


for (i = 0; i < PROCIMG_SIZE; i++)
{
gProcImg[i] = 0;
}

// 125kbit, Adresa nod, 1s heartbeat


MCO_Init(125,ADR_NOD,1500);

// RPDO1, default ID (0x200+nodeID), 4 octeti


MCO_InitRPDO(1,0x180+6,4,OUT_digi_1); //Primeste ID-ul TPDO1 al nodului 6

// RPDO2, default ID (0x300+nodeID), 4 octeti


MCO_InitRPDO(2,0x280+7,4,OUT_ana_1); //Primeste ID-ul TPDO2 al nodului 7

// TPDO1, default ID (0x180+nodeID), 100ms event, 0ms inhibit, 4 bytes


MCO_InitTPDO(1,0,300,15,4,IN_digi_1);

// TPDO2, default ID (0x280+nodeID), 1250ms event, 10ms inhibit, 4 bytes


MCO_InitTPDO(2,0,275,75,4,IN_ana_1);
}
6. Rezultate și concluzii Bibliografie

Bibliografie

• SAE 81C9x Datasheet


• CANopen specification
• Embedded Networking with CAN and CANopen
• ZigBee specification

Rezultate și concluzii

• codul a fost compilat fără erori;

• funcțiile de transmisie și recepție funcționează corect, transmit si


recepționează mesaje cu viteza de 125 kbps și heartbeat la 1,5
secunde;
• la apăsarea oricărui buton se incrementează o valoare care este
afișată pe LCD.