Concurso de fotografía AM

Temática: «Una panorámica de tu acuario».
Ya esta abierto el plazo para presentar fotografías.

Más info
image01

¿Aún no conoces AMA?

Hazte socio de Acuariofilia Madrid Asociación.
CERRADO EL PLAZO DE INSCRIPCIÓN

Más info
image01

Atlas de peces de AM

¡Hemos alcanzado las 800 fichas! Visita nuestro atlas de peces actualizado.

Más info
image01

Cardúmenes y sociabilidad

Nueva actualización de la tabla con una extensa relación de peces, donde podrás conocer qué entorno necesita cada especie, su sociabilidad y si convive o no en cardumen. ¡Pasa a descubrirla!

Mas info
image01
Programación C desde Cero.
Respuestas: 135    Visitas: 47847
#106
Hola Arturos.

ese código es un corta y pega, que puse como ejemplo
de que el código que yo puse se podía mejorar y mucho
pero que por el momento no soy capaz de redadtar(aunque lo entienda)
El que yo redacte esta al principio y ya voy separando las cosas
no se si bien o mal, pero bueno tiempo al tiempo


por otra parte

Ayer modifique el código que puse
y he sustituido. int tcorto=100;
por lo recomendado por Antonio. const int tcorto=100;

y es curioso ver como se reducen los bytes utilizados


Ahora bien he intentado meter en el código, lo que comentaste .#define
y no hay manera.lo ponga como lo ponga me da fallo al compilar -pardon.gif
#107
(25-01-2016, 06:00 PM)rodazac escribió: Hola Arturos.
Ahora bien he intentado meter en el código, lo que comentaste .#define
y no hay manera.lo ponga como lo ponga me da fallo al compilar -pardon.gif
pon el código que te falla
#108
joer. no guarde los intentos -pardon.gif

lo escribo otra vez y lo pongo

primero lo intente a si y nada


Código:
#define  punto  300;
#define  raya   600;
#define  separacion   100;
#define fin   4000;


void setup() { //comienza la configuracion
Serial.begin(9600) ;
pinMode(13, OUTPUT); //configura el pin 13 como de salida
}
void loop() { //comienza el bucle principal del programa

  Serial.println( "Hola" );

digitalWrite(13, HIGH); //envia 5V al pin (salida) 13
delay (punto);//espera
digitalWrite(13, LOW); //envia 0V al pin (salida) 13
delay (separacion);//espera  pin 13 con 0V

digitalWrite(13, HIGH); //envia 5V al pin (salida) 13
delay (punto);//espera
digitalWrite(13, LOW); //envia 0V al pin (salida) 13
delay (separacion);//espera  pin 13 con 0V

digitalWrite(13, HIGH); //envia 5V al pin (salida) 13
delay (punto);//espera
digitalWrite(13, LOW); //envia 0V al pin (salida) 13
delay (separacion);//espera  pin 13 con 0V


digitalWrite(13, HIGH); //envia 5V al pin (salida) 13
delay (raya);//espera
digitalWrite(13, LOW); //envia 0V al pin (salida) 13
delay (separacion);//espera  pin 13 con 0V

digitalWrite(13, HIGH); //envia 5V al pin (salida) 13
delay (raya);//espera
digitalWrite(13, LOW); //envia 0V al pin (salida) 13
delay (separacion);//espera pin 13 con 0V


digitalWrite(13, HIGH); //envia 5V al pin (salida) 13
delay (raya);//espera
digitalWrite(13, LOW); //envia 0V al pin (salida) 13
delay (separacion);//espera pin 13 con 0V

digitalWrite(13, HIGH); //envia 5V al pin (salida) 13
delay (punto);//espera
digitalWrite(13, LOW); //envia 0V al pin (salida) 13
delay (separacion);//espera  pin 13 con 0V

digitalWrite(13, HIGH); //envia 5V al pin (salida) 13
delay (punto);//espera
digitalWrite(13, LOW); //envia 0V al pin (salida) 13
delay (separacion);//espera  pin 13 con 0V

digitalWrite(13, HIGH); //envia 5V al pin (salida) 13
delay (punto);//espera
digitalWrite(13, LOW); //envia 0V al pin (salida) 13

Serial.println( "Adios" );
delay (fin);//espera  pin 13 con 0V


}


