mirror of
https://gitlab.com/etherlab.org/ethercat.git
synced 2026-02-06 11:51:45 +08:00
346 lines
8.1 KiB
C
346 lines
8.1 KiB
C
/******************************************************************************
|
|
*
|
|
* ec_mini.c
|
|
*
|
|
* Minimalmodul für EtherCAT
|
|
*
|
|
* $Id$
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/tqueue.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/delay.h>
|
|
|
|
#include "../drivers/ec_master.h"
|
|
#include "../drivers/ec_device.h"
|
|
#include "../drivers/ec_types.h"
|
|
#include "../drivers/ec_dbg.h"
|
|
|
|
extern EtherCAT_device_t rtl_ecat_dev;
|
|
|
|
//static EtherCAT_master_t *ecat_master = NULL;
|
|
|
|
#if 0
|
|
static EtherCAT_slave_t ecat_slaves[] =
|
|
{
|
|
// Block 1
|
|
ECAT_INIT_SLAVE(Beckhoff_EK1100),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL4102),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL3162),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL1014),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL2004),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL3102),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL4102),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL4102),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL4102),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL3162),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL3162),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL3162),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL3102),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL3102),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL2004),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL2004),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL2004),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL2004),
|
|
|
|
// Block 2
|
|
ECAT_INIT_SLAVE(Beckhoff_EK1100),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL4102),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL1014),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL3162),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL2004),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL3102),
|
|
|
|
// Block 3
|
|
ECAT_INIT_SLAVE(Beckhoff_EK1100),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL1014),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL1014),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL1014),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL1014),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL1014),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL2004),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL2004),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL2004),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL2004),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL1014),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL1014),
|
|
ECAT_INIT_SLAVE(Beckhoff_EL1014)
|
|
};
|
|
|
|
#define ECAT_SLAVES_COUNT (sizeof(ecat_slaves) / sizeof(EtherCAT_slave_t))
|
|
#endif
|
|
|
|
double value;
|
|
int dig1;
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Function: next2004
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#if 0
|
|
static int next2004(int *wrap)
|
|
{
|
|
static int i = 0;
|
|
unsigned int j = 0;
|
|
|
|
*wrap = 0;
|
|
|
|
for (j = 0; j < ECAT_SLAVES_COUNT; j++)
|
|
{
|
|
i++;
|
|
|
|
i %= ECAT_SLAVES_COUNT;
|
|
|
|
if (i == 0) *wrap = 1;
|
|
|
|
if (ecat_slaves[i].desc == Beckhoff_EL2004)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Function: msr_controller
|
|
*
|
|
* Beschreibung: Zyklischer Prozess
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#if 0
|
|
void msr_controller()
|
|
{
|
|
static int ms = 0;
|
|
static int cnt = 0;
|
|
static unsigned long int k = 0;
|
|
static int firstrun = 1;
|
|
|
|
static int klemme = 12;
|
|
static int kanal = 0;
|
|
static int up_down = 0;
|
|
int wrap = 0;
|
|
|
|
ms++;
|
|
ms %= 1000;
|
|
|
|
#if 0
|
|
ecat_tx_delay = ((unsigned int) (100000 / HZ) * (ecat_master->dev->tx_time-k))
|
|
/ (current_cpu_data.loops_per_jiffy / 10);
|
|
ecat_rx_delay = ((unsigned int) (100000 / HZ) * (ecat_master->dev->rx_time-k))
|
|
/ (current_cpu_data.loops_per_jiffy / 10);
|
|
|
|
rx_intr = ecat_master->dev->rx_intr_cnt;
|
|
tx_intr = ecat_master->dev->tx_intr_cnt;
|
|
total_intr = ecat_master->dev->intr_cnt;
|
|
#endif
|
|
|
|
// Prozessdaten lesen
|
|
if (!firstrun)
|
|
{
|
|
EtherCAT_read_process_data(ecat_master);
|
|
|
|
// Daten lesen und skalieren
|
|
value = EtherCAT_read_value(&ecat_master->slaves[5], 0) / 3276.7;
|
|
dig1 = EtherCAT_read_value(&ecat_master->slaves[3], 0);
|
|
}
|
|
|
|
// Daten schreiben
|
|
EtherCAT_write_value(&ecat_master->slaves[4], 0, ms > 500 ? 1 : 0);
|
|
EtherCAT_write_value(&ecat_master->slaves[4], 1, ms > 500 ? 0 : 1);
|
|
EtherCAT_write_value(&ecat_master->slaves[4], 2, ms > 500 ? 0 : 1);
|
|
EtherCAT_write_value(&ecat_master->slaves[4], 3, ms > 500 ? 1 : 0);
|
|
|
|
if (cnt++ > 20)
|
|
{
|
|
cnt = 0;
|
|
|
|
if (++kanal > 3)
|
|
{
|
|
kanal = 0;
|
|
klemme = next2004(&wrap);
|
|
|
|
if (wrap == 1)
|
|
{
|
|
if (up_down == 1) up_down = 0;
|
|
else up_down = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (klemme >= 0)
|
|
EtherCAT_write_value(&ecat_master->slaves[klemme], kanal,up_down);
|
|
|
|
//EtherCAT_write_value(&ecat_master->slaves[13], 1, ms > 500 ? 0 : 1);
|
|
//EtherCAT_write_value(&ecat_master->slaves[14], 2, ms > 500 ? 0 : 1);
|
|
//EtherCAT_write_value(&ecat_master->slaves[15], 3, ms > 500 ? 1 : 0);
|
|
|
|
// Prozessdaten schreiben
|
|
rdtscl(k);
|
|
EtherCAT_write_process_data(ecat_master);
|
|
firstrun = 0;
|
|
}
|
|
#endif
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Function: init
|
|
*
|
|
******************************************************************************/
|
|
|
|
//#define ECAT_OPEN
|
|
|
|
int init()
|
|
{
|
|
#ifdef ECAT_OPEN
|
|
int rv = -1;
|
|
#endif
|
|
|
|
EC_DBG(KERN_INFO "=== Starting Minimal EtherCAT environment... ===\n");
|
|
|
|
EtherCAT_device_debug(&rtl_ecat_dev);
|
|
//mdelay(5000);
|
|
|
|
#ifdef ECAT_OPEN
|
|
EC_DBG("Opening EtherCAT device.\n");
|
|
|
|
// HIER PASSIERT DER FEHLER:
|
|
if (EtherCAT_device_open(&rtl_ecat_dev) < 0)
|
|
{
|
|
EC_DBG(KERN_ERR "msr_modul: Could not initialize EtherCAT NIC.\n");
|
|
goto out_nothing;
|
|
}
|
|
|
|
if (!rtl_ecat_dev.dev) // Es gibt kein EtherCAT-Device
|
|
{
|
|
EC_DBG(KERN_ERR "msr_modul: No EtherCAT device!\n");
|
|
goto out_close;
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
// EtherCAT-Master und Slaves initialisieren
|
|
EC_DBG("Initialising EtherCAT master\n");
|
|
|
|
if ((ecat_master = (EtherCAT_master_t *) kmalloc(sizeof(EtherCAT_master_t), GFP_KERNEL)) == 0)
|
|
{
|
|
EC_DBG(KERN_ERR "msr_modul: Could not alloc memory for EtherCAT master!\n");
|
|
goto out_close;
|
|
}
|
|
|
|
if (EtherCAT_master_init(ecat_master, &rtl_ecat_dev) < 0)
|
|
{
|
|
EC_DBG(KERN_ERR "EtherCAT could not init master!\n");
|
|
goto out_master;
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
EC_DBG("Checking EtherCAT slaves.\n");
|
|
|
|
if (EtherCAT_check_slaves(ecat_master, ecat_slaves, ECAT_SLAVES_COUNT) != 0)
|
|
{
|
|
EC_DBG(KERN_ERR "EtherCAT: Could not init slaves!\n");
|
|
goto out_masterclear;
|
|
}
|
|
|
|
EC_DBG("Activating all EtherCAT slaves.\n");
|
|
|
|
if (EtherCAT_activate_all_slaves(ecat_master) != 0)
|
|
{
|
|
EC_DBG(KERN_ERR "EtherCAT: Could not activate slaves!\n");
|
|
goto out_masterclear;
|
|
}
|
|
|
|
// Zyklischen Aufruf starten
|
|
|
|
EC_DBG("Starting cyclic sample thread.\n");
|
|
|
|
EtherCAT_write_process_data(ecat_master);
|
|
|
|
EC_DBG("Initialised sample thread.\n");
|
|
#endif
|
|
|
|
EC_DBG(KERN_INFO "=== Minimal EtherCAT environment started. ===\n");
|
|
|
|
return 0;
|
|
|
|
#if 0
|
|
out_masterclear:
|
|
EC_DBG(KERN_INFO "Clearing EtherCAT master.\n");
|
|
EtherCAT_master_clear(ecat_master);
|
|
#endif
|
|
|
|
#if 0
|
|
out_master:
|
|
EC_DBG(KERN_INFO "Freeing EtherCAT master.\n");
|
|
kfree(ecat_master);
|
|
#endif
|
|
|
|
#ifdef ECAT_OPEN
|
|
out_close:
|
|
EC_DBG(KERN_INFO "Closing device.\n");
|
|
EtherCAT_device_close(&rtl_ecat_dev);
|
|
|
|
out_nothing:
|
|
return rv;
|
|
#endif
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Function: cleanup
|
|
*
|
|
******************************************************************************/
|
|
|
|
void cleanup()
|
|
{
|
|
EC_DBG(KERN_INFO "=== Stopping Minimal EtherCAT environment... ===\n");
|
|
|
|
// Noch einmal lesen
|
|
//EC_DBG(KERN_INFO "Reading process data.\n");
|
|
//EtherCAT_read_process_data(ecat_master);
|
|
|
|
#if 0
|
|
if (ecat_master)
|
|
{
|
|
#if 0
|
|
EC_DBG(KERN_INFO "Deactivating slaves.\n");
|
|
EtherCAT_deactivate_all_slaves(ecat_master);
|
|
#endif
|
|
|
|
EC_DBG(KERN_INFO "Clearing EtherCAT master.\n");
|
|
EtherCAT_master_clear(ecat_master);
|
|
|
|
EC_DBG(KERN_INFO "Freeing EtherCAT master.\n");
|
|
kfree(ecat_master);
|
|
ecat_master = NULL;
|
|
}
|
|
#endif
|
|
|
|
#ifdef ECAT_OPEN
|
|
EC_DBG(KERN_INFO "Closing device.\n");
|
|
EtherCAT_device_close(&rtl_ecat_dev);
|
|
#endif
|
|
|
|
EC_DBG(KERN_INFO "=== Minimal EtherCAT environment stopped. ===\n");
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR ("Florian Pose <fp@igh-essen.com>");
|
|
MODULE_DESCRIPTION ("Minimal EtherCAT environment");
|
|
|
|
module_init(init);
|
|
module_exit(cleanup);
|
|
|
|
/*****************************************************************************/
|