##// END OF EJS Templates
ABS » abscontrol
RSS
Joining with abs monitoring.
imanay -
r116:117
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,17
1 /*
2 * Mensajes.h
3 *
4 * Created on: Nov 12, 2009
5 * Author: redes
6 */
7
8 #ifndef MENSAJES_H_
9 #define MENSAJES_H_
10
11 void LOG_SERVIDOR(char *mensaje);
12 void LOG_CLIENTE(char *mensaje);
13 void ERROR_FATAL(char *mensaje);
14 void ERROR(char *mensaje);
15
16
17 #endif /* MENSAJES_H_ */
Show file before | Show file after | Hide comments
@@ -0,0 +1,124
1 // *****************************************************************************
2 // SOFTWARE API DEFINITION FOR Analog to Digital Convertor
3 // *****************************************************************************
4
5 #ifndef ADC_AT91_H
6 #define ADC_AT91_H
7
8 #define MAP_SIZE 4096Ul
9 #define MAP_MASK (MAP_SIZE - 1)
10
11 #define ADC_BASE 0xFFFE0000
12
13 // -------- ADC_CR : (ADC Offset: 0x0) ADC Control Register --------
14 #define ADC_SWRST ((unsigned int) 0x1 << 0) // (ADC) Software Reset
15 #define ADC_START ((unsigned int) 0x1 << 1) // (ADC) Start Conversion
16 // -------- ADC_MR : (ADC Offset: 0x4) ADC Mode Register --------
17 #define ADC_TRGEN_DIS ((unsigned int) 0x0) // (ADC) Hradware triggers are disabled. Starting a conversion is only possible by software
18 #define ADC_TRGEN_EN ((unsigned int) 0x1) // (ADC) Hardware trigger selected by TRGSEL field is enabled.
19
20 #define ADC_TRGSEL_TIOA0 ((unsigned int) 0x0 << 1) // (ADC) Selected TRGSEL = TIAO0
21 #define ADC_TRGSEL_TIOA1 ((unsigned int) 0x1 << 1) // (ADC) Selected TRGSEL = TIAO1
22 #define ADC_TRGSEL_TIOA2 ((unsigned int) 0x2 << 1) // (ADC) Selected TRGSEL = TIAO2
23 #define ADC_TRGSEL_TIOA3 ((unsigned int) 0x3 << 1) // (ADC) Selected TRGSEL = TIAO3
24 #define ADC_TRGSEL_TIOA4 ((unsigned int) 0x4 << 1) // (ADC) Selected TRGSEL = TIAO4
25 #define ADC_TRGSEL_TIOA5 ((unsigned int) 0x5 << 1) // (ADC) Selected TRGSEL = TIAO5
26 #define ADC_TRGSEL_EXT ((unsigned int) 0x6 << 1) // (ADC) Selected TRGSEL = External Trigger
27
28 #define ADC_RES_10BIT ((unsigned int) 0x0 << 4) // (ADC) 10-bit resolution
29 #define ADC_RES_8BIT ((unsigned int) 0x1 << 4) // (ADC) 8-bit resolution
30
31 #define ADC_SLEEP_NORMAL_MODE ((unsigned int) 0x0 << 5) // (ADC) Normal Mode
32 #define ADC_SLEEP_MODE ((unsigned int) 0x1 << 5) // (ADC) Sleep Mode
33
34 #define ADC_PRESCAL ((unsigned int) 0x31 << 2) // (ADC) Prescaler rate selection
35 #define ADC_STARTUP ((unsigned int) 0x00 << 2) // (ADC) Startup Time
36 #define ADC_SHTIM ((unsigned int) 0x01 << 9) // (ADC) Sample & Hold Time
37
38 // -------- ADC_CHER : (ADC Offset: 0x10) ADC Channel Enable Register --------
39 #define ADC_CH0 ((unsigned int) 0x1 << 0) // (ADC) Channel 0
40 #define ADC_CH1 ((unsigned int) 0x1 << 1) // (ADC) Channel 1
41 #define ADC_CH2 ((unsigned int) 0x1 << 2) // (ADC) Channel 2
42 #define ADC_CH3 ((unsigned int) 0x1 << 3) // (ADC) Channel 3
43
44 /*Anadido por DCordova*/
45 // -------- ADC_CHSR : (ADC Offset: 0x10) ADC Channel Status Register --------
46 #define ADC_CHSR0 ((unsigned int) 0x1 << 0) // (ADC) Channel 0
47 #define ADC_CHSR1 ((unsigned int) 0x1 << 1) // (ADC) Channel 1
48 #define ADC_CHSR2 ((unsigned int) 0x1 << 2) // (ADC) Channel 2
49 #define ADC_CHSR3 ((unsigned int) 0x1 << 3) // (ADC) Channel 3
50 /*Anadido por DCordova*/
51
52
53 // -------- ADC_CHDR : (ADC Offset: 0x14) ADC Channel Disable Register --------
54 // -------- ADC_CHSR : (ADC Offset: 0x18) ADC Channel Status Register --------
55 // -------- ADC_SR : (ADC Offset: 0x1c) ADC Status Register --------
56
57 #define MASK_EOC0 ((unsigned int) 0x1 << 0) // (ADC) End of Conversion
58 #define MASK_EOC1 ((unsigned int) 0x1 << 1) // (ADC) End of Conversion
59 #define MASK_EOC2 ((unsigned int) 0x1 << 2) // (ADC) End of Conversion
60 #define MASK_EOC3 ((unsigned int) 0x1 << 3) // (ADC) End of Conversion
61 #define MASK_OVRE0 ((unsigned int) 0x1 << 8) // (ADC) Overrun Error
62 #define MASK_OVRE1 ((unsigned int) 0x1 << 9) // (ADC) Overrun Error
63 #define MASK_OVRE2 ((unsigned int) 0x1 << 10) // (ADC) Overrun Error
64 #define MASK_OVRE3 ((unsigned int) 0x1 << 11) // (ADC) Overrun Error
65 #define MASK_DRDY ((unsigned int) 0x1 << 16) // (ADC) Data Ready
66 #define MASK_GOVRE ((unsigned int) 0x1 << 17) // (ADC) General Overrun
67
68 // -------- ADC_LCDR : (ADC Offset: 0x20) ADC Last Converted Data Register --------
69 #define ADC_LDATA ((unsigned int) 0x3FF << 0) // (ADC) Last Data Converted
70 #define ADC_DATA ((unsigned int) 0x3FF << 0) // (ADC) Converted Data
71 #define ADC_DISABLE_INTERRUP ((unsigned int) 0x0F0F0F << 0) //(ADC) Disable all interrup
72
73 typedef volatile unsigned int AT91_REG2;// Hardware register definition
74
75 typedef struct _AT91S_ADC {
76 AT91_REG2 ADC_CR; // ADC Control Register
77 AT91_REG2 ADC_MR; // ADC Mode Register
78 AT91_REG2 Reserved0[2]; //
79 AT91_REG2 ADC_CHER; // ADC Channel Enable Register
80 AT91_REG2 ADC_CHDR; // ADC Channel Disable Register
81 AT91_REG2 ADC_CHSR; // ADC Channel Status Register
82 AT91_REG2 ADC_SR; // ADC Status Register
83 AT91_REG2 ADC_LCDR; // ADC Last Converted Data Register
84 AT91_REG2 ADC_IER; // ADC Interrupt Enable Register
85 AT91_REG2 ADC_IDR; // ADC Interrupt Disable Register
86 AT91_REG2 ADC_IMR; // ADC Interrupt Mask Register
87 AT91_REG2 ADC_CDR0; // ADC Channel Data Register 0
88 AT91_REG2 ADC_CDR1; // ADC Channel Data Register 1
89 AT91_REG2 ADC_CDR2; // ADC Channel Data Register 2
90 AT91_REG2 ADC_CDR3; // ADC Channel Data Register 3
91 AT91_REG2 ADC_CDR4; // ADC Channel Data Register 4
92 AT91_REG2 ADC_CDR5; // ADC Channel Data Register 5
93 AT91_REG2 ADC_CDR6; // ADC Channel Data Register 6
94 AT91_REG2 ADC_CDR7; // ADC Channel Data Register 7
95 AT91_REG2 Reserved1[44]; //
96 AT91_REG2 ADC_RPR; // Receive Pointer Register
97 AT91_REG2 ADC_RCR; // Receive Counter Register
98 AT91_REG2 ADC_TPR; // Transmit Pointer Register
99 AT91_REG2 ADC_TCR; // Transmit Counter Register
100 AT91_REG2 ADC_RNPR; // Receive Next Pointer Register
101 AT91_REG2 ADC_RNCR; // Receive Next Counter Register
102 AT91_REG2 ADC_TNPR; // Transmit Next Pointer Register
103 AT91_REG2 ADC_TNCR; // Transmit Next Counter Register
104 AT91_REG2 ADC_PTCR; // PDC Transfer Control Register
105 AT91_REG2 ADC_PTSR; // PDC Transfer Status Register
106 } AT91S_ADC, *AT91PS_ADC;
107
108 AT91S_ADC *adc_map(unsigned int adcbase);
109 /**********************Aniadido por DCV*********/
110 AT91S_ADC *adc_map1(unsigned int adcbase);
111 /**********************Aniadido por DCV*********/
112
113 void ADC_INIT(AT91S_ADC * adc);
114 void ADC_RESET(AT91S_ADC * adc);
115 void CONFIG_ADC(AT91S_ADC * adc,unsigned int REG_CONFIG);
116 void ENABLE_CHANNEL(AT91S_ADC * adc,unsigned int CHANNEL);
117 unsigned int STATUS_CHANNEL(AT91S_ADC * adc);
118 unsigned int GET_ADC(AT91S_ADC * adc);
119 unsigned int GET_ADC0(AT91S_ADC * adc);
120 unsigned int GET_ADC1(AT91S_ADC * adc);
121 unsigned int GET_ADC3(AT91S_ADC * adc);
122 unsigned int ver_reg_mode(AT91S_ADC * adc);
123 unsigned int GET_STATUS(AT91S_ADC * adc);
124 #endif
Show file before | Show file after | Hide comments
@@ -0,0 +1,137
1 /*
2 * This programmer uses AT91' GPIO lines
3 *
4 * 2006 by Carlos Camargo
5 * 2007.May.10 Andres Calderon
6 * 2009.Aug.26 Jose Francisco Quenta
7 */
8
9 #ifndef ECB_AT91_H
10 #define ECB_AT91_H
11
12
13 #define MAP_SIZE 4096Ul
14 #define MAP_MASK (MAP_SIZE - 1)
15
16 #define PIOA_BASE 0xFFFFF400
17 #define PIOB_BASE 0xFFFFF600
18 #define PIOC_BASE 0xFFFFF800
19 #define PIOD_BASE 0xFFFFFA00
20
21 #define PB0 (1 << 0)
22 #define PB1 (1 << 1)
23 #define PB2 (1 << 2)
24 #define PB3 (1 << 3)
25 #define PB8 (1 << 8)
26 #define PB9 (1 << 9)
27 #define PB10 (1 << 10)
28 #define PB11 (1 << 11)
29 #define PB16 (1 << 16)
30 #define PB17 (1 << 17)
31 #define PB18 (1 << 18)
32 #define PB19 (1 << 19)
33 #define PB20 (1 << 20)
34 #define PB21 (1 << 21)
35 #define PB22 (1 << 22)
36 #define PB23 (1 << 23)
37 #define PB24 (1 << 24)
38 #define PB25 (1 << 25)
39 #define PB30 (1 << 30)
40 #define PB31 (1 << 31)
41
42 #define PC0 (1 << 0)
43 #define PC1 (1 << 1)
44 #define PC4 (1 << 4)
45 #define PC5 (1 << 5)
46 #define PC6 (1 << 6)
47 #define PC7 (1 << 7)
48 #define PC8 (1 << 8)
49 #define PC9 (1 << 9)
50 #define PC10 (1 << 10)
51 #define PC11 (1 << 11)
52 #define PC16 (1 << 16)
53 #define PC17 (1 << 17)
54 #define PC18 (1 << 18)
55 #define PC19 (1 << 19)
56 #define PC20 (1 << 20)
57 #define PC21 (1 << 21)
58 #define PC22 (1 << 22)
59 #define PC23 (1 << 23)
60 #define PC24 (1 << 24)
61 #define PC25 (1 << 25)
62 #define PC26 (1 << 26)
63 #define PC27 (1 << 27)
64 #define PC28 (1 << 28)
65 #define PC29 (1 << 29)
66 #define PC30 (1 << 30)
67 #define PC31 (1 << 31)
68
69
70 typedef volatile unsigned int AT91_REG;
71 /* Hardware register definition */
72
73 typedef struct _AT91S_PIO {
74 AT91_REG PIO_PER; /* PIO Enable Register */
75 AT91_REG PIO_PDR; /* PIO Disable Register */
76 AT91_REG PIO_PSR; /* PIO Status Register */
77 AT91_REG Reserved0[1];
78 AT91_REG PIO_OER; /* Output Enable Register */
79 AT91_REG PIO_ODR; /* Output Disable Registerr */
80 AT91_REG PIO_OSR; /* Output Status Register */
81 AT91_REG Reserved1[1];
82 AT91_REG PIO_IFER; /* Input Filter Enable Register */
83 AT91_REG PIO_IFDR; /* Input Filter Disable Register */
84 AT91_REG PIO_IFSR; /* Input Filter Status Register */
85 AT91_REG Reserved2[1];
86 AT91_REG PIO_SODR; /* Set Output Data Register */
87 AT91_REG PIO_CODR; /* Clear Output Data Register */
88 AT91_REG PIO_ODSR; /* Output Data Status Register */
89 AT91_REG PIO_PDSR; /* Pin Data Status Register */
90 AT91_REG PIO_IER; /* Interrupt Enable Register */
91 AT91_REG PIO_IDR; /* Interrupt Disable Register */
92 AT91_REG PIO_IMR; /* Interrupt Mask Register */
93 AT91_REG PIO_ISR; /* Interrupt Status Register */
94 AT91_REG PIO_MDER; /* Multi-driver Enable Register */
95 AT91_REG PIO_MDDR; /* Multi-driver Disable Register */
96 AT91_REG PIO_MDSR; /* Multi-driver Status Register */
97 AT91_REG Reserved3[1];
98 AT91_REG PIO_PUDR; /* Pull-up Disable Register */
99 AT91_REG PIO_PUER; /* Pull-up Enable Register */
100 AT91_REG PIO_PUSR; /* Pad Pull-up Status Register */
101 AT91_REG Reserved4[1];
102 AT91_REG PIO_ASR; /* Select A Register */
103 AT91_REG PIO_BSR; /* Select B Register */
104 AT91_REG PIO_ABSR; /* AB Select Status Register */
105 AT91_REG Reserved5[9];
106 AT91_REG PIO_OWER; /* Output Write Enable Register */
107 AT91_REG PIO_OWDR; /* Output Write Disable Register */
108 AT91_REG PIO_OWSR; /* Output Write Status Register */
109 } AT91S_PIO, *AT91PS_PIO;
110
111 void pio_out(AT91S_PIO * pio, int mask, unsigned long val, int opcion);
112
113 int pio_in(AT91S_PIO * pio, int mask);
114
115 AT91S_PIO *pio_map(unsigned int piobase);
116
117 void pio_enable(AT91S_PIO * pio, int mask);
118
119 void pio_output_enable(AT91S_PIO * pio, int mask);
120
121 void pio_input_enable(AT91S_PIO * pio, int mask);
122
123 void pio_disable_irq(AT91S_PIO * pio, int mask);
124
125 void pio_disable_multiple_driver(AT91S_PIO * pio, int mask);
126
127 void pio_disable_pull_ups(AT91S_PIO * pio, int mask);
128
129 void pio_synchronous_data_output(AT91S_PIO * pio, int mask);
130
131 //funciones agregadas para la realizar el estado de algunos registros:
132 int ver_registro(AT91S_PIO * pio);
133 void pin_adc_enable(AT91S_PIO * pio, int mask);
134 void periferico_a(AT91S_PIO * pio, int mask);
135 int ver_periferico(AT91S_PIO * pio);
136
137 #endif
Show file before | Show file after | Hide comments
@@ -0,0 +1,83
1 // *****************************************************************************
2 // SOFTWARE API DEFINITION FOR Power Management Controler
3 // *****************************************************************************
4 #ifndef SYSCLOCK_AT91_H
5 #define SYSCLOCK_AT91_H
6
7 #define MAP_SIZE 4096Ul
8 #define MAP_MASK (MAP_SIZE - 1)
9
10 #define CLOCK_BASE 0xFFFFFC00
11 // -------- PMC_SCER : (PMC Offset: 0x0) System Clock Enable Register --------
12 #define AT91C_PMC_PCK ((unsigned int) 0x1 << 0) // (PMC) Processor Clock
13 #define AT91C_PMC_UHP ((unsigned int) 0x1 << 6) // (PMC) USB Host Port Clock
14 #define AT91C_PMC_UDP ((unsigned int) 0x1 << 7) // (PMC) USB Device Port Clock
15 #define AT91C_PMC_PCK0 ((unsigned int) 0x1 << 8) // (PMC) Programmable Clock Output
16 #define AT91C_PMC_PCK1 ((unsigned int) 0x1 << 9) // (PMC) Programmable Clock Output
17 #define AT91C_PMC_HCK0 ((unsigned int) 0x1 << 16) // (PMC) AHB UHP Clock Output
18 #define AT91C_PMC_HCK1 ((unsigned int) 0x1 << 17) // (PMC) AHB LCDC Clock Output
19 // -------- PMC_SCDR : (PMC Offset: 0x4) System Clock Disable Register --------
20 // -------- PMC_SCSR : (PMC Offset: 0x8) System Clock Status Register --------
21 // -------- CKGR_MOR : (PMC Offset: 0x20) Main Oscillator Register --------
22 // -------- CKGR_MCFR : (PMC Offset: 0x24) Main Clock Frequency Register --------
23 // -------- CKGR_PLLAR : (PMC Offset: 0x28) PLL A Register --------
24 // -------- CKGR_PLLBR : (PMC Offset: 0x2c) PLL B Register --------
25 // -------- PMC_MCKR : (PMC Offset: 0x30) Master Clock Register --------
26 #define AT91C_PMC_CSS ((unsigned int) 0x3 << 0) // (PMC) Programmable Clock Selection
27 #define AT91C_PMC_CSS_SLOW_CLK ((unsigned int) 0x0) // (PMC) Slow Clock is selected
28 #define AT91C_PMC_CSS_MAIN_CLK ((unsigned int) 0x1) // (PMC) Main Clock is selected
29 #define AT91C_PMC_CSS_PLLA_CLK ((unsigned int) 0x2) // (PMC) Clock from PLL A is selected
30 #define AT91C_PMC_CSS_PLLB_CLK ((unsigned int) 0x3) // (PMC) Clock from PLL B is selected
31 #define AT91C_PMC_PRES ((unsigned int) 0x7 << 2) // (PMC) Programmable Clock Prescaler
32 #define AT91C_PMC_PRES_CLK ((unsigned int) 0x0 << 2) // (PMC) Selected clock
33 #define AT91C_PMC_PRES_CLK_2 ((unsigned int) 0x1 << 2) // (PMC) Selected clock divided by 2
34 #define AT91C_PMC_PRES_CLK_4 ((unsigned int) 0x2 << 2) // (PMC) Selected clock divided by 4
35 #define AT91C_PMC_PRES_CLK_8 ((unsigned int) 0x3 << 2) // (PMC) Selected clock divided by 8
36 #define AT91C_PMC_PRES_CLK_16 ((unsigned int) 0x4 << 2) // (PMC) Selected clock divided by 16
37 #define AT91C_PMC_PRES_CLK_32 ((unsigned int) 0x5 << 2) // (PMC) Selected clock divided by 32
38 #define AT91C_PMC_PRES_CLK_64 ((unsigned int) 0x6 << 2) // (PMC) Selected clock divided by 64
39 #define AT91C_PMC_MDIV ((unsigned int) 0x3 << 8) // (PMC) Master Clock Division
40 #define AT91C_PMC_MDIV_1 ((unsigned int) 0x0 << 8) // (PMC) The master clock and the processor clock are the same
41 #define AT91C_PMC_MDIV_2 ((unsigned int) 0x1 << 8) // (PMC) The processor clock is twice as fast as the master clock
42 #define AT91C_PMC_MDIV_3 ((unsigned int) 0x2 << 8) // (PMC) The processor clock is four times faster than the master clock
43 // -------- PMC_PCKR : (PMC Offset: 0x40) Programmable Clock Register --------
44 // -------- PMC_IER : (PMC Offset: 0x60) PMC Interrupt Enable Register --------
45 #define AT91C_PMC_MOSCS ((unsigned int) 0x1 << 0) // (PMC) MOSC Status/Enable/Disable/Mask
46 #define AT91C_PMC_LOCKA ((unsigned int) 0x1 << 1) // (PMC) PLL A Status/Enable/Disable/Mask
47 #define AT91C_PMC_LOCKB ((unsigned int) 0x1 << 2) // (PMC) PLL B Status/Enable/Disable/Mask
48 #define AT91C_PMC_MCKRDY ((unsigned int) 0x1 << 3) // (PMC) Master Clock Status/Enable/Disable/Mask
49 #define AT91C_PMC_PCK0RDY ((unsigned int) 0x1 << 8) // (PMC) PCK0_RDY Status/Enable/Disable/Mask
50 #define AT91C_PMC_PCK1RDY ((unsigned int) 0x1 << 9) // (PMC) PCK1_RDY Status/Enable/Disable/Mask
51 // -------- PMC_IDR : (PMC Offset: 0x64) PMC Interrupt Disable Register --------
52 // -------- PMC_SR : (PMC Offset: 0x68) PMC Status Register --------
53 // -------- PMC_IMR : (PMC Offset: 0x6c) PMC Interrupt Mask Register --------
54
55 typedef volatile unsigned int AT91_REG3;// Hardware register definition
56 typedef struct _AT91S_PMC {
57 AT91_REG3 PMC_SCER; // System Clock Enable Register
58 AT91_REG3 PMC_SCDR; // System Clock Disable Register
59 AT91_REG3 PMC_SCSR; // System Clock Status Register
60 AT91_REG3 Reserved0[1]; //
61 AT91_REG3 PMC_PCER; // Peripheral Clock Enable Register
62 AT91_REG3 PMC_PCDR; // Peripheral Clock Disable Register
63 AT91_REG3 PMC_PCSR; // Peripheral Clock Status Register
64 AT91_REG3 Reserved1[1]; //
65 AT91_REG3 PMC_MOR; // Main Oscillator Register
66 AT91_REG3 PMC_MCFR; // Main Clock Frequency Register
67 AT91_REG3 PMC_PLLAR; // PLL A Register
68 AT91_REG3 PMC_PLLBR; // PLL B Register
69 AT91_REG3 PMC_MCKR; // Master Clock Register
70 AT91_REG3 Reserved2[3]; //
71 AT91_REG3 PMC_PCKR[8]; // Programmable Clock Register
72 AT91_REG3 PMC_IER; // Interrupt Enable Register
73 AT91_REG3 PMC_IDR; // Interrupt Disable Register
74 AT91_REG3 PMC_SR; // Status Register
75 AT91_REG3 PMC_IMR; // Interrupt Mask Register
76 } AT91S_PMC, *AT91PS_PMC;
77
78 //Funciones:
79 AT91S_PMC *clock_map(unsigned int clockbase);
80 void enable_clock_adc(AT91S_PMC * clock);
81 unsigned int status_clock_adc(AT91S_PMC * clock);
82 #endif
83
Show file before | Show file after | Hide comments
@@ -0,0 +1,39
1 /*
2 * Mensajes.c
3 *
4 * Created on: Nov 12, 2009
5 * Author: Jose Francisco Quenta
6 */
7
8 #include <stdio.h>
9 #include <stdlib.h>
10
11 /*
12 * Imprime mensajes del servidor
13 */
14 void LOG_SERVIDOR(char *mensaje){
15 printf("SERVIDOR: %s\n",mensaje);
16 }
17
18 /*
19 * Imprime mensajes del cliente
20 */
21 void LOG_CLIENTE(char *mensaje){
22 printf("CLIENTE: %s\n",mensaje);
23 }
24
25 /*
26 * Error no fatal, permite la continuación del programa
27 */
28 void ERROR(char *mensaje){
29 fprintf(stderr, "ERROR. %s\n", mensaje);
30 }
31
32 /*
33 * Error fatal, aborta la ejecución del programa con código de salida de error
34 */
35 void ERROR_FATAL(char *mensaje){
36 fprintf(stderr, "ERROR FATAL. %s\n", mensaje);
37 exit(EXIT_FAILURE);
38 }
39
Show file before | Show file after | Hide comments
@@ -0,0 +1,138
1 /*
2 * This programmer uses AT91' ADC Module
3 *
4 * 2010 by Ricardo V. Rojas Quispe
5 */
6
7 #include <stdint.h>
8 #include <stdlib.h>
9 #include <stdio.h>
10 #include <unistd.h>
11
12 #include <sys/types.h>
13 #include <sys/stat.h>
14 #include <sys/mman.h>
15 #include <fcntl.h>
16
17 #include "./Librerias/at91adc.h"
18
19 AT91S_ADC *adc_map(unsigned int adcbase){
20 int fd;
21 void *base;
22
23 AT91S_ADC *adc;
24
25 off_t addr = adcbase;
26
27 if ((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) {
28 fprintf(stderr, "Cannot open /dev/mem.\n");
29 exit(EXIT_FAILURE);
30 }
31
32
33 base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, addr & ~MAP_MASK);
34
35 if (base == (void *) -1) {
36 fprintf(stderr, "Cannot open /dev/mem.\n");
37 exit(EXIT_FAILURE);
38 }
39
40
41 adc = base + (addr & MAP_MASK);
42
43 return adc;
44 }
45 /**********************Anadido por DCV*ini********/
46 AT91S_ADC *adc_map1(unsigned int adcbase){
47 int fd;
48 void *base;
49
50 AT91S_ADC *adc;
51
52 off_t addr = adcbase;
53
54 if ((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) {
55 //fprintf(stderr, "Cannot open /dev/mem.\n");
56 exit(EXIT_FAILURE);
57 }
58
59 base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, addr & ~MAP_MASK);
60
61 if (base == (void *) -1) {
62 //fprintf(stderr, "Cannot open /dev/mem.\n");
63 exit(EXIT_FAILURE);
64 }
65
66 adc = base + (addr & MAP_MASK);
67
68 return adc;
69 }
70
71 /*********************Anadido por DCV*fin**********/
72 void ADC_INIT(AT91S_ADC * adc){
73 //Incia conversion ADC
74 adc->ADC_CR = ADC_START;
75 }
76
77 void ADC_RESET(AT91S_ADC * adc){
78 //Reset de ADC
79 adc->ADC_CR = ADC_SWRST;
80 }
81 void CONFIG_ADC(AT91S_ADC * adc,unsigned int REG_CONFIG){
82 //configura ADC
83 adc->ADC_MR = REG_CONFIG;
84 adc->ADC_IDR = ADC_DISABLE_INTERRUP;
85 }
86 void ENABLE_CHANNEL(AT91S_ADC * adc,unsigned int CHANNEL){
87 //Habilita canal selecconado y deshabilita el resto
88 adc->ADC_CHER = CHANNEL & 0x0F;
89 adc->ADC_CHDR = ~CHANNEL & 0x0F;
90 }
91 unsigned int STATUS_CHANNEL(AT91S_ADC * adc){
92 //Retorna el estado del canal habilitado
93 return (adc->ADC_CHSR);
94 }
95 unsigned int GET_ADC(AT91S_ADC * adc){
96 //unsigned int valor=1;
97 //Retorna el valor de ADC (resolucion de 10BIT)
98 while(1){
99 if ((adc-> ADC_SR & MASK_DRDY) == MASK_DRDY)
100 break;
101 }
102 return (adc->ADC_LCDR & ADC_LDATA);
103 }
104 unsigned int GET_STATUS(AT91S_ADC * adc){
105 //Retorna el estado del ADC (registro)
106 return (adc->ADC_SR);
107 }
108 unsigned int GET_ADC0(AT91S_ADC * adc){
109 //Retorna el valor de la conversion del canal 0
110 while(1){
111 if ((adc->ADC_SR & MASK_EOC0) == MASK_EOC0)
112 break;
113 }
114 return (adc->ADC_CDR0 & ADC_LDATA);
115 }
116 unsigned int GET_ADC1(AT91S_ADC * adc){
117 //Retorna el valor de la conversion del canal 1
118 while(1){
119 if ((adc->ADC_SR & MASK_EOC1) == MASK_EOC1)
120 break;
121 }
122 return (adc->ADC_CDR1 & ADC_LDATA);
123 }
124 unsigned int GET_ADC3(AT91S_ADC * adc){
125 unsigned int valor=1;
126 //Retorna el valor de ADC (resolucion de 10BIT)
127 while(valor){
128 if ((adc-> ADC_SR) & 0x10000)
129 valor = 0;
130 else
131 valor = 1;
132 }
133 return (adc->ADC_CDR1 & ADC_DATA);
134 }
135 unsigned int ver_reg_mode(AT91S_ADC * adc){
136 //retorna el valor del ADC_MR
137 return (adc->ADC_MR);
138 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,119
1 /*
2 * This programmer uses AT91' GPIO lines
3 *
4 * 2006 by Carlos Camargo
5 * 2007.May.10 Andres Calderon
6 * 2009.Aug.26 Jose Francisco Quenta
7 */
8
9 #include <stdint.h>
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <unistd.h>
13
14
15 #include <sys/types.h>
16 #include <sys/stat.h>
17 #include <sys/mman.h>
18 #include <fcntl.h>
19
20 #include "./Librerias/at91gpio.h"
21
22 void pio_out(AT91S_PIO * pio, int mask, unsigned long val, int opcion)
23 {
24 if (opcion == 1)
25 pio->PIO_SODR = mask & val;
26 else
27 pio->PIO_CODR = mask & val;
28 }
29
30
31 int pio_in(AT91S_PIO * pio, int mask)
32 {
33 return (pio->PIO_PDSR & mask);
34 }
35
36
37 AT91S_PIO *pio_map(unsigned int piobase)
38 {
39 int fd;
40 void *base;
41
42 AT91S_PIO *pio;
43
44 off_t addr = piobase;
45
46 if ((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) {
47 fprintf(stderr, "Cannot open /dev/mem.\n");
48 exit(EXIT_FAILURE);
49 }
50
51 fprintf(stderr, "/dev/mem opened.\n");
52
53 base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, addr & ~MAP_MASK);
54
55 if (base == (void *) -1) {
56 fprintf(stderr, "Cannot open /dev/mem.\n");
57 exit(EXIT_FAILURE);
58 }
59
60 fprintf(stderr, "Memory mapped at address %p.\n", base);
61
62 pio = base + (addr & MAP_MASK);
63
64 return pio;
65 }
66
67
68 void pio_enable(AT91S_PIO * pio, int mask)
69 {
70 pio->PIO_PER = mask; /* Enable PIO */
71 }
72
73 void pio_output_enable(AT91S_PIO * pio, int mask)
74 {
75 pio->PIO_OER = mask; /* Set TDI, TMS and TCK as outputs */
76 }
77
78 void pio_input_enable(AT91S_PIO * pio, int mask)
79 {
80 pio->PIO_ODR = mask; /* Set TDO as input */
81 pio->PIO_IFER = mask; /* Enable Input Filter */
82 }
83
84 void pio_disable_irq(AT91S_PIO * pio, int mask)
85 {
86 pio->PIO_IDR = mask; /* Disable pin interrupts */
87 }
88
89 void pio_disable_multiple_driver(AT91S_PIO * pio, int mask)
90 {
91 pio->PIO_MDDR = mask; /* Disable Multiple Diver */
92 }
93
94 void pio_disable_pull_ups(AT91S_PIO * pio, int mask)
95 {
96 pio->PIO_PUDR = mask; /* Disable Pull-Ups */
97 }
98
99 void pio_synchronous_data_output(AT91S_PIO * pio, int mask)
100 {
101 pio->PIO_OWDR = mask; /* Synchronous Data Output Write in PIO_ */
102 }
103
104 //Nuevas funciones:
105 int ver_registro(AT91S_PIO * pio){
106 return (pio->PIO_PSR);
107 }
108 //Habilitar pines para usar con ADC
109 void pin_adc_enable(AT91S_PIO * pio, int mask){
110 pio->PIO_PDR = mask;
111 }
112 //selecciona para el periferico A
113 void periferico_a(AT91S_PIO * pio, int mask){
114 pio->PIO_ASR = mask;
115 }
116 //Retorna cero si esta en el perifierico A y 1 si est aen el periferico B
117 int ver_periferico(AT91S_PIO * pio){
118 return (pio->PIO_ABSR & 0x01);
119 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,55
1 /*
2 * This programmer uses AT91' System clock
3 *
4 * 2010 by Ricardo V. Rojas Quispe
5 */
6
7 #include <stdint.h>
8 #include <stdlib.h>
9 #include <stdio.h>
10 #include <unistd.h>
11
12 #include <sys/types.h>
13 #include <sys/stat.h>
14 #include <sys/mman.h>
15 #include <fcntl.h>
16
17 #include "./Librerias/at91sysclock.h"
18
19 //Mapeando los registro en memoria:
20 AT91S_PMC *clock_map(unsigned int clockbase){
21 int fd;
22 void *base;
23
24 AT91S_PMC *clock;
25
26 off_t addr = clockbase;
27
28 if ((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) {
29 fprintf(stderr, "Cannot open /dev/mem.\n");
30 exit(EXIT_FAILURE);
31 }
32
33 //fprintf(stderr, "/dev/mem opened.\n");
34
35 base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, addr & ~MAP_MASK);
36
37 if (base == (void *) -1) {
38 fprintf(stderr, "Cannot open /dev/mem.\n");
39 exit(EXIT_FAILURE);
40 }
41
42 //fprintf(stderr, "Memory mapped at address %p.\n", base);
43
44 clock = base + (addr & MAP_MASK);
45
46 return clock;
47 }
48 //Habilitamos el clock de ADC
49 void enable_clock_adc(AT91S_PMC * clock){
50 clock->PMC_PCER=0x20;
51 }
52 //Leemos el registro de estado de clock para perifericos
53 unsigned int status_clock_adc(AT91S_PMC * clock){
54 return (clock->PMC_PCSR);
55 }
Show file before | Show file after | Hide comments
@@ -1,561 +1,1023
1 /*
1 /*
2 * Servidor.c
2 * Servidor.c
3 *
3 *
4 * Created on: Nov 3, 2009
4 * Created on: Nov 3, 2009
5 * Author: Jose Francisco Quenta
5 * Author: Jose Francisco Quenta
6 *
6 *
7 * Se implementa:
7 * Se implementa:
8 * -Carga en memoria los apuntes contenidos en un archivo de experimentos: apunte0 -> GPIO
8 * -Carga en memoria los apuntes contenidos en un archivo de experimentos: apunte0 -> GPIO
9 * -Cambio de apunte.
9 * -Cambio de apunte.
10 * -Lectura del estado actual del apunte y grabado del mismo en un archivo
10 * -Lectura del estado actual del apunte y grabado del mismo en un archivo
11 *
11 *
12 * Modified by Iván Manay since Nov 2012
12 * Modified by Iván Manay since Nov 2012
13 * -From UDP to TCP.
13 * -From UDP to TCP.
14 * -Use of a frame for TCP communications with the central control module.
14 * -Use of a frame for TCP communications with the central control module.
15 */
15 */
16
16
17 #include <stdio.h>
17 #include <stdio.h>
18 #include <stdlib.h>
18 #include <stdlib.h>
19 #include <string.h>
19 #include <string.h>
20 #include <unistd.h>
20 #include <unistd.h>
21 #include <errno.h>
21 #include <errno.h>
22
22
23 #include <sys/types.h>
23 #include <sys/types.h>
24 #include <sys/socket.h>
24 #include <sys/socket.h>
25 #include <netinet/in.h>
25 #include <netinet/in.h>
26 #include <arpa/inet.h>
26 #include <arpa/inet.h>
27 #include <netdb.h>
27 #include <netdb.h>
28
28 #include <time.h>
29 #include "./Librerias/AT91gpio_Funciones.h"
29 #include <math.h>
30 #include "./Librerias/Mensajes.h"
30
31 #include "./Librerias/at91gpio.h"
32 //#include "./Librerias/Mensajes.h"
33 #include "./Librerias/at91adc.h"
34 //clock
35 #include "./Librerias/at91sysclock.h"
31
36
32 #define PUERTO_SERVIDOR 5500
37 #define PUERTO_SERVIDOR 5500
33 #define TAM_BUFFER 1024
38 #define TAM_BUFFER 1024
34
39
35 #define maskc_out PC30+PC28+PC26+PC24+PC22+PC20 //MSB-UP-LSB MSB-DOWN-LSB //APUNTE
40 #define maskc_out PC30+PC28+PC26+PC24+PC22+PC20 //MSB-UP-LSB MSB-DOWN-LSB //APUNTE
36
41
37 #define maskb_in PB16+PB18+PB20+PB30+PB24+PB22 //MSB-UP-LSB MSB-DOWN-LSB //VERIFICACION
42 #define maskb_in PB16+PB18+PB20+PB30+PB24+PB22 //MSB-UP-LSB MSB-DOWN-LSB //VERIFICACION
38
43
39 #define bit_up_2 0x00010000 //Mascara de cada bit a revisar: bit_up_2 es MSB
44 #define bit_up_2 0x00010000 //Mascara de cada bit a revisar: bit_up_2 es MSB
40 #define bit_up_1 0x00040000
45 #define bit_up_1 0x00040000
41 #define bit_up_0 0x00100000
46 #define bit_up_0 0x00100000
42 #define bit_dow_2 0x40000000
47 #define bit_dow_2 0x40000000
43 #define bit_dow_1 0x01000000
48 #define bit_dow_1 0x01000000
44 #define bit_dow_0 0x00400000
49 #define bit_dow_0 0x00400000
45
50
46 #define MyID 11
51 #define MyID 11
47 #define MAXPENDING 5 /* Maximum outstanding connection requests */
52 #define MAXPENDING 5 /* Maximum outstanding connection requests */
53
54 //parameters for the name of the output file
55 #define FPRE "AD" //prefix for the output file name
56 #define FEXT ".out" //file extension for the output file
57 #define FNAMELEN 40
58
59 //ADC parameters
60 #define REP 1 //defines how many times the data acquisation loop is repeated
61 #define NSAMPLES 100 //defines how many samples are taken in one data acqu-
62 // isation loop
63 #define CNVTIME 14.3 //defines how long it takes to get one sample. Value
64 // is only needed for the output file, doesn't change
65 // any ADC configurations
66 #define UREF 3.3 //Reference Voltage of ADC (max. ADC Voltage)
67 #define ADCRES 1023 //Resolution of ADC (10bit=1023)
68
48
69
49 char *buff_experimento= NULL;
70 char *buff_experimento= NULL;
50
71
51 AT91S_PIO *pioc;
72 AT91S_PIO *pioc;
52 AT91S_PIO *piob;
73 AT91S_PIO *piob;
53
74
54 struct control_module_parameters {
75 struct control_module_parameters {
55 char ID[20];
76 char ID[20];
56 char param2[20];
77 char param2[20];
57 char param3[20];
78 char param3[20];
58 char param4[20];
79 char param4[20];
59 };
80 };
60
81
61 typedef struct control_module_parameters cmp;
82 typedef struct control_module_parameters cmp;
62
83
63 char *header = NULL;
84 char *header = NULL;
64 char *TypeOfInstrument = NULL;
85 char *TypeOfInstrument = NULL;
65 char *iDSource = NULL;
86 char *iDSource = NULL;
66 char *iDDestino = NULL;
87 char *iDDestino = NULL;
67 char *rx_len = NULL;
88 char *rx_len = NULL;
68 char *cmd = NULL;
89 char *cmd = NULL;
69 char *rx_data = NULL;
90 char *rx_data = NULL;
70 char *crc = NULL;
91 char *crc = NULL;
71
92
72 cmp parameters;
93 cmp parameters;
73 /*
94 /*
74 * Zona de declaracion de cabeceras.
95 * Zona de declaracion de cabeceras.
75 */
96 */
76 cmp inicializa_modulo(cmp p);
97 cmp inicializa_modulo(cmp p);
77 int inicializa_ethernet();
98 int inicializa_ethernet();
78 int rxData(int, char*);
99 int rxData(int, char*);
79 void txData(int, char*);
100 void txData(int, char*);
80 void inicializa_gpio();
101 void inicializa_gpio();
81 void procesa_peticion(char *rx_buffer, char *tx_buffer);
102 void procesa_peticion(char *rx_buffer, char *tx_buffer);
82 int cambia_apuntamiento(char *puntero_char);
103 int cambia_apuntamiento(char *puntero_char);
83 int carga_experimento(char *nombre_archivo);
104 int carga_experimento(char *nombre_archivo);
84 char *chequeo_sistema(char *filename, char *numero_muestras);
105 char *chequeo_sistema(char *filename, char *numero_muestras);
85 void recibe_experimento(char *data, char filename[]);
106 void recibe_experimento(char *data, char filename[]);
86 void SplitFrame(char *frame);
107 void SplitFrame(char *frame);
87 void intToStr( int number, char* str );
108 void intToStr( int number, char* str );
88
109
110 //ABS monitoring
111 int ABS_monitoreo(int sel_atenuador, int sel_calibracion, float umbral, int pulsewidth);
112
113 AT91S_ADC * configADC1(void);
114 AT91S_ADC * configADC2(void);
115
116 FILE * create_Output(char*, time_t);
117
118 void writeOutput(float resultado, FILE * output);
119
120 int checkTx(long int results1[],long int results2[], float umbral, int pulsewidth);
121
122 double mediana(long int *results, unsigned int cuenta);
123 float getPhase(long int results1[], long int results2[]);
124
125 int fExists(char *);
126 int configCLK();
127 //
128
89 /*
129 /*
90 *
130 *
91 */
131 */
92 int main(){
132 int main(){
93
133
94 int servSocket;
134 int servSocket;
95 int clntSocket;
135 int clntSocket;
96
136
97
137
98 char *rx_buffer = (char *) malloc(TAM_BUFFER);
138 char *rx_buffer = (char *) malloc(TAM_BUFFER);
99 char *tx_buffer = (char *) malloc(TAM_BUFFER);
139 char *tx_buffer = (char *) malloc(TAM_BUFFER);
100 /* Inicializa parametros del modulo*/
140 /* Inicializa parametros del modulo*/
101 parameters = inicializa_modulo(parameters);
141 parameters = inicializa_modulo(parameters);
102 printf("%s\n%s\n%s\n%s\n",parameters.ID, parameters.param2, parameters.param3, parameters.param4);
142 printf("%s\n%s\n%s\n%s\n",parameters.ID, parameters.param2, parameters.param3, parameters.param4);
103 /* Inicializa red*/
143 /* Inicializa red*/
104 servSocket = inicializa_ethernet();
144 servSocket = inicializa_ethernet();
105 /* Inicializamos el puerto GPIO del sistema embebido GSBC-9260S */
145 /* Inicializamos el puerto GPIO del sistema embebido GSBC-9260S */
106 inicializa_gpio();
146 inicializa_gpio();
107
147
108 while(1){
148 while(1){
109 // Recepción TCP de petición
149 // Recepción TCP de petición
110 clntSocket = rxData(servSocket, rx_buffer);
150 clntSocket = rxData(servSocket, rx_buffer);
111 //testpoint
151 //testpoint
112 printf("rx:%s\n",rx_buffer);
152 printf("rx:%s\n",rx_buffer);
113 // Procesamiento de la petición
153 // Procesamiento de la petición
114 procesa_peticion(rx_buffer, tx_buffer);
154 procesa_peticion(rx_buffer, tx_buffer);
115 //testpoint
155 //testpoint
116 printf("tx:%s\n",tx_buffer);
156 printf("tx:%s\n",tx_buffer);
117 // Respuesta del modulo de control
157 // Respuesta del modulo de control
118 txData(clntSocket, tx_buffer);
158 txData(clntSocket, tx_buffer);
119
159
120 }
160 }
121 }
161 }
122
162
123
163
124 int inicializa_ethernet(){
164 int inicializa_ethernet(){
125
165
126 struct sockaddr_in inf_servidor;
166 struct sockaddr_in inf_servidor;
127
167
128 int servSocket;
168 int servSocket;
129
169
130 int resultado;
170 int resultado;
131
171
132 /* Haciendo la estructura local*/
172 /* Haciendo la estructura local*/
133 memset(&inf_servidor, 0, sizeof(inf_servidor));
173 memset(&inf_servidor, 0, sizeof(inf_servidor));
134 inf_servidor.sin_family= AF_INET;
174 inf_servidor.sin_family= AF_INET;
135 inf_servidor.sin_port= htons(PUERTO_SERVIDOR);
175 inf_servidor.sin_port= htons(PUERTO_SERVIDOR);
136 inf_servidor.sin_addr.s_addr= INADDR_ANY;
176 inf_servidor.sin_addr.s_addr= INADDR_ANY;
137
177
138 /* Se establece el socket */
178 /* Se establece el socket */
139 servSocket = socket(AF_INET,SOCK_STREAM, IPPROTO_TCP);
179 servSocket = socket(AF_INET,SOCK_STREAM, IPPROTO_TCP);
140 if (servSocket == -1){
180 if (servSocket == -1){
141 ERROR_FATAL("No se establecio correctamente el socket: socket()\n");
181 printf("No se establecio correctamente el socket: socket()\n");
182 //ERROR_FATAL("No se establecio correctamente el socket: socket()\n");
142 exit(-1);
183 exit(-1);
143 }
184 }
144
185
145 /* Se asocia el socket a un puerto y una IP */
186 /* Se asocia el socket a un puerto y una IP */
146 resultado = bind(servSocket,(struct sockaddr *)&inf_servidor,sizeof(inf_servidor));
187 resultado = bind(servSocket,(struct sockaddr *)&inf_servidor,sizeof(inf_servidor));
147 if (resultado== -1){
188 if (resultado== -1){
148 ERROR_FATAL("No se establecio correctamente el socket: bind()\n");
189 printf("No se establecio correctamente el socket: bind()\n");
190 //ERROR_FATAL("No se establecio correctamente el socket: bind()\n");
149 exit(-1);
191 exit(-1);
150 }
192 }
151
193
152 if (listen(servSocket, MAXPENDING) < 0){
194 if (listen(servSocket, MAXPENDING) < 0){
153 printf("listen() failed\n");
195 printf("listen() failed\n");
154 exit(-1);
196 exit(-1);
155 }
197 }
156
198
157 return servSocket;
199 return servSocket;
158
200
159 }
201 }
160
202
161 int rxData(int servSocket, char* rx_buffer){
203 int rxData(int servSocket, char* rx_buffer){
162
204
163 int clntSocket;
205 int clntSocket;
164 struct sockaddr_in inf_cliente;
206 struct sockaddr_in inf_cliente;
165 int numbytes_recibidos;
207 int numbytes_recibidos;
166 unsigned int inf_client_Len;
208 unsigned int inf_client_Len;
167
209
168 printf("\nEsperando solicitud de cliente...\n");
210 printf("\nEsperando solicitud de cliente...\n");
169
211
170 /* Set the size of the in-out parameter */
212 /* Set the size of the in-out parameter */
171 inf_client_Len = sizeof(inf_cliente);
213 inf_client_Len = sizeof(inf_cliente);
172 /* Se espera hasta que un cliente se conecte */
214 /* Se espera hasta que un cliente se conecte */
173 if ((clntSocket = accept(servSocket, (struct sockaddr *) &inf_cliente,
215 if ((clntSocket = accept(servSocket, (struct sockaddr *) &inf_cliente,
174 &inf_client_Len)) < 0)
216 &inf_client_Len)) < 0)
175 printf("accept() failed\n");
217 printf("accept() failed\n");
176
218
177 if ((numbytes_recibidos = recv(clntSocket, rx_buffer, TAM_BUFFER, 0)) < 0)
219 if ((numbytes_recibidos = recv(clntSocket, rx_buffer, TAM_BUFFER, 0)) < 0)
178 printf("recv() failed\n");
220 printf("recv() failed\n");
179
221
180 /* Se procede a procesar los datos recibidos */
222 /* Se procede a procesar los datos recibidos */
181 rx_buffer[numbytes_recibidos]= '\0';
223 rx_buffer[numbytes_recibidos]= '\0';
182
224
183 return clntSocket;
225 return clntSocket;
184 }
226 }
185
227
186 void txData(int clntSocket, char* data){
228 void txData(int clntSocket, char* data){
187
229
188 /* Echo message back to client */
230 /* Echo message back to client */
189 if (send(clntSocket, data, strlen(data), 0) != strlen(data))
231 if (send(clntSocket, data, strlen(data), 0) != strlen(data))
190 printf("send() failed\n");
232 printf("send() failed\n");
191
233
192 close(clntSocket); /* Close client socket */
234 close(clntSocket); /* Close client socket */
193 }
235 }
194
236
195 /*
237 /*
196 * Esta funcion incializa el puerto GPIO
238 * Esta funcion incializa el puerto GPIO
197 */
239 */
198 void inicializa_gpio(){
240 void inicializa_gpio(){
199
241
200 // Configuracion de los pines de APUNTE
242 // Configuracion de los pines de APUNTE
201 pioc = pio_map(PIOC_BASE);
243 pioc = pio_map(PIOC_BASE);
202 pio_enable(pioc, maskc_out);
244 pio_enable(pioc, maskc_out);
203 pio_disable_irq(pioc, maskc_out);
245 pio_disable_irq(pioc, maskc_out);
204 pio_disable_multiple_driver(pioc, maskc_out);
246 pio_disable_multiple_driver(pioc, maskc_out);
205 pio_disable_pull_ups(pioc, maskc_out);
247 pio_disable_pull_ups(pioc, maskc_out);
206 pio_synchronous_data_output(pioc, maskc_out);
248 pio_synchronous_data_output(pioc, maskc_out);
207 pio_output_enable(pioc, maskc_out);
249 pio_output_enable(pioc, maskc_out);
208
250
209 // Configuracion de los pines de VERIFICACION
251 // Configuracion de los pines de VERIFICACION
210 piob = pio_map(PIOB_BASE);
252 piob = pio_map(PIOB_BASE);
211 pio_enable(piob, maskb_in);
253 pio_enable(piob, maskb_in);
212 pio_disable_irq(piob, maskb_in);
254 pio_disable_irq(piob, maskb_in);
213 pio_disable_multiple_driver(piob, maskb_in);
255 pio_disable_multiple_driver(piob, maskb_in);
214 pio_disable_pull_ups(piob, maskb_in);
256 pio_disable_pull_ups(piob, maskb_in);
215 pio_input_enable(piob, maskb_in);
257 pio_input_enable(piob, maskb_in);
216 }
258 }
217
259
218
260
219 /*
261 /*
220 * Divide rx frame into the frame components
262 * Divide rx frame into the frame components
221 */
263 */
222 void SplitFrame(char *frame){
264 void SplitFrame(char *frame){
223 header = malloc(4);
265 header = malloc(4);
224 *header = *frame;
266 *header = *frame;
225 *(header + 1) = *(frame + 1);
267 *(header + 1) = *(frame + 1);
226 *(header + 2) = *(frame + 2);
268 *(header + 2) = *(frame + 2);
227 *(header + 3) = '\0';
269 *(header + 3) = '\0';
228 TypeOfInstrument = malloc(4);
270 TypeOfInstrument = malloc(4);
229 *TypeOfInstrument = *(frame + 3);
271 *TypeOfInstrument = *(frame + 3);
230 *(TypeOfInstrument + 1) = *(frame + 4);
272 *(TypeOfInstrument + 1) = *(frame + 4);
231 *(TypeOfInstrument + 2) = *(frame + 5);
273 *(TypeOfInstrument + 2) = *(frame + 5);
232 *(TypeOfInstrument + 3) = '\0';
274 *(TypeOfInstrument + 3) = '\0';
233 iDSource = malloc(8);
275 iDSource = malloc(8);
234 *iDSource = *(frame + 6);
276 *iDSource = *(frame + 6);
235 *(iDSource + 1) = *(frame + 7);
277 *(iDSource + 1) = *(frame + 7);
236 *(iDSource + 2) = *(frame + 8);
278 *(iDSource + 2) = *(frame + 8);
237 *(iDSource + 3) = *(frame + 9);
279 *(iDSource + 3) = *(frame + 9);
238 *(iDSource + 4) = *(frame + 10);
280 *(iDSource + 4) = *(frame + 10);
239 *(iDSource + 5) = *(frame + 11);
281 *(iDSource + 5) = *(frame + 11);
240 *(iDSource + 6) = *(frame + 12);
282 *(iDSource + 6) = *(frame + 12);
241 *(iDSource + 7) = '\0';
283 *(iDSource + 7) = '\0';
242 iDDestino = malloc(8);
284 iDDestino = malloc(8);
243 *iDDestino = *(frame + 13);
285 *iDDestino = *(frame + 13);
244 *(iDDestino + 1) = *(frame + 14);
286 *(iDDestino + 1) = *(frame + 14);
245 *(iDDestino + 2) = *(frame + 15);
287 *(iDDestino + 2) = *(frame + 15);
246 *(iDDestino + 3) = *(frame + 16);
288 *(iDDestino + 3) = *(frame + 16);
247 *(iDDestino + 4) = *(frame + 17);
289 *(iDDestino + 4) = *(frame + 17);
248 *(iDDestino + 5) = *(frame + 18);
290 *(iDDestino + 5) = *(frame + 18);
249 *(iDDestino + 6) = *(frame + 19);
291 *(iDDestino + 6) = *(frame + 19);
250 *(iDDestino + 7) = '\0';
292 *(iDDestino + 7) = '\0';
251 rx_len = malloc(7);
293 rx_len = malloc(7);
252 *rx_len = *(frame + 20);
294 *rx_len = *(frame + 20);
253 *(rx_len + 1) = *(frame + 21);
295 *(rx_len + 1) = *(frame + 21);
254 *(rx_len + 2) = *(frame + 22);
296 *(rx_len + 2) = *(frame + 22);
255 *(rx_len + 3) = *(frame + 23);
297 *(rx_len + 3) = *(frame + 23);
256 *(rx_len + 4) = *(frame + 24);
298 *(rx_len + 4) = *(frame + 24);
257 *(rx_len + 5) = *(frame + 25);
299 *(rx_len + 5) = *(frame + 25);
258 *(rx_len + 6) = '\0';
300 *(rx_len + 6) = '\0';
259 cmd = malloc(5);
301 cmd = malloc(5);
260 *cmd = *(frame + 26);
302 *cmd = *(frame + 26);
261 *(cmd + 1) = *(frame + 27);
303 *(cmd + 1) = *(frame + 27);
262 *(cmd + 2) = *(frame + 28);
304 *(cmd + 2) = *(frame + 28);
263 *(cmd + 3) = *(frame + 29);
305 *(cmd + 3) = *(frame + 29);
264 *(cmd + 4) = '\0';
306 *(cmd + 4) = '\0';
265
307
266 int l = atoi(rx_len);
308 int l = atoi(rx_len);
267 rx_data = malloc(l + 1);
309 rx_data = malloc(l + 1);
268 int i;
310 int i;
269 for (i = 30; i < 30 + l; i++)
311 for (i = 30; i < 30 + l; i++)
270 *(rx_data + (i-30)) = *(frame + i);
312 *(rx_data + (i-30)) = *(frame + i);
271 *(rx_data + l) = '\0';
313 *(rx_data + l) = '\0';
272 crc = malloc(2);
314 crc = malloc(2);
273 *crc = *(frame + 30 + l);
315 *crc = *(frame + 30 + l);
274 *(crc + 1) = '\0';
316 *(crc + 1) = '\0';
275 }
317 }
276
318
277
319
278 /*
320 /*
279 * Esta funcion procesa el mensaje de peticion y genera respuesta
321 * Esta funcion procesa el mensaje de peticion y genera respuesta
280 */
322 */
281 void procesa_peticion(char *rx_buffer, char *tx_buffer){
323 void procesa_peticion(char *rx_buffer, char *tx_buffer){
282 // int n = 0;
324 // int n = 0;
283 char filename1[50];
325 char filename1[50];
284 char filename2[] = "verificacion.txt";
326 char filename2[] = "verificacion.txt";
285 char *tx_data = NULL;
327 char *tx_data = NULL;
286 char *tx_len = NULL;
328 char *tx_len = NULL;
287 SplitFrame(rx_buffer);
329 SplitFrame(rx_buffer);
288
330
289 if ((cmd == NULL) || (rx_data == NULL)){
331 if ((cmd == NULL) || (rx_data == NULL)){
290 ERROR("procesarPeticion: formato de mensaje incorrecto");
332 printf("procesarPeticion: formato de mensaje incorrecto");
333 //ERROR("procesarPeticion: formato de mensaje incorrecto");
334
291 }
335 }
292 else{
336 else{
293 if(strcmp(cmd,"SNDF") == 0){
337 if(strcmp(cmd,"SNDF") == 0){
294 recibe_experimento(rx_data,filename1);
338 recibe_experimento(rx_data,filename1);
295 carga_experimento(filename1);
339 carga_experimento(filename1);
296 cambia_apuntamiento("0");
340 cambia_apuntamiento("0");
297 tx_data = (char*)malloc(3);
341 tx_data = (char*)malloc(3);
298 tx_data = "OK";
342 tx_data = "OK";
299 }
343 }
300 else if(strcmp(cmd,"CHGB") == 0){
344 else if(strcmp(cmd,"CHGB") == 0){
301 cambia_apuntamiento(rx_data);
345 cambia_apuntamiento(rx_data);
302 tx_data = (char*)malloc(3);
346 tx_data = (char*)malloc(3);
303 tx_data = "OK";
347 tx_data = "OK";
304 }
348 }
305 else if(strcmp(cmd,"ANST") == 0){
349 else if(strcmp(cmd,"ANST") == 0){
306 tx_data = chequeo_sistema(filename2,rx_data);
350 tx_data = chequeo_sistema(filename2,rx_data);
351 ABS_monitoreo(1, 1, 50, 10);
307 printf("%s\n",tx_data);
352 printf("%s\n",tx_data);
308 }
353 }
309 else if(strcmp(cmd,"NTST") == 0){
354 else if(strcmp(cmd,"NTST") == 0){
310 tx_data = malloc(strlen(parameters.ID) + 1);
355 tx_data = malloc(strlen(parameters.ID) + 1);
311 strcpy(tx_data,parameters.ID);
356 strcpy(tx_data,parameters.ID);
312 printf("%s\n",tx_data);
357 printf("%s\n",tx_data);
313 }
358 }
314 else{
359 else{
315 tx_data = (char*)malloc(6);
360 tx_data = (char*)malloc(6);
316 tx_data = "Error";
361 tx_data = "Error";
317 ERROR("procesa_peticion: comando no reconocido");
362 printf("procesa_peticion: comando no reconocido");
363 //ERROR("procesa_peticion: comando no reconocido");
318 }
364 }
319
365
320 tx_len = malloc(7);
366 tx_len = malloc(7);
321 int number = strlen(tx_data);
367 int number = strlen(tx_data);
322 intToStr(number, tx_len );
368 intToStr(number, tx_len );
323
369
324 strcpy(tx_buffer,header); //3
370 strcpy(tx_buffer,header); //3
325 strcat(tx_buffer,TypeOfInstrument); //3
371 strcat(tx_buffer,TypeOfInstrument); //3
326 strcat(tx_buffer,parameters.ID); //7
372 strcat(tx_buffer,parameters.ID); //7
327 strcat(tx_buffer,iDSource); //7
373 strcat(tx_buffer,iDSource); //7
328 strcat(tx_buffer,tx_len); //6
374 strcat(tx_buffer,tx_len); //6
329 strcat(tx_buffer,cmd); //4
375 strcat(tx_buffer,cmd); //4
330 strcat(tx_buffer,tx_data); //?
376 strcat(tx_buffer,tx_data); //?
331 strcat(tx_buffer,crc); //1
377 strcat(tx_buffer,crc); //1
332
378
333 }
379 }
334
380
335 }
381 }
336
382
337 /*
383 /*
338 * Esta función genera el archivo de experimento a partir de la trama TCP recibida
384 * Esta función genera el archivo de experimento a partir de la trama TCP recibida
339 */
385 */
340 void recibe_experimento(char *p_data, char filename[]){
386 void recibe_experimento(char *p_data, char filename[]){
341 FILE *fd;
387 FILE *fd;
342 int i = 0;
388 int i = 0;
343
389
344 while (*p_data != '\n'){
390 while (*p_data != '\n'){
345 filename[i] = *p_data;
391 filename[i] = *p_data;
346 i++;
392 i++;
347 p_data++;
393 p_data++;
348 }
394 }
349 filename[i] = '\0';
395 filename[i] = '\0';
350 p_data = p_data - i;
396 p_data = p_data - i;
351 fd = fopen(filename,"w");
397 fd = fopen(filename,"w");
352 fprintf(fd, p_data);
398 fprintf(fd, p_data);
353 fclose(fd);
399 fclose(fd);
354 }
400 }
355
401
356 /*
402 /*
357 * Esta funcion carga un archivo en un buffer que esta ubicado en memoria, luego
403 * Esta funcion carga un archivo en un buffer que esta ubicado en memoria, luego
358 * este buffer es usado en la funcion "cambia_apuntamiento" para obtener el dato
404 * este buffer es usado en la funcion "cambia_apuntamiento" para obtener el dato
359 * que sera usado en el cambio de apuntamiento.
405 * que sera usado en el cambio de apuntamiento.
360 */
406 */
361 int carga_experimento(char *nombre_archivo){
407 int carga_experimento(char *nombre_archivo){
362
408
363 FILE *Archivo_Fd;
409 FILE *Archivo_Fd;
364
410
365 char *cadena = (char *) malloc(25);
411 char *cadena = (char *) malloc(25);
366
412
367 int longitud_cadena;
413 int longitud_cadena;
368 int num_bytes= 0;
414 int num_bytes= 0;
369 int num_filas= 0;
415 int num_filas= 0;
370
416
371 Archivo_Fd = fopen(nombre_archivo,"r"); // Se procede a abrir el archivo, segun la ruta especificada
417 Archivo_Fd = fopen(nombre_archivo,"r"); // Se procede a abrir el archivo, segun la ruta especificada
372 if(!Archivo_Fd){
418 if(!Archivo_Fd){
373 ERROR("carga_archivo: No se pudo abrir el archivo!!! --> fopen()\n");
419 printf("carga_archivo: No se pudo abrir el archivo!!! --> fopen()\n");
420 //ERROR("carga_archivo: No se pudo abrir el archivo!!! --> fopen()\n");
374 return -1;
421 return -1;
375 }else{
422 }else{
376
423
377 while(!feof(Archivo_Fd)){ // Se procede a calcular la longitud del archivo para separar memoria
424 while(!feof(Archivo_Fd)){ // Se procede a calcular la longitud del archivo para separar memoria
378 fgets(cadena,20,Archivo_Fd);
425 fgets(cadena,20,Archivo_Fd);
379 longitud_cadena= strlen(cadena);
426 longitud_cadena= strlen(cadena);
380 cadena[longitud_cadena-1] = '\0';
427 cadena[longitud_cadena-1] = '\0';
381 num_bytes = num_bytes + longitud_cadena;
428 num_bytes = num_bytes + longitud_cadena;
382 num_filas++;
429 num_filas++;
383 }
430 }
384
431
385 rewind(Archivo_Fd); // Se reinicia el puntero del archivo
432 rewind(Archivo_Fd); // Se reinicia el puntero del archivo
386
433
387 char *buffer_temporal = (char *) malloc(num_bytes+1); // Se separa espacio de memoria segun
434 char *buffer_temporal = (char *) malloc(num_bytes+1); // Se separa espacio de memoria segun
388 // la longitud del archivo
435 // la longitud del archivo
389 fread(buffer_temporal, sizeof(char), num_bytes, Archivo_Fd);
436 fread(buffer_temporal, sizeof(char), num_bytes, Archivo_Fd);
390
437
391 char *puntero= strstr(buffer_temporal,".ab1"); // Se procede a eliminar la cabecera del archivo
438 char *puntero= strstr(buffer_temporal,".ab1"); // Se procede a eliminar la cabecera del archivo
392 puntero= puntero + 12;
439 puntero= puntero + 12;
393
440
394 buff_experimento = (char *) malloc(7*(num_filas-3)); // num_bytes_fila*(num_filas-3);
441 buff_experimento = (char *) malloc(7*(num_filas-3)); // num_bytes_fila*(num_filas-3);
395 strncpy(buff_experimento,puntero,7*(num_filas-3)); // Se carga en memoria la informacion del archivo
442 strncpy(buff_experimento,puntero,7*(num_filas-3)); // Se carga en memoria la informacion del archivo
396
443
397 fclose(Archivo_Fd);
444 fclose(Archivo_Fd);
398
445
399 return 1;
446 return 1;
400 }
447 }
401 }
448 }
402
449
403 /*
450 /*
404 * Esta funcion recibe un numero en formato char, el dato se transforma a su equivalente en
451 * Esta funcion recibe un numero en formato char, el dato se transforma a su equivalente en
405 * un numero entero, que sera usado para sacar un dato del buffer "buff_experimento", esta
452 * un numero entero, que sera usado para sacar un dato del buffer "buff_experimento", esta
406 * dato es el valor que se enviara al sistema de conmutacion RF para el cambio de apunte a
453 * dato es el valor que se enviara al sistema de conmutacion RF para el cambio de apunte a
407 * traves del puerto GPIO.
454 * traves del puerto GPIO.
408 */
455 */
409 int cambia_apuntamiento(char *puntero_char){
456 int cambia_apuntamiento(char *puntero_char){
410
457
411 /*MSB-UP-LSB MSB-DOWN-LSB*/
458 /*MSB-UP-LSB MSB-DOWN-LSB*/
412 int desplazamiento[6]={30,28,26,24,22,20}; // Defino los dezplazamientos que se aplicara
459 int desplazamiento[6]={30,28,26,24,22,20}; // Defino los dezplazamientos que se aplicara
413 // al dato que ingresa para formar el número
460 // al dato que ingresa para formar el número
414 // entero que se le pasara al puerto GPIO
461 // entero que se le pasara al puerto GPIO
415 // Estos números son los pines del puerto GPIO
462 // Estos números son los pines del puerto GPIO
416 // que se estan usando para el control
463 // que se estan usando para el control
417
464
418 int puntero= atoi(puntero_char); // Se convierte a entero la direccion del puntero
465 int puntero= atoi(puntero_char); // Se convierte a entero la direccion del puntero
419
466
420 int base= 7*puntero; // base= cantidad_bytes del dato x puntero
467 int base= 7*puntero; // base= cantidad_bytes del dato x puntero
421 // cantidad de bytes es el numero de bytes que
468 // cantidad de bytes es el numero de bytes que
422 printf("%s\n",puntero_char); // contiene cada dato, para este caso es 7
469 printf("%s\n",puntero_char); // contiene cada dato, para este caso es 7
423 // porque es 6 bits de datos + 1 bit del cambio
470 // porque es 6 bits de datos + 1 bit del cambio
424 // de linea.
471 // de linea.
425 char valor_char;
472 char valor_char;
426 unsigned long valor;
473 unsigned long valor;
427 unsigned long acumulado_ceros=0;
474 unsigned long acumulado_ceros=0;
428 unsigned long acumulado_unos=0;
475 unsigned long acumulado_unos=0;
429
476
430 int offset; // Defino offset para el desplazamiento a traves
477 int offset; // Defino offset para el desplazamiento a traves
431 for(offset=0;offset<6;offset++){ // de cada dato que se obtiene del "buff_experimento"
478 for(offset=0;offset<6;offset++){ // de cada dato que se obtiene del "buff_experimento"
432
479
433 valor_char= buff_experimento[base+offset]; // Obtengo el dato
480 valor_char= buff_experimento[base+offset]; // Obtengo el dato
434
481
435 if (valor_char == '0'){ // Obtengo el número acumulado segun sea un cero o un uno
482 if (valor_char == '0'){ // Obtengo el número acumulado segun sea un cero o un uno
436 valor= 0;
483 valor= 0;
437 acumulado_ceros= acumulado_ceros + (1 << desplazamiento[offset]);
484 acumulado_ceros= acumulado_ceros + (1 << desplazamiento[offset]);
438 }else{
485 }else{
439 valor= 1;
486 valor= 1;
440 acumulado_unos= acumulado_unos + (1 << desplazamiento[offset]);
487 acumulado_unos= acumulado_unos + (1 << desplazamiento[offset]);
441 }
488 }
442 }
489 }
443 pio_out(pioc, maskc_out, acumulado_unos, 1);
490 pio_out(pioc, maskc_out, acumulado_unos, 1);
444 pio_out(pioc, maskc_out, acumulado_ceros, 0);
491 pio_out(pioc, maskc_out, acumulado_ceros, 0);
445
492
446 return 1;
493 return 1;
447
494
448 }
495 }
449
496
450 /*
497 /*
451 * Esta funcion lee "n" veces el estado del APUNTE actual y reporta
498 * Esta funcion lee "n" veces el estado del APUNTE actual y reporta
452 * una cadena de Verificacion.
499 * una cadena de Verificacion.
453 */
500 */
454 char* chequeo_sistema(char *filename, char *numero_muestras){
501 char* chequeo_sistema(char *filename, char *numero_muestras){
455
502
456 int i;
503 int i;
457 int cnt = 0;
504 int cnt = 0;
458 unsigned int entradac= 0;
505 unsigned int entradac= 0;
459
506
460 char page0[250];
507 char page0[250];
461
508
462 strcpy(page0,"Verificacion\n");
509 strcpy(page0,"Verificacion\n");
463 strcat(page0,parameters.ID);
510 strcat(page0,parameters.ID);
464 strcat(page0,"\n------------\n");
511 strcat(page0,"\n------------\n");
465
512
466 char page1[8];
513 char page1[8];
467
514
468 do{
515 do{
469 //Inicializando arreglo
516 //Inicializando arreglo
470 for(i=0;i<6;i++)
517 for(i=0;i<6;i++)
471 page1[i]='0';
518 page1[i]='0';
472 page1[6] = '\n';
519 page1[6] = '\n';
473 page1[7] = '\0';
520 page1[7] = '\0';
474 //Lectura de puerto
521 //Lectura de puerto
475 entradac= pio_in(piob,maskb_in);
522 entradac= pio_in(piob,maskb_in);
476 //Dandole formato al dato
523 //Dandole formato al dato
477 if (!(entradac & bit_up_2))
524 if (!(entradac & bit_up_2))
478 page1[0] = '1';
525 page1[0] = '1';
479 if (!(entradac & bit_up_1))
526 if (!(entradac & bit_up_1))
480 page1[1] = '1';
527 page1[1] = '1';
481 if (!(entradac & bit_up_0))
528 if (!(entradac & bit_up_0))
482 page1[2] = '1';
529 page1[2] = '1';
483 if (!(entradac & bit_dow_2))
530 if (!(entradac & bit_dow_2))
484 page1[3] = '1';
531 page1[3] = '1';
485 if (!(entradac & bit_dow_1))
532 if (!(entradac & bit_dow_1))
486 page1[4] = '1';
533 page1[4] = '1';
487 if (!(entradac & bit_dow_0))
534 if (!(entradac & bit_dow_0))
488 page1[5] = '1';
535 page1[5] = '1';
489
536
490 strcat(page0, page1);
537 strcat(page0, page1);
491 cnt=cnt+1;
538 cnt=cnt+1;
492 usleep(1*1000*1000);
539 usleep(1*1000*1000);
493
540
494 }while(cnt < atoi(numero_muestras));
541 }while(cnt < atoi(numero_muestras));
495
542
496 page0[strlen(page0)] = '\0';
543 page0[strlen(page0)] = '\0';
497
544
498 char *all_pages = malloc(strlen(page0)+1);
545 char *all_pages = malloc(strlen(page0)+1);
499 strcpy(all_pages, page0);
546 strcpy(all_pages, page0);
500 return all_pages;
547 return all_pages;
501 }
548 }
502
549
503 /*
550 /*
504 *
551 *
505 */
552 */
506 cmp inicializa_modulo(cmp p){
553 cmp inicializa_modulo(cmp p){
507 FILE *fd = fopen("configuration.txt","r");
554 FILE *fd = fopen("configuration.txt","r");
508 fgets(p.ID,20,fd);
555 fgets(p.ID,20,fd);
509 p.ID[7]='\0';
556 p.ID[7]='\0';
510 fgets(p.param2,20,fd);
557 fgets(p.param2,20,fd);
511 p.param2[10]='\0';
558 p.param2[10]='\0';
512 fgets(p.param3,20,fd);
559 fgets(p.param3,20,fd);
513 p.param3[10]='\0';
560 p.param3[10]='\0';
514 fgets(p.param4,20,fd);
561 fgets(p.param4,20,fd);
515 p.param4[10]='\0';
562 p.param4[10]='\0';
516 fclose(fd);
563 fclose(fd);
517 return p;
564 return p;
518 }
565 }
519
566
520 /*
567 /*
521 *
568 *
522 */
569 */
523 void intToStr( int number, char* str )
570 void intToStr( int number, char* str )
524
571
525 {
572 {
526 int index = 0;
573 int index = 0;
527
574
528 while( number > 0 )
575 while( number > 0 )
529 {
576 {
530 int digit = number%10;
577 int digit = number%10;
531 str[index++] = digit + '0';
578 str[index++] = digit + '0';
532 number /= 10;
579 number /= 10;
533 }
580 }
534 str[index] = '\0';
581 str[index] = '\0';
535 //Adding zero to the left
582 //Adding zero to the left
536 int n= strlen(str);
583 int n= strlen(str);
537 if (n == 1) {
584 if (n == 1) {
538 strcat(str,"00000");
585 strcat(str,"00000");
539 index = index + 5;
586 index = index + 5;
540 }else if(n == 2){
587 }else if(n == 2){
541 strcat(str,"0000");
588 strcat(str,"0000");
542 index = index + 4;
589 index = index + 4;
543 }else if(n == 3){
590 }else if(n == 3){
544 strcat(str,"000");
591 strcat(str,"000");
545 index = index + 3;
592 index = index + 3;
546 }else if(n == 4){
593 }else if(n == 4){
547 strcat(str,"00");
594 strcat(str,"00");
548 index = index + 2;
595 index = index + 2;
549 }else if(n == 5){
596 }else if(n == 5){
550 strcat(str,"0");
597 strcat(str,"0");
551 index = index + 1;
598 index = index + 1;
552 }
599 }
553 //Now reverse the numbers in the string.
600 //Now reverse the numbers in the string.
554 int position;
601 int position;
555 for( position = 0; position <= (index-1)/2; ++position )
602 for( position = 0; position <= (index-1)/2; ++position )
556 {
603 {
557 char tmp = str[position];
604 char tmp = str[position];
558 str[position] = str[(index-1)-position];
605 str[position] = str[(index-1)-position];
559 str[(index-1)-position] = tmp;
606 str[(index-1)-position] = tmp;
560 }
607 }
561 }
608 }
609
610
611 //*****************************************************************
612 //ABS_monitoreo es la funci�n principal del proyecto ABS_Monitoreo.
613 //Esta funci�n es la que se debe agregar en otros c�digos.
614 //*****************************************************************
615 int ABS_monitoreo(int sel_atenuador, int sel_calibracion, float umbral, int pulsewidth){
616
617 //local variables
618 AT91S_PIO *pioc;
619 pioc = pio_map(PIOC_BASE);
620 unsigned int mask_sel_canal =PC4; //Aqu� se indican los pines que se desean usar como salidas. Las constantes PCx est�n defiidas en el header at91gpio.h
621 unsigned int mask_sel_atenuacion =PC5;
622 unsigned int mask_sel_calibracion =PC6;
623 AT91S_ADC *padc;
624 AT91S_ADC *padd;
625 FILE *fp;
626 long int results1[NSAMPLES], results2[NSAMPLES], results3[NSAMPLES], results4[NSAMPLES];
627 unsigned int i=0;
628 char fname[FNAMELEN];
629 int j=0;
630 time_t now;
631 FILE *archivo;
632 float phase1;
633 float phase2;
634 //system("./map_clock");
635
636 if (configCLK() == 1)
637 printf("clock ADC enable.\n");
638
639
640 //configurar tres pines como salida usando als m�scaras mask_sel_canal, mask_sel_atenuacion y mask_sel_calibracion. En este caso corresponden a los pines pc4, pc5 y pc6.
641 pio_enable(pioc, mask_sel_canal);
642 pio_enable(pioc, mask_sel_atenuacion);
643 pio_enable(pioc, mask_sel_calibracion);
644 pio_output_enable(pioc, mask_sel_canal); //configurar pc4 como salida
645 pio_output_enable(pioc, mask_sel_atenuacion); //configurar pc5 como salida
646 pio_output_enable(pioc, mask_sel_calibracion); //configurar pc6 como salida
647
648
649 //Se modifican las salidas correspondientes a la selecci�n del atenuador y calibraci�n, de acuerdo a los par�metros ingresados en la funci�n ABS_monitoreo.
650 pio_out(pioc, mask_sel_atenuacion, sel_atenuador,1);
651 pio_out(pioc, mask_sel_calibracion, sel_calibracion,1);
652
653
654 strcpy (fname, "/mnt/sd/archivos/absmonitoreo.txt"); //Direcci�n y nombre del archivo donde se desea guardar los datos.
655
656 if (fExists(fname)==0){ //si el archivo no existe, crea uno y le asigna el titulo
657 archivo = fopen(fname,"a+");
658 fprintf(archivo,"%s"," Registro de datos del ABS Control \n");
659 fprintf(archivo,"%s"," Fecha y hora Fase UP Fase DOWN\n");
660 fclose(archivo);
661 }
662
663
664 //configure ADC Settings
665 padc=configADC1();
666 padd=configADC2();
667
668 while (1){
669
670 ENABLE_CHANNEL(padc, ADC_CH0+ADC_CH1);
671 printf("\nAdquiriendo datos...\n"); //Indica en el terminal que se est�n adquiriendo datos (muestreando la se�al).
672
673
674 now = time(0); //Get current Time for File Name
675
676
677 //Se pone la salida de selecci�n de canal para seleccionar el canal 1 del detector de fase
678 pio_out(pioc, mask_sel_canal, 0,1);
679
680
681 //Se toman muestras para el canal 1 del detector de fase
682 while(1){
683 for(i=0; i < NSAMPLES; i++){
684
685 ADC_INIT(padc);
686 results1[i] = GET_ADC0(padc);
687 results2[i] = GET_ADC1(padd);
688 }
689
690
691 if (checkTx(results1, results2, umbral, pulsewidth)==1){ //Se verifica que las muestras tomadas del canal 1 del datector de fase //correspondan a un pulso.
692 break;
693 }
694 }
695
696
697 //Se pone la salida de selecci�n de canal para seleccionar el canal 2 del detector de fase
698 pio_out(pioc, mask_sel_canal, 1,1);
699
700
701
702 //Setoman muestras para el canal 2 del detector de fase
703 while(1){
704 for(i=0; i < NSAMPLES; i++){
705
706 ADC_INIT(padc);
707 results3[i] = GET_ADC0(padc);
708 results4[i] = GET_ADC1(padd);
709 }
710
711 if (checkTx(results3, results4, umbral, pulsewidth)==1){ //Se verifica que las muestras tomadas del canal 2 del detector de fase //correspondan a un pulso.
712 break;
713 }
714 }
715
716
717 //Una vez que se ha encontrado un pulso en cada canal, se calcula la fase de ambos.
718
719 phase1 = getPhase(results1, results2); //Calcular la fase del canal 1 del detector de fase.
720 phase2 = getPhase(results3, results4); //Calcular la fase del canal 2 del detector de fase.
721 //create Output File
722
723 strcpy (fname, "/mnt/sd/archivos/absmonitoreo.txt");
724 printf("\nTerminada la prueba # %d \n", j++);
725 fp=create_Output(fname, now); //Coloca la fecha y la hora en el archivo de texto
726 printf("mediana ch1 = %1.2f\n", phase1); //muestra resultado en terminal
727 printf("mediana ch2 = %1.2f\n", phase2); //muestra resultado en terminal
728 writeOutput(phase1, fp); //graba el resultado en el archivo de texto
729 writeOutput(phase2, fp); //graba el resultado en el archivo de texto
730 fprintf(fp, "\n"); //Pasa a la siguiente l�nea del archivo de texto
731 fclose(fp);
732 printf("Resultado guardado en %s \n", fname);
733
734 sleep(1);
735
736 }
737 return 0;
738 }
739 /*=============================================================================
740 Function definitions
741 =============================================================================*/
742
743 // Configures ADC registers in order to get a sample every 10us
744 AT91S_ADC * configADC1(void){
745 //Variables a usar:
746 unsigned int maskc_adc =PC0; //Usamos ADC0 y ADC1
747
748 //configuro pin:
749 AT91S_PIO *pioc;
750 pioc = pio_map(PIOC_BASE);
751 pin_adc_enable(pioc,maskc_adc); //Habilitamos PC0 para usar con ADC0 y 1
752 pio_disable_irq(pioc, maskc_adc);
753 pio_disable_multiple_driver(pioc, maskc_adc);
754 pio_disable_pull_ups(pioc, maskc_adc);
755 pio_input_enable(pioc, maskc_adc);
756
757
758 //Configuro el ADC:
759 AT91S_ADC *padc;
760
761 padc = adc_map1(ADC_BASE);
762
763 //clock ADC = 1MHz
764 //time startup = 8us
765 //time sample and hold = 2us
766 // hold
767 // ___________
768 // start ___________| |___________
769 //
770 // | --1.2us-- | --0.15us-- |
771 //ADC_RESET(padc);
772 CONFIG_ADC(padc,ADC_TRGEN_DIS | ADC_RES_10BIT | ADC_SLEEP_NORMAL_MODE | ADC_PRESCAL | ADC_STARTUP | ADC_SHTIM);
773 ENABLE_CHANNEL(padc,ADC_CH0); //habilito canal 0
774
775
776 return padc;
777 }
778
779 AT91S_ADC * configADC2(void){
780 //Variables a usar:
781 unsigned int maskc_adc =PC1; //Usamos ADC0 y ADC1
782
783 //configuro pin:
784 AT91S_PIO *piod;
785 piod = pio_map(PIOC_BASE);
786 pin_adc_enable(piod,maskc_adc); //Habilitamos PC0 para usar con ADC0 y 1
787 pio_disable_irq(piod, maskc_adc);
788 pio_disable_multiple_driver(piod, maskc_adc);
789 pio_disable_pull_ups(piod, maskc_adc);
790 pio_input_enable(piod, maskc_adc);
791
792 //Configuro el ADC:
793 AT91S_ADC *padd;
794
795 padd = adc_map1(ADC_BASE);
796
797 //clock ADC = 1MHz
798 //time startup = 8us
799 //time sample and hold = 2us
800 // hold
801 // ___________
802 // start ___________| |___________
803 //
804 // | --1.2us-- | --0.15us-- |
805 //ADC_RESET(padc);
806 CONFIG_ADC(padd,ADC_TRGEN_DIS | ADC_RES_10BIT | ADC_SLEEP_NORMAL_MODE | ADC_PRESCAL | ADC_STARTUP | ADC_SHTIM);
807 ENABLE_CHANNEL(padd,ADC_CH1); //habilito canal 1
808 return padd;
809 }
810
811
812 //++++++++++++++++++++
813
814 //creats the output file with a timestamp in the name
815 FILE * create_Output(char *fname, time_t rawtime){
816 FILE *file;
817 char timestamp[80];//, counter[5]="dcv";
818 //char str[4];
819 struct tm * timeinfo;
820
821 //format time
822 timeinfo = localtime ( &rawtime );
823 strftime (timestamp,sizeof(timestamp),"%a %y-%m-%d %H:%M:%S %Z",timeinfo);
824
825
826 //Creates the file name out of the #define parameters
827
828 strcpy (fname, "/mnt/sd/archivos/absmonitoreo.txt");
829 file = fopen(fname,"a+");
830 fprintf(file,"%s", timestamp);
831 //printf("\nTerminada la prueba # %d. Guardando resultado en %s\n",r, fname);
832 //printf("\nTerminada la prueba # %d/%d. Writing data to the file %s\n",r+1 , REP, fname);
833 //printf("\nAAAAAAAAAA %d...%s\n", counter[1], fname);
834 // return file pointer
835 return file;
836 }
837
838 //++++++++++++++++++++
839
840 //tests if a file already exists. returns 1 if it exists and 0 if it doesn't
841
842
843
844 //Funci�n checkTx verifica que la se�al muestreada corresponda a un pulso.
845 //results1 y results2 son los arreglos que contienen los datos muestreados por ambos canales del ADC del embebido.
846 //umbral indica qu� valor debe superar una muestra para considerarla un posible pulso o pico.
847 //pulsewidth indica cu�ntas muestras consecutivas deben superar el umbral para que se considere que se ha detectado un pulso.
848 int checkTx(long int results1[],long int results2[], float umbral, int pulsewidth){
849
850 int i, cont;
851 float z[NSAMPLES], sum, avg;
852 int isSignal, pulse;
853
854 for(i=0;i<NSAMPLES;i++){
855
856 z[i] =sqrt(1.0*results1[i]*results1[i]+1.0*results2[i]*results2[i]);
857 }
858
859 pulse = 0;
860 isSignal = 0;
861 cont =0;
862
863 sum = 0;
864 for(i=0;i<NSAMPLES;i++){
865
866 sum += z[i];
867 avg = sum/(i+1);
868 if ((z[i] - avg) > umbral){
869 if (isSignal == 1){
870 cont += 1;
871 }
872 if (cont == pulsewidth){
873 pulse = 1;
874 break;
875 }
876 isSignal = 1;
877 continue;
878 isSignal = 0;
879 cont = 0;
880 }
881 }
882
883 return pulse; //devuelve un entero: 1 si se ha detectado pulso, de lo contrario, 0.
884 }
885
886
887 int fExists(char * fname){
888 FILE * file;
889
890 file = fopen (fname, "r");
891 if (file == NULL)
892 {
893 return 0;
894 }
895 fclose(file);
896 return 1;
897 }
898
899
900 //Funci�n que calcula la mediana de un conjunto de muestras
901 double mediana(long int *results,unsigned int cuenta){
902 unsigned int i=0,j=0,aux=0;
903
904 double median=0;
905 /*Calculo mediana */
906
907 for(i=0;i<cuenta-1;i++){
908 for (j=i+1;j<cuenta;j++){
909 if(results[i]>results[j] ){
910
911 aux=results[i];
912 results[i]=results[j];
913 results[j]=aux;
914
915 }
916 }
917
918 }
919 median=results[cuenta/2];
920 return median;
921 }
922
923
924
925 //Funci�n que halla la fase de la se�al.
926 //Tiene como entradas las muestras correspondientes a la parte real e imaginaria de la se�al.
927 float getPhase(long int results1[],long int results2[]){
928
929 unsigned int count=0, i=0,umbral=1000;
930 //long int results1[];
931 //long int results2[];
932 long int power[NSAMPLES];
933 long int sumI=0,sumQ=0,I[NSAMPLES], Q[NSAMPLES],II[NSAMPLES], QQ[NSAMPLES];
934 double median1=0,median2=0;
935 long int promedioI=0,promedioQ=0;/*Calculo mediana 1*/
936 float resultado=0;
937
938 for(i=0;i<NSAMPLES;i++){
939
940 I[i] =results1[i];
941 Q[i] =results2[i];
942 }
943
944 /*Calculo mediana 1*/
945 median1=mediana(I,NSAMPLES);
946
947 /*Calculo mediana 2*/
948 median2=mediana(Q,NSAMPLES);
949
950
951
952
953
954
955 for(i=0;i<NSAMPLES;i++){
956
957 I[i] =results1[i];
958 Q[i] =results2[i];
959
960 }
961
962
963
964 for(i = 0; i < NSAMPLES ; i++){
965
966 I[i]=(I[i]-median1);
967 Q[i]=(Q[i]-median2);
968
969 }
970
971 for(i = 0; i < NSAMPLES ; i++){
972
973 power[i]=I[i]*I[i]+Q[i]*Q[i];
974
975 if(power[i] > umbral)
976 {
977
978 II[count]=I[i];
979 QQ[count]=Q[i];
980 count=count+1;
981
982 }
983
984 }
985
986 for(i = 0; i < count ; i++){
987
988 sumI=sumI+II[i];
989 sumQ=sumQ+QQ[i];
990
991 }
992
993 promedioI=sumI;
994 promedioQ=sumQ;
995
996 resultado = atan2(1.0*promedioI,1.0*promedioQ)*180/3.1416+62-44;
997
998
999 return resultado;
1000
1001 }
1002
1003
1004
1005 //Funci�n que muestra la fase detectada en el terminal y tambi�n la graba en el archivo de texto.
1006 void writeOutput(float resultado, FILE * output){
1007
1008
1009 //
1010
1011 fprintf(output," %1.2f ",resultado); //graba resultado en archivo .txt
1012 //
1013
1014 }
1015
1016 int configCLK(){
1017 //configuro pin:
1018 AT91S_PMC *sys_clock;
1019 sys_clock = clock_map(CLOCK_BASE);
1020 enable_clock_adc(sys_clock);
1021 //printf("clock ADC enable.\n");
1022 return 1;
1023 }
Show file before | Show file after | Hide comments
1 NO CONTENT: file was removed
NO CONTENT: file was removed
Show file before | Show file after | Hide comments
1 NO CONTENT: file was removed
NO CONTENT: file was removed
Show file before | Show file after | Hide comments
1 NO CONTENT: file was removed
NO CONTENT: file was removed
Show file before | Show file after | Hide comments
1 NO CONTENT: file was removed
NO CONTENT: file was removed
General Comments 0
You need to be logged in to leave comments. Login now