Grazie mille per l'interesse
per compilare ed installare il componente viene usato HALCOMPILE che dovrebbe essere parte del sistema di LINUXCNC
http://linuxcnc.org/docs/stable/html/hal/intro.html
non so se lo compilo con altri sistemi se dopo può funzionare; comunque il linguaggio è C C++
non saprei come fare debugging
quì sotto il programma che ho fatto modificando un altro componente esistente
vedrete che ho usato una variabile char per fare la discriminazione dell if ma non funziona ugualmente… stessa cosa con int e double
la variabile scrivi dovrebbe servire da controllo in modo che entri solo una volta e poi può rientrare solo dopo che il clock è andato alto per preparare il dato del passaggio seguente
se ci fate caso ho commentato la parte con if(entra); questa la volevo usare come inizializzazione, ma non entra neppure li…
poi mi da anche errori di “caught signal 11 - dumping core” se decommento la riga // *(IOdecoder->debug) = num_giro; ma quello sarà il problema successivo…
scusatemi se ho fatto delle bestialità sono un hobbysta smanettone ;-)
/********************************************************************
* Description: IOdecoder.c
* This file, 'IOdecoder.c', is a HAL component that
* generates a clock signal to drive an input/output system
* based on NPIC6C596 ICs.
*
* Author: bobwolf
* License: GPL Version 2
*
* Copyright (c) 2024 All rights reserved.
*
********************************************************************/
/** Questo componente è un componente HAL di LINUXCNC e genera segnali per
* poter pilotare degli integrati NPIC6C596 che vengono usati sia in input
* che in output.
* il sistema si basa su un segnale di CLOCK fissato a 2500Hz collegato al
* clock dello shift register e ad un uscita DATA che inserisce il dato nello
* shift register ad ogni fronte di salita del clock; CLOCK e DATA sono in comune
* alla parte in input ed a quella in output.
* in fase di configurazione vengono creati i pin di input e di output che HAL
* userà e questi possono essere un numero multiplo di 8 fino ad un massimo di 32.
* il programma funziona così: dopo aver generato i pin di I/O il segnale di clock
* aspetta 2 cicli per andare alto partendo da un conto di -2;quando arriva a 0
* legge il dato presente sul pin di HAL in output, partendo dal numero più alto
* e lo mette sul pin fisico di uscita DATA dopodichè il pin di CLOCK va alto;
* il giro continua tornando indietro fino al pin out.0, DATA poi CLOCK.
* arrivati a leggere tutti gli output lo shift register è completo e viene dato
* un impulso alto sul pin fisico L_OUTPUT per far passare i dati nello shift
* register all'uscita fisica dell'IC. questo segnale è collegato anche al
* master reset attivo basso della parte della circuiteria degli input, in modo
* che lo shift register risulti pulito; a quel punto viene inserito con il
* pin fisico DATA un 1 nella prima posizione dello shift register degli input
* e viene fatto traslare e messo in uscita con la combinazione di CLOCK e L_INPUT
* viene visualizzato e fatto scorrere in tutte le posizione di input; questo bit
* messo ad 1 serve come selettore chiudendo l'uscita open-collector dell'IC
* a questo vi è collegato un pulsate (o un interruttore) da verificare. l'altro
* capo del pulsante è collegato a tutti gli altri pulsanti del sistema, ad una
* resistenza di pull-up ed al pin fisico IN_COM. se il selezionato pulsante è
* aperto sul pi IN_COM sarà presente un valore alto dato dalla resistenza di
* pull-up, altrimenti se è chiuso sarà presente un valore 0 dato
* dall'open-collector collegato a massa.
* quando tutte le uscite e gli ingressi sono stati processati il pin L_OUTPUT
* tornerà a 0 resettando tutti gli input.
* prima di fare ripartire il giro il CLOCK stà per due periodi bassi (questo
* l'ho fatto più che altro per poter in qualche modo capire con un oscilloscopio
* quando il giro riparte da capo e vedere le uscite cosa fanno)
*/
#include "rtapi.h" /* RTAPI realtime OS API */
#include "rtapi_app.h" /* RTAPI realtime module decls */
#include "hal.h" /* HAL public API decls */
#include <float.h>
#include <rtapi_math.h>
#include <rtapi_string.h>
#include <stdbool.h>
/* module information */
MODULE_AUTHOR("bobwolf");
MODULE_DESCRIPTION("NPIC6C596 input output driver Component for EMC HAL");
MODULE_LICENSE("GPL");
static int howmany;
static int input;
static int output;
int entra;
RTAPI_MP_INT(input, "number input channels");
RTAPI_MP_INT(output, "number output channels");
#define MAX_CHAN 2
#define MAX_INPUT 32
#define MAX_OUTPUT 32
/***********************************************************************
* STRUCTURES AND GLOBAL VARIABLES *
************************************************************************/
/** This structure contains the runtime data for a single IOdecoder.
*/
typedef struct {
hal_bit_t *clock; /* pin: clock */
hal_bit_t *data; /* pin: data */
hal_bit_t *l_input; /* pin: latch input */
hal_bit_t *l_output; /* pin: latch output */
hal_bit_t *in_com; /* pin: input common */
hal_float_t *frequency; /* pin: frequency */
hal_float_t *debug; /* pin: debug */
hal_bit_t *in_bit[MAX_INPUT];
hal_bit_t *out_bit[MAX_OUTPUT];
int howinput;
int howoutput;
double index; /* position within output cycle */
} hal_IOdecoder_t;
/* pointer to array of IOdecoder_t structs in shared memory, 1 per gen */
static hal_IOdecoder_t *IOdecoder_array;
/* other globals */
static int comp_id; /* component ID */
/***********************************************************************
* LOCAL FUNCTION DECLARATIONS *
************************************************************************/
static int export_IOdecoder(int num, hal_IOdecoder_t * addr,char* prefix);
static void calc_IOdecoder(void *arg, long period);
/***********************************************************************
* INIT AND EXIT CODE *
************************************************************************/
int rtapi_app_main(void)
{
int n, retval, i;
n=0;
entra = 1;
if((input!=8)&&(input!=16)&&(input!=24)&&(input!=32)) {
rtapi_print_msg(RTAPI_MSG_ERR,"input must be 8 or 16 or 24 or 32\n");
return -EINVAL;
}
if((output!=8)&&(output!=16)&&(output!=24)&&(output!=32)) {
rtapi_print_msg(RTAPI_MSG_ERR,"output must be 8 or 16 or 24 or 32\n");
return -EINVAL;
}
/* have good config info, connect to the HAL */
comp_id = hal_init("IOdecoder");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "IOdecoder: ERROR: hal_init() failed\n");
return -1;
}
/* allocate shared memory for IOdecoder data */
howmany = ( input + output )*2;
IOdecoder_array = hal_malloc(howmany * sizeof(hal_IOdecoder_t));
if (IOdecoder_array == 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"IOdecoder: ERROR: hal_malloc() failed\n");
hal_exit(comp_id);
return -1;
}
/* export variables and functions for each IOdecoder */
char buf[HAL_NAME_LEN + 1];
rtapi_snprintf(buf, sizeof(buf), "IOdecoder");
retval = export_IOdecoder(n, &(IOdecoder_array[n]),buf);
rtapi_print_msg(RTAPI_MSG_INFO,
"IOdecoder: installed %d input and %d output\n", input, output);
hal_ready(comp_id);
return 0;
}
void rtapi_app_exit(void)
{
hal_exit(comp_id);
}
/***********************************************************************
* REALTIME LOOP CALCULATIONS *
************************************************************************/
static void calc_IOdecoder(void *arg, long period)
{
hal_IOdecoder_t *IOdecoder;
double tmp1, tmp2;
int i;
char scrivi;
int spazio;
int num_input;
int num_output;
int giro;
int num_giro;
int TRUE;
int FALSE;
TRUE = 1;
FALSE = 0;
num_input = input;
num_output = output;
giro = num_output+num_input;
/*
if ( entra ) {
entra = 0;
num_giro = -2;
scrivi = 1;
}
*/
// *(IOdecoder->debug) = num_giro;
/* point to the data for this signal generator */
IOdecoder = arg;
/* calculate the time since last execution */
tmp1 = period * 0.000000001;
/* calculate how much of an output cycle that has passed */
tmp2 = *(IOdecoder->frequency) * tmp1;
/* limit frequency to comply with Nyquist limit */
if ( tmp2 > 1 ) {
*(IOdecoder->frequency) = 1 / tmp1;
tmp2 = 1;
}
/* index ramps from 0.0 to 0.99999 for each output cycle */
IOdecoder->index += tmp2;
/* wrap index if it is >= 1.0 */
if ( IOdecoder->index >= 1.0 ) {
IOdecoder->index -= 1.0;
}
//num_giro=-1;
/* generate the square wave and clock output */
/* tmp1 steps from -1.0 to +1.0 when index passes 0.5 */
if ( IOdecoder->index > 0.5 ) {
tmp1 = 1.0;
if ( num_giro >= 0 ) {
*(IOdecoder->clock) = 1;
scrivi = '1';
} else {
*(IOdecoder->clock) = 0;
//scrivi = 1;
if ( spazio == 1 ) {
num_giro++;
spazio = 0;
}
}
if ( IOdecoder->index > 0.75 ) {
*(IOdecoder->l_input) = 1;
}
} else {
tmp1 = -1.0;
// *(IOdecoder->clock) = 0;
spazio = 1;
if (scrivi != '0') {
scrivi = '0';
num_giro++;
*(IOdecoder->clock) = 0;
if ((num_giro >= 0)&&(num_giro < num_output)) {
i = num_output-num_giro-1; //0=31 31=0
*(IOdecoder->data) = *(IOdecoder->out_bit[i]);
}
if(num_giro == num_output){
*(IOdecoder->l_output) = 1;
*(IOdecoder->data) = 1;
}
if(num_giro > num_output){
*(IOdecoder->data) = 0;
}
/* num_input = input;32
num_output = output;32
giro = num_output+num_input;64
*/
if ((num_giro > num_output)&&(num_giro <= giro)) {
*(IOdecoder->l_input) = 0;
i=num_giro-num_input-1; //33=0 64=31
if (i>=0) {
*(IOdecoder->in_bit[i]) = *(IOdecoder->in_com);
}
}
if (num_giro > giro) {
num_giro = -2;
*(IOdecoder->l_output) = 0;
}
}
}
}
/***********************************************************************
* LOCAL FUNCTION DEFINITIONS *
************************************************************************/
static int export_IOdecoder(int num, hal_IOdecoder_t * addr,char* prefix)
{
int retval;
int i=0;
/* export pins */
for (i = 0; i < input; i++) {
retval = hal_pin_bit_newf(HAL_IN, &(addr->in_bit[i]), comp_id,
"%s.input.%02i", prefix, i);
if (retval != 0) {
return retval;
}
*(addr->in_bit[i]) = 0;
}
for (i = 0; i < output; i++) {
retval = hal_pin_bit_newf(HAL_OUT, &(addr->out_bit[i]), comp_id,
"%s.output.%02i", prefix, i);
if (retval != 0) {
return retval;
}
*(addr->out_bit[i]) = 0;
}
retval = hal_pin_bit_newf(HAL_IN, &(addr->in_com), comp_id,
"%s.input-common", prefix);
if (retval != 0) {
return retval;
}
*(addr->in_com) = 0;
retval = hal_pin_bit_newf(HAL_OUT, &(addr->data), comp_id,
"%s.data", prefix);
if (retval != 0) {
return retval;
}
*(addr->data) = 0;
retval = hal_pin_bit_newf(HAL_OUT, &(addr->l_input), comp_id,
"%s.latch-input", prefix);
if (retval != 0) {
return retval;
}
*(addr->l_input) = 0;
retval = hal_pin_bit_newf(HAL_OUT, &(addr->l_output), comp_id,
"%s.latch-output", prefix);
if (retval != 0) {
return retval;
}
*(addr->l_output) = 0;
retval = hal_pin_bit_newf(HAL_OUT, &(addr->clock), comp_id,
"%s.clock", prefix);
if (retval != 0) {
return retval;
}
retval = hal_pin_float_newf(HAL_IN, &(addr->frequency), comp_id,
"%s.frequency", prefix);
if (retval != 0) {
return retval;
}
retval = hal_pin_float_newf(HAL_OUT, &(addr->debug), comp_id,
"%s.debug", prefix);
if (retval != 0) {
return retval;
}
/* init all structure members */
*(addr->clock) = 0;
*(addr->debug) = 0;
*(addr->frequency) = 2500;
addr->index = 0.0;
/* export function for this loop */
char appoggio[HAL_NAME_LEN + 1];
rtapi_snprintf(appoggio, sizeof(appoggio), "%s.update", prefix);
retval =
hal_export_funct(appoggio, calc_IOdecoder, &(IOdecoder_array[num]), 0, 0,
comp_id);
if (retval != 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"IOdecoder: ERROR: update funct export failed\n");
hal_exit(comp_id);
return -1;
}
return 0;
}