bkinnightskytw
/
ethercat
mirror of https://gitlab.com/bkinnightskytw/ethercat.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Code-Dokumentation angepasst.

This commit is contained in:
Florian Pose 2006-02-28 11:10:57 +00:00
parent 59be77d01d
commit 42f8695d18
9 changed files with 113 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
master/canopen.c
View File

@ -115,7 +115,7 @@ int EtherCAT_rt_canopen_sdo_write(ec_slave_t *slave, /**< EtherCAT-Slave */
/*****************************************************************************/
/**
Schreibt ein CANopen-SDO (service data object).
Liest ein CANopen-SDO (service data object).
*/
int EtherCAT_rt_canopen_sdo_read(ec_slave_t *slave, /**< EtherCAT-Slave */
@ -202,6 +202,14 @@ int EtherCAT_rt_canopen_sdo_read(ec_slave_t *slave, /**< EtherCAT-Slave */
/*****************************************************************************/
/**
Schweibt ein CANopen-SDO (Variante mit Angabe des Masters und der Adresse).
Siehe EtherCAT_rt_canopen_sdo_write()
\return 0 wenn alles ok, < 0 bei Fehler
*/
int EtherCAT_rt_canopen_sdo_addr_write(ec_master_t *master,
/**< EtherCAT-Master */
const char *addr,
@ -223,6 +231,14 @@ int EtherCAT_rt_canopen_sdo_addr_write(ec_master_t *master,
/*****************************************************************************/
/**
Liest ein CANopen-SDO (Variante mit Angabe des Masters und der Adresse).
Siehe EtherCAT_rt_canopen_sdo_read()
\return 0 wenn alles ok, < 0 bei Fehler
*/
int EtherCAT_rt_canopen_sdo_addr_read(ec_master_t *master,
/**< EtherCAT-Slave */
const char *addr,

64
master/device.c
View File

@ -21,6 +21,8 @@
/**
EtherCAT-Geräte-Konstuktor.
\return 0 wenn alles ok, < 0 bei Fehler (zu wenig Speicher)
*/
int ec_device_init(ec_device_t *device, /**< EtherCAT-Gerät */
@ -52,7 +54,7 @@ int ec_device_init(ec_device_t *device, /**< EtherCAT-Ger
EtherCAT-Geräte-Destuktor.
Gibt den dynamisch allozierten Speicher des
EtherCAT-Gerätes (die beiden Socket-Buffer) wieder frei.
EtherCAT-Gerätes (den Sende-Socket-Buffer) wieder frei.
*/
void ec_device_clear(ec_device_t *device /**< EtherCAT-Gerät */)
@ -84,11 +86,6 @@ int ec_device_open(ec_device_t *device /**< EtherCAT-Ger
{
unsigned int i;
if (!device) {
EC_ERR("Trying to open a NULL device!\n");
return -1;
}
if (!device->dev) {
EC_ERR("No net_device to open!\n");
return -1;
@ -96,16 +93,16 @@ int ec_device_open(ec_device_t *device /**< EtherCAT-Ger
if (device->open) {
EC_WARN("Device already opened!\n");
return 0;
}
else {
// Device could have received frames before
for (i = 0; i < 4; i++) ec_device_call_isr(device);
// Reset old device state
device->state = EC_DEVICE_STATE_READY;
// Device could have received frames before
for (i = 0; i < 4; i++) ec_device_call_isr(device);
if (device->dev->open(device->dev) == 0) device->open = 1;
}
// Reset old device state
device->state = EC_DEVICE_STATE_READY;
if (device->dev->open(device->dev) == 0) device->open = 1;
return device->open ? 0 : -1;
}
@ -115,8 +112,8 @@ int ec_device_open(ec_device_t *device /**< EtherCAT-Ger
/**
Führt die stop()-Funktion des net_devices aus.
\return 0 bei Erfolg, < 0: Kein Gerät zum Schliessen oder
Schliessen fehlgeschlagen.
\return 0 bei Erfolg, < 0: Kein Gerät zum Schließen oder
Schließen fehlgeschlagen.
*/
int ec_device_close(ec_device_t *device /**< EtherCAT-Gerät */)
@ -146,25 +143,21 @@ int ec_device_close(ec_device_t *device /**< EtherCAT-Ger
uint8_t *ec_device_prepare(ec_device_t *device /**< EtherCAT-Gerät */)
{
// Clear transmit socket buffer and reserve space for Ethernet-II header
skb_trim(device->tx_skb, 0);
skb_reserve(device->tx_skb, ETH_HLEN);
skb_trim(device->tx_skb, 0); // Auf Länge 0 abschneiden
skb_reserve(device->tx_skb, ETH_HLEN); // Reserve für Ethernet-II-Header
// Erstmal Speicher für maximal langen Frame reservieren
// Vorerst Speicher für maximal langen Frame reservieren
return skb_put(device->tx_skb, EC_MAX_FRAME_SIZE);
}
/*****************************************************************************/
/**
Sendet einen Rahmen über das EtherCAT-Gerät.
Sendet den Inhalt des Socket-Buffers.
Kopiert die zu sendenden Daten in den statischen Socket-
Buffer, fügt den Ethernat-II-Header hinzu und ruft die
start_xmit()-Funktion der Netzwerkkarte auf.
\return 0 bei Erfolg, < 0: Vorheriger Rahmen noch
nicht empfangen, oder kein Speicher mehr vorhanden
Schneidet den Inhalt des Socket-Buffers auf die (nun bekannte) Größe zu,
fügt den Ethernet-II-Header an und ruft die start_xmit()-Funktion der
Netzwerkkarte auf.
*/
void ec_device_send(ec_device_t *device, /**< EtherCAT-Gerät */
@ -173,7 +166,7 @@ void ec_device_send(ec_device_t *device, /**< EtherCAT-Ger
{
struct ethhdr *eth;
// Framegroesse auf (jetzt bekannte) Laenge abschneiden
// Framegröße auf (jetzt bekannte) Länge abschneiden
skb_trim(device->tx_skb, length);
// Ethernet-II-Header hinzufuegen
@ -213,7 +206,7 @@ unsigned int ec_device_received(const ec_device_t *device)
/**
Gibt die empfangenen Daten zurück.
\return Adresse auf empfangene Daten.
\return Zeiger auf empfangene Daten.
*/
uint8_t *ec_device_data(ec_device_t *device)
@ -269,7 +262,7 @@ void ec_device_debug(const ec_device_t *device /**< EtherCAT-Ger
{
EC_DBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
ec_data_print(device->tx_skb->data + ETH_HLEN, device->tx_skb->len);
EC_DBG("------------------------------------------------\n");
EC_DBG("--------------------------------------\n");
ec_data_print_diff(device->tx_skb->data + ETH_HLEN, device->rx_data,
device->rx_data_size);
EC_DBG("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
@ -344,6 +337,8 @@ void EtherCAT_dev_state(ec_device_t *device, /**< EtherCAT-Ger
/**
Prüft, ob das Net-Device \a dev zum registrierten EtherCAT-Gerät gehört.
\return 0 wenn nein, nicht-null wenn ja.
*/
int EtherCAT_dev_is_ec(const ec_device_t *device, /**< EtherCAT-Gerät */
@ -355,7 +350,16 @@ int EtherCAT_dev_is_ec(const ec_device_t *device, /**< EtherCAT-Ger
/*****************************************************************************/
void EtherCAT_dev_receive(ec_device_t *device, const void *data, size_t size)
/**
Nimmt einen Empfangenen Rahmen entgegen.
Kopiert die empfangenen Daten in den Receive-Buffer.
*/
void EtherCAT_dev_receive(ec_device_t *device, /**< EtherCAT-Gerät */
const void *data, /**< Zeiger auf empfangene Daten */
size_t size /**< Größe der empfangenen Daten */
)
{
// Copy received data to ethercat-device buffer
memcpy(device->rx_data, data, size);

13
master/domain.c
View File

@ -62,7 +62,7 @@ void ec_domain_clear(ec_domain_t *domain /**< Dom
/**
Registriert ein Feld in einer Domäne.
\returns 0 bei Erfolg, < 0 bei Fehler
\return 0 bei Erfolg, < 0 bei Fehler
*/
int ec_domain_reg_field(ec_domain_t *domain, /**< Domäne */
@ -99,7 +99,12 @@ int ec_domain_reg_field(ec_domain_t *domain, /**< Dom
/*****************************************************************************/
/**
\returns 0 bei Erfolg, < 0 bei Fehler
Erzeugt eine Domäne.
Reserviert den Speicher einer Domäne, berechnet die logischen Adressen der
FMMUs und setzt die Prozessdatenzeiger der registrierten Felder.
\return 0 bei Erfolg, < 0 bei Fehler
*/
int ec_domain_alloc(ec_domain_t *domain, /**< Domäne */
@ -182,7 +187,7 @@ int ec_domain_alloc(ec_domain_t *domain, /**< Dom
*****************************************************************************/
/**
Registriert einer Domäne ein Datenfeld hinzu.
Registriert ein Datenfeld innerhalb einer Domäne.
\return Zeiger auf den Slave bei Erfolg, sonst NULL
*/
@ -258,7 +263,7 @@ ec_slave_t *EtherCAT_rt_register_slave_field(
/*****************************************************************************/
/**
Sendet und empfängt Prozessdaten der angegebenen Domäne
Sendet und empfängt Prozessdaten der angegebenen Domäne.
\return 0 bei Erfolg, sonst < 0
*/

2
master/frame.c
View File

@ -317,7 +317,7 @@ int ec_frame_send(ec_frame_t *frame /**< Rahmen zum Senden */)
/*****************************************************************************/
/**
Empfängt einen gesendeten Rahmen.
Wertet empfangene Daten zu einem Rahmen aus.
\return 0 bei Erfolg, sonst < 0
*/

19
master/master.c
View File

@ -112,8 +112,8 @@ void ec_master_clear_slaves(ec_master_t *master /**< EtherCAT-Master */)
/**
Öffnet das EtherCAT-Geraet des Masters.
\return 0, wenn alles o.k., < 0, wenn kein Gerät registriert wurde oder
es nicht geoeffnet werden konnte.
\return 0 wenn alles ok, < 0 wenn kein Gerät registriert wurde oder
es nicht geoeffnet werden konnte.
*/
int ec_master_open(ec_master_t *master /**< Der EtherCAT-Master */)
@ -151,9 +151,12 @@ void ec_master_close(ec_master_t *master /**< EtherCAT-Master */)
/*****************************************************************************/
/**
Durchsucht den Bus nach Slaves.
Durchsucht den EtherCAT-Bus nach Slaves.
@return 0 bei Erfolg, sonst < 0
Erstellt ein Array mit allen Slave-Informationen die für den
weiteren Betrieb notwendig sind.
\return 0 bei Erfolg, sonst < 0
*/
int ec_scan_for_slaves(ec_master_t *master /**< EtherCAT-Master */)
@ -234,7 +237,9 @@ int ec_scan_for_slaves(ec_master_t *master /**< EtherCAT-Master */)
/*****************************************************************************/
/**
Gibt von Zeit zu Zeit die Anzahl verlorener Frames aus.
Gibt die Anzahl verlorener Frames aus.
Die Ausgabe erfolgt gesammelt höchstens einmal pro Sekunde.
*/
void ec_output_lost_frames(ec_master_t *master /**< EtherCAT-Master */)
@ -426,7 +431,7 @@ ec_domain_t *EtherCAT_rt_master_register_domain(ec_master_t *master,
Konfiguriert alle Slaves und setzt den Operational-Zustand.
Führt die komplette Konfiguration und Aktivierunge aller registrierten
Slaves durch. Setzt Sync-Manager und FMMU's, führt die entsprechenden
Slaves durch. Setzt Sync-Manager und FMMUs, führt die entsprechenden
Zustandsübergänge durch, bis der Slave betriebsbereit ist.
\return 0 bei Erfolg, sonst < 0
@ -480,7 +485,7 @@ int EtherCAT_rt_master_activate(ec_master_t *master /**< EtherCAT-Master */)
// Check and reset CRC fault counters
ec_slave_check_crc(slave);
// Resetting FMMU's
// Resetting FMMUs
if (slave->base_fmmu_count) {
memset(data, 0x00, EC_FMMU_SIZE * slave->base_fmmu_count);
ec_frame_init_npwr(&frame, master, slave->station_address, 0x0600,

67
master/module.c
View File

@ -63,8 +63,8 @@ MODULE_PARM_DESC(ec_master_count, "Number of EtherCAT master to initialize.");
Initialisiert soviele Master, wie im Parameter ec_master_count
angegeben wurde (Default ist 1).
@returns 0, wenn alles o.k., -1 bei ungueltiger Anzahl Master
oder zu wenig Speicher.
\return 0 wenn alles ok, < 0 bei ungültiger Anzahl Master
oder zu wenig Speicher.
*/
int __init ec_init_module(void)
@ -140,23 +140,22 @@ void __exit ec_cleanup_module(void)
/**
Registeriert das EtherCAT-Geraet fuer einen EtherCAT-Master.
@param master_index Index des EtherCAT-Masters
@param dev Das net_device des EtherCAT-Geraetes
@param isr Funktionszeiger auf die Interrupt-Service-Routine
@param module Zeiger auf das Modul (fuer try_module_lock())
@return 0, wenn alles o.k.,
< 0, wenn bereits ein Geraet registriert oder das Geraet nicht
geoeffnet werden konnte.
\return 0 wenn alles ok, oder < 0 wenn bereits ein Gerät registriert
oder das Geraet nicht geöffnet werden konnte.
*/
ec_device_t *EtherCAT_dev_register(unsigned int master_index,
struct net_device *dev,
/**< Index des EtherCAT-Masters */
struct net_device *net_dev,
/**< net_device des EtherCAT-Gerätes */
irqreturn_t (*isr)(int, void *,
struct pt_regs *),
struct module *module)
/**< Interrupt-Service-Routine */
struct module *module
/**< Zeiger auf das Modul */
)
{
ec_device_t *ecd;
ec_device_t *device;
ec_master_t *master;
if (master_index >= ec_master_count) {
@ -164,7 +163,7 @@ ec_device_t *EtherCAT_dev_register(unsigned int master_index,
return NULL;
}
if (!dev) {
if (!net_dev) {
EC_WARN("Device is NULL!\n");
return NULL;
}
@ -176,30 +175,31 @@ ec_device_t *EtherCAT_dev_register(unsigned int master_index,
return NULL;
}
ecd = &master->device;
device = &master->device;
if (ec_device_init(ecd, master) < 0) return NULL;
if (ec_device_init(device, master) < 0) return NULL;
ecd->dev = dev;
ecd->tx_skb->dev = dev;
ecd->isr = isr;
ecd->module = module;
device->dev = net_dev;
device->tx_skb->dev = net_dev;
device->isr = isr;
device->module = module;
master->device_registered = 1;
return ecd;
return device;
}
/*****************************************************************************/
/**
Entfernt das EtherCAT-Geraet eines EtherCAT-Masters.
@param master_index Der Index des EtherCAT-Masters
@param ecd Das EtherCAT-Geraet
Hebt die Registrierung eines EtherCAT-Gerätes auf.
*/
void EtherCAT_dev_unregister(unsigned int master_index, ec_device_t *ecd)
void EtherCAT_dev_unregister(unsigned int master_index,
/**< Index des EtherCAT-Masters */
ec_device_t *device
/**< EtherCAT-Geraet */
)
{
ec_master_t *master;
@ -210,13 +210,13 @@ void EtherCAT_dev_unregister(unsigned int master_index, ec_device_t *ecd)
master = ec_masters + master_index;
if (!master->device_registered || &master->device != ecd) {
if (!master->device_registered || &master->device != device) {
EC_WARN("Unable to unregister device!\n");
return;
}
master->device_registered = 0;
ec_device_clear(ecd);
ec_device_clear(device);
}
/******************************************************************************
@ -230,11 +230,12 @@ void EtherCAT_dev_unregister(unsigned int master_index, ec_device_t *ecd)
Gibt einen Zeiger auf den reservierten EtherCAT-Master zurueck.
@param index Index des gewuenschten Masters
@returns Zeiger auf EtherCAT-Master oder NULL, wenn Parameter ungueltig.
\return Zeiger auf EtherCAT-Master oder NULL, wenn Parameter ungueltig.
*/
ec_master_t *EtherCAT_rt_request_master(unsigned int index)
ec_master_t *EtherCAT_rt_request_master(unsigned int index
/**< EtherCAT-Master-Index */
)
{
ec_master_t *master;
@ -293,11 +294,9 @@ ec_master_t *EtherCAT_rt_request_master(unsigned int index)
/**
Gibt einen zuvor angeforderten EtherCAT-Master wieder frei.
@param master Zeiger auf den freizugebenden EtherCAT-Master.
*/
void EtherCAT_rt_release_master(ec_master_t *master)
void EtherCAT_rt_release_master(ec_master_t *master /**< EtherCAT-Masdter */)
{
unsigned int i, found;

6
master/slave.c
View File

@ -58,6 +58,8 @@ void ec_slave_clear(ec_slave_t *slave /**< EtherCAT-Slave */)
/**
Liest alle benötigten Informationen aus einem Slave.
\return 0 wenn alles ok, < 0 bei Fehler.
*/
int ec_slave_fetch(ec_slave_t *slave /**< EtherCAT-Slave */)
@ -186,7 +188,7 @@ int ec_slave_sii_read(ec_slave_t *slave,
/**
Bestätigt einen Fehler beim Zustandswechsel.
FIXME Funktioniert noch nicht...
\todo Funktioniert noch nicht...
*/
void ec_slave_state_ack(ec_slave_t *slave,
@ -342,6 +344,8 @@ int ec_slave_set_fmmu(ec_slave_t *slave, /**< EtherCAT-Slave */
if (slave->fmmus[i].domain == domain && slave->fmmus[i].sync == sync)
return 0;
// Neue FMMU reservieren...
if (slave->fmmu_count >= slave->base_fmmu_count) {
EC_ERR("Slave %i FMMU limit reached!\n", slave->ring_position);
return -1;

2
master/types.h
View File

@ -55,7 +55,7 @@ ec_sync_t;
Diese Beschreibung dient zur Konfiguration einer bestimmten
Slave-Art. Sie enthält die Konfigurationsdaten für die
Slave-internen Sync-Manager und FMMU's.
Slave-internen Sync-Manager und FMMUs.
*/
typedef struct ec_slave_type

2
rt/msr_module.c
View File

@ -132,7 +132,7 @@ int __init init_rt_module(void)
goto out_msr_cleanup;
}
EtherCAT_rt_master_print(master);
//EtherCAT_rt_master_print(master);
printk(KERN_INFO "Registering domain...\n");