después puse esto

#define (punto) 300;
#define (raya) 600;
#define (separacion) 100;
#define (fin) 4000;

y nada
y después como hiciste referencia a un mensaje de Antonio.
ya me lié a poner cosas,como esta #int define (punto) 300; a ver si sonaba
la flauta

saludos
#109
(25-01-2016, 02:29 PM)rodazac escribió: la verdad que no entiendo nada.
esto de que un administrador amenace en publico a usuarios
no se yo.

No estoy amenazando a nadie, simplemente recordando que en el foro, sobran esas contestaciones hacia otros usuarios, como bien interpreta todo el mundo(menos tú).

Si tienes algún problema con la forma que tenemos de llevar el foro lo haces por privado.

Y no hay más que decir, que con contestaciones así hacia un Administrador, también deberías evitarlas sino quieres que tomemos medidas.


Y con ésto, todo queda zanjado, las normas están ahí para todo el mundo y el respeto hacia todos los usuarios es un pilar del foro.













1 saludo
#110
Rodazac

prueba con

#define punto 300
#define raya 600
#define separacion 100
#define fin 4000

Aunque parezca extraño las macros de compilador no deben llevar ; al final
(el mismo las identifica por el # inicial)

Es buena costumbre nombrarlas totalmente en mayúsculas (espacios no deben tener) para no confundirlas con variables y otros mandatos.
#111
(26-01-2016, 12:36 AM)Gwendal escribió:
(25-01-2016, 02:29 PM)rodazac escribió: la verdad que no entiendo nada.
esto de que un administrador amenace en publico a usuarios
no se yo.

No estoy amenazando a nadie, simplemente recordando que en el foro, sobran esas contestaciones hacia otros usuarios, como bien interpreta todo el mundo(menos tú).

Si tienes algún problema con la forma que tenemos de llevar el foro lo haces por privado.

Y no hay más que decir, que con contestaciones así hacia un Administrador, también deberías evitarlas sino quieres que tomemos medidas.


Y con ésto, todo queda zanjado, las normas están ahí para todo el mundo y el respeto hacia todos los usuarios es un pilar del foro.

1 saludo
supongo que aparte de contestarte al MP de toque que me has mandado
podre contestar por aqui.

no voy a entrar en discusiones de si es o deja de ser.
pero lo que si te digo es que yo, cuando veo algo que no esta bien
evidentemente bajo mi punto de vista y mi interpretación lo digo.

y este caso, es uno de ellos . ya que creo que sea puesto en evidencia a dos personas innecesariamente.

pero vamos, pensándolo bien. que necesidad tengo yo de estos berenjenales
y mira. aunque en el MP te he comentado que si veo algo mal lo voy a comentar
sea quien sea el aludido.
pero ya te digo, que eso no va volver a suceder. a partir de ahora ya me cuidare muy mucho de no decir nada.

(26-01-2016, 12:56 AM)ArturoS escribió: Rodazac

prueba con

#define punto 300
#define raya 600
#define separacion 100
#define fin 4000

Aunque parezca extraño las macros de compilador no deben llevar ; al final
(el mismo las identifica por el # inicial)

Es buena costumbre nombrarlas totalmente en mayúsculas (espacios no deben tener) para no confundirlas con variables y otros mandatos.

ya podía estar yo probando cosas
cuando te refieres a los espacios seria "PRIMER_PIN" sustituyendolos por la barra
#112
Si en caso de querer dejarlo claro pones barra baja simulando espacios.
#113
Como bien advierte Arturo, suele ponerse en mayúsculas los idenficadores de muchas macros para darles una visibilidad especial. Es solo una buena costumbre.

Lo importante en el caso de las sentencias de declaración de constantes con una macro '#define' es comprender que el compilador lo que va a hacer es lo siguiente: Antes de compilar expandirá esa instrucción. Cada vez que en el fuente pongamos ese identificador, el precompilador lo sustiturá por el cuerpo de la macro que tengamos definida.

Es decir:

#define PUNTO 300
delay(PUNTO);

se convierte en delay(300);

Eso el compilador lo hace buscando en todo el código y sustituyendo el identificador antes de compilar.

Yo en un programita de morse que hice hace tiempo, declaré algunas constantes como variables de tipo entero.

int DotL = 100; // Duración del punto
int DashL = DotL * 3; // Duracion de la raya
int ElemPause = DotL; // Duracion de la pausa entre elementos puntos o rayas
int Spaces = DotL * 3; // Duracion de pausas entre caracteres
int WordPause = DotL * 7; // Duración de pausas entre palabras.

La idea era respetar la duración relativa de cada cosa según se establece en el código morse.

Lo podría haber declarado con macros (no lo he compilado aún)

#define DOT_L 100
#define DASH_L (DOT_L*3)
#define ELEM_PAUSE DOT_L
#define SPACES (DOT_L*3)
#define WORD_PAUSE (DOT_L*7)

Todos los tiempos quedarían definidos en función de la duración del punto y de esa forma para variar la velocidad de reproducción del código morse bastaría cambiar la duración del punto.

Otra cosa interesante es que mientras se definan las cosas en el orden adecuado puedo definir unas constantes en función de otras previamente definidas.

Ojo no se puede definir nada en función de sí mismo.

Por último, cuando se usa una expresión en una macro, conviene encerrarla dentro de un paréntesis para garantizar que la expresión resultante, use donde se use, no cambiará por culpa de la precedencia de otros operadores cercanos. El producto tiene bastante precedencia y no suele dar problemas pero conviene acostumbrarse a usar los parentesis en estos caso. Los errores provocados por mal uso de macros son algo más difíciles de corregir.

Estas cosas que comento se usan mucho. Podeis probar a cambiar algunas cosas en vuestros programas aplicando algo de esto.

El programita que yo hice no resultaría didactico en este momento porque me diverti metiendo el primer parrafo del Quijote en la PROGMEM y el programa lo reproduciá. Lo puedo publicar completo más adelante cuando hablemos de las funciones macro y de la macro F().
#114
a ver si me aclaro

int punto=300;
el compilador sustituye en todo el programa punto por 300 y ese valor puede ser alterado o modificado...y ocupa mas memoria
que los otros ejemplos
const int punto=300;
el compilador sustituye en todo el programa punto por 300.pero ese valor de 300 no se puede modificar es fijo......y ocupa menos memoria que el anterior

#define PUNTO 300
el valor es sustituido antes de compilar.en los casos anteriores ¿es igual?
y el valor que asignemos ¿puede ser modificado?
lo que si he comprobado.
es que ocupa la misma memoria que const int punto=300;
pero claro en un programa pequeñito. no se si en programas largos sera igual
#115
Veamos

Variable:
int punto = 300
el compilador reserva un espacio en la memoria para contener el valor de la variable, cuyo valor puede cambiar durante la ejecución del programa

Constante:
const int punto = 300
el compilador reserva un espacio en la memoria para almacenar el valor y este no puede ser cambiado durante la ejecución del programa.
No lo se exactamente pero creo que es en otra zona de memoria que ocupa menos y no afecta a un posible desborde.

Macro:
#define punto 300
El compilador sustituye el valor al compilar (al principio) y queda incluido en el código objeto compilado del programa, solo ocupa memoria en el espacio del código de programa que le corresponda.
Además en el procesado como no hay que ir a leer el valor de una variable el procesado será mas ágil.


Lo que ocurre, y si me equivoco que me corrijan, es que como macro solo se pueden asignar valores int, mientras que en variables y constantes hay mas variedad de tipos
#116
Entendido.y un pasito mas,en el mundo arduino.
una cosa. los macros se comportan después de compilar.
igual que las variables "int punto"
(su valor puede cambiar durante la ejecución del programa)
#117
La declaración de una variable hace varias cosas en el compilador. la más importante es como dice Arturo reservar un espacio en memoria para el dato y asociarle un identificador para reconocerla cuando se use en el programa, pero también le proporciona un tipo. Por ejemplo: el compilador, que no intenta adivinar lo que pretendes hacer sino que hace las cosas siempre con una reglas muy estrictas perfectamente previsibles, te permitirá que sumes un int de 16 bits con un long de 32 bits. Son datos enteros y tiene sentido sumarlos y el resultado puede necesitar 32 bits de espacio así que el resultado es un long.

Lo que no te va a permitir es sumar un entero con una cadena de caracteres aunque contenga solo dígitos. Son datos de distinto tipo y la suma entre ellos no está definida. Lo que si se puede hacer es usar alguna función para convertir las cadenas de caracteres que contienen dígitos a un valor entero. Por ejemplo la función atoi(). Además el compilador no permite que uses una variable en cualquier parte salvo que sea una variable global. Si es una variable local. Es decir si la has declarado dentro de una función, solo se puede usar dentro de la función. Cada vez que entras en la función te crea la funcion, hace lo que tenga que hacer con ella y al terminar ese espacio en memora se recupera y la variable se destruye.

Las macros no usan tipos de datos expanden lo que tu pongas. Por ejemplo: si defines una macro como la siguiente:

#define SUMA_RARA 123+"456"

El compilador no protestará por esa definición de macro, pero al expandirla en alguna parte. Por ejemplo en:

VarEntera = SUMA;

Te dará un error en esa línea de código porque la expansíon da lugar a una operación suma que incluye un dato que es una cadena de caracteres.

Algunos datos pueden pueden ser convertidos en datos de otro tipo. Bien sea recurriendo a una función como la de atoi() que acabo de mencionar antes o mediante una conversión directa de tipos con un cast pero para vuestro nivel resultaría un poco lioso introducir este tema. Consiste en poner un nombre de un tipo entre paréntesis antes de un dato para indicar al compilador que antes de hacer nada con ese dato lo transforme al tipo indicado. Por ejemplo:

VarEntera = (int) 5.33;

Este tipo de conversiones entre tipos es mejor dejarlo para más adelante. Si surge la necesidad lo explico un poco más.

La mayoría de las veces usareis el #define para una constante pero si necesitáis usar una expresión necesitais saber como funcionan las macros y que tipos de errores pueden dar al intentar hacer cosas diferentes.
#118
Lo que voy a explicar ahora no es programación básica, pero creo que es necesario comentarlo aunque sea de pasada porque aunque vosotros no lo useis para programar necesitáis saber que es para reconocerlo si os tropezáis con ello.

Podemos definir una macro para que se comporte como lo haría una función.
Las macros que siguen sirven para lo siguiente:

ABS(x) Devuelve el valor absoluto de un entero, es decir para x igua a 5 o para x igual a -5 devolverá el valor positivo 5.

MAX(a,b) Devuelve el valor mayor de los dos.

MDE2(a,b) Devuelve la media de dos valores.

MED3(a,b,c) Devuelve la media de tres valores.

BIGGEST(a,b,c) Devuelve el mayor valor de los tres.

INRANGE(min, i, max) Devuelve true si el valor i está dentro del rango de valores comprendido entre los valores min, max ambos inclusive.

Código:
#define ABS(x)                  (((x) < 0) ? -(x) : (x))
#define MAX(a,b)                ((a < b) ?  (b) : (a))
#define MED2(a,b)               (((a)+(b))/2)
#define MED3(a,b,c)             (((a)+(b)+(c))/3)
#define BIGGEST(a,b,c)          ((MAX(a,b) < c) ?  (c) : (MAX(a,b)))
#define INRANGE(min, i, max)    ((i <= min) || (i >= max) ? 0 : 1)

Son solo ejemplos.

Las macros de este tipo son delicadas de manejar porque pueden provocar problemas si no se usan bien. Las macros funciona por simple expansión de patrones en el código y por ello el compilador no puede verificar si existe un problema de compatibilidad de tipos de datos. Los mensajes de error que se produzcan como resultado de un mal uso de una macro pueden ser poco claros y no ayudar mucho a localizar el fallo.

Dicho esto hay una macro que yo en Arduino me he acostumbrado a usar bastante a menudo. Se trata de la macro F().

Se trata de una macro que permite al compilador guardar un dato en una zona de memoria totalmente diferente a la del resto de los datos.

Para ahorrar memoria SRAM que en Arduino suele ser escasa, recurrimos a usar la memoria FLASH con aquellos datos que son invariables. En la memoria FLASH que es más abundante, es donde se almacena el código del programa una vez compilado y por ello en Arduino se la suele denominar PROGMEM.

La función F() entrega una dirección de memoria PROMEM. Se suele usa mucho para ahorrar memoria con cadenas de caracteres entre comillas dobles.

Si en lugar de usar Serial.println("Hola mundo"); usamos Serial.println(F("Hola mundo")); ahorramos 11 carateres en SRAM.

En C las cadenas de caracteres incluyen siempre un caracter con valor nulo que hace de señal para indican el final de la cadena. de esa forma nos basta pasar la dirección de memoria donde empieza la cadena.

El caso es que la función F("cadena") devuelve un dato que es especial y solo unas pocas funciones entre las cuales se encuentra Serial.print() y Serial.println() son capaces de usarla. Aún así, F("cadena") es muy útil, dado que esas cadenas se usan con frecuencia para ser mandadas a un puerto Serial .

En mis programas vais a ver mucho cosas del tipo Serial.println(F("lo que sea")); porque no me gusta malgastar la poca memoria SRAM del Arduino.

Ya sabéis que F() es una macro y para que sirve.
#119
buenas
estoy enredando con un programa para encender luces mediante el rtc
y el autor, escribe.lineas como estas.

HardwareSerial &pc = Serial;

void setup()

pc.begin(9600);
while(!pc);
pc.println("Comunicacion Serial iniciada");

void loop()

pc.println( d.toString("Y/m/d H:iConfused") );
pc.println("LUZ ENCENDIDA");


yo he eliminado o sustituido las lineas.por estas
y el programa continua funcionando

void setup()
Serial.begin(9600);
Serial.println(F("Comunicacion Serial iniciada"));

void loop()
Serial.println( d.toString("Y/m/d H:iConfused") );
Serial.println( F("LUZ ENCENDIDA") );


¿cuales son las diferencias? de escritura
#120
(08-02-2016, 04:37 PM)rodazac escribió: buenas
estoy enredando con un programa para encender luces mediante el rtc
y el autor, escribe.lineas como estas.

HardwareSerial &pc = Serial;

void setup()

pc.begin(9600);
while(!pc);
pc.println("Comunicacion Serial iniciada");

void loop()

pc.println( d.toString("Y/m/d H:iConfused") );
pc.println("LUZ ENCENDIDA");


yo he eliminado o sustituido las lineas.por estas
y el programa continua funcionando

void setup()
Serial.begin(9600);
Serial.println(F("Comunicacion Serial iniciada"));

void loop()
Serial.println( d.toString("Y/m/d H:iConfused") );
Serial.println( F("LUZ ENCENDIDA") );


¿cuales son las diferencias? de escritura

La diferencia es que él seguramente está pensando en la posibilidad de conmutar todas las entradas y salidas del puerto Serial a un puerto diferente.
Le bastaría con cambiar una línea.

HardwareSerial &pc = Serial1;

Los objetos como por ejemplo Serial pueden ser tratados como si fueran un tipo especial de variables. Lo que ha hecho es sacar una copia del objeto con el nombre pc.

Usuarios navegando en este tema: 2 invitado(s)


Salto de foro: