Tips de lenguaje C

Cuidado, cuidado... No te fíes de lo que estás viendo...

En el código divisor = dividendo/17, ¿has hecho la prueba de cambiar ese 17 por otros valores?

Te vas a sorprender...
 
una preguntota a los super programadores

digamos que cometo la siguiente porqueria:

Código:
switch(dato)
{
case 0xF1:
//codigo
break;

case 0xAA:
//codigo
break;

case 0x01:
//codigo
break;

case 0x11:
//codigo
break;
}

todo bien cochinamente rebolvido

¿afecta la velocidad de ejecucion?

¿y si no le pongo default al switch case?

¿necesito un jalon de orejas?
 
una preguntota a los super programadores

digamos que cometo la siguiente porqueria:

Código:
switch(dato)
{
case 0xF1:
//codigo
break;

case 0xAA:
//codigo
break;

case 0x01:
//codigo
break;

case 0x11:
//codigo
break;
}
todo bien cochinamente rebolvido

¿afecta la velocidad de ejecucion?
No debería, pero depende del código que genere el compilador. La estructura switch se supone que no hace comparación secuencial, y el compilador puede precalcular los saltos por que los case llevan constantes...

¿y si no le pongo default al switch case?
No pasa nada...

¿necesito un jalon de orejas?
Mejor un golpe con un palo en la frente... :LOL: :LOL: :LOL:
 
un golpe!!

otra duda para ahorrar espacio en la placa y costo se me ocurrio meter el audio directo al ADC claro con su respectivo capacitor.

era simple preamplificar la señal segun la norma de un conector RCA debe dar 1vpp pero
como todo mundo sabra aveces el audio esta muy bajo.

se me ocurrio que el valor leido del ADC lo puedo multiplicar por 100 por decir asi

de porsi hise otra porqueria hise PWM a software 15 para ser exactos, el PWM no lo reflejo en los puertos si no en registror de corrimiento y dentro del main tengo varios switch case.

hise puras porquerias lo se.

pero mi duda es la siguiente

ojo necesito regaños de los buenos.

¿es buena idea andar multiplicando el valor leido del ADC?

¿le comeria tiempo al CPU, hay otra manera mas eficiente de hacerlo sin multiplicar?


lo que quiero es hacer que el valor leido del ADC tenga una buena resolucion para meterlo en 1 byte para poder asi mover mi PWM marrano a software
 
Última edición:
Depende de la referencia que uses en el adc va a variar tu resolucion con respecto a la señal que midas. Si la señal es baja como decis 1Vpp pues montala en una continua de 1,25v y la referencia ponela en 2,5v, asi mejoras tu resolucion y no tenes que multiplicar por 100
 
ese es mi problema
debo unirme a la PPA "pesimos programadores anonimos".

paso 1 admitir que tienes un problema.
paso 2 estar convencido de que un Poder Superior podrá ayudarme.
paso 3 decidir poner mi voluntad y mi vida al cuidado de este tema, como nosotros lo concebimos.

y etc y etc.

¿pero no habra manera de corregir mi brutalidad?
digo no habra un modo de hacer una amplificacion a software sin multiplicar
una algoritmo

o terminare metiendo una cochina multiplicacion que no se ve muy afectado pero no me gusta
lo hago para unos LEDS.

se ve bien para un ojo palurdo, pero para un ojo experimentado hay blinking con el ADC.

no todo el tiempo trabaja el ADC en el proyecto, pero ami no me gusta mi cochinada
 
No debería, pero depende del código que genere el compilador. La estructura switch se supone que no hace comparación secuencial, y el compilador puede precalcular los saltos por que los case llevan constantes.
Como regla general, un switch-case se traduce como un conjunto de if-elseif-else en cascada, salvo por la -no- presencia de break, que en ese caso sabemos que la ejecución debe continuar en el código de la siguiente condición.

En el caso propuesto, el código generado será el mismo que cuatro if() en cascada. Si se sabe que 'datos' va a tener solo uno de cuatro valores, pues entonces podemos dejar el último caso con un default, y ahorramos una comparación (si dejamos el cuarto case, el compilador no sabría que solo hay cuatro casos, por lo que siempre haría la comparación).

A veces hay optimizaciones, como cuando las comparaciones se componen de valores consecutivos o repetidos, pero son casos muy raros. Por ejemplo, si tenemos un

switch (datos) {
case 1:
// código
break;
case 2:
// código
break;
case 3:
// código
break;
case 4:
// código
break;
...

el compilador podría generar un código en el que fuera decrementando una copia de datos, y saltar al código correspondiente cuando esa operación sea cero. O incluso generar una tabla de saltos, con una simple multiplicación del valor de datos (esta solución es la que algunos programadores implementan para acelerar el proceso).



lo que quiero es hacer que el valor leido del ADC tenga una buena resolucion para meterlo en 1 byte para poder asi mover mi PWM marrano a software

¿Y cuál es la resolución del ADC?

Si, suponemos, que el ADC tiene 10 bit de resolución, y que el voltaje ocupa todo ese rango (suponemos que alguna vez la entrada al ADC llega al voltaje máximo), entonces el pasarlo a un byte consiste en quedarnos con el byte alto de los dos donde queda guardado el resultado (y además, ajustado a la izquierda).

Me explico: en los ADC de 10, 12, 14 bit, el resultado se guarda en dos registros de 8 bit. Y en un bit de configuración podemos decidir si queremos que lo guarde ajustado hacia la derecha o hacia la izquierda (los bits que faltan hasta completar los 16 bit se rellenan con '0' en el lado contrario).

Ajustando ese valor de configuración para que guarde los 8 bit superiores en el byte alto del resultado, solo tenemos que leerlo, sin tener que hacer ninguna operación más.
 
Última edición por un moderador:
Con respecto a los ADC, hay que entender que si no usamos todo su rango dinamico estamos desperdiciando bits del conversor. Y los bits que se desprecian ya no son recuperables en terminos de SNR.

Si el mal ya esta hecho, lo que es multiplicar, se puede multiplicar en forma burda y rapida por multiplos de dos haciendo simples operaciones de shift que son sumamente rapidas.
 
me gusto la ultima entonces me sugieres que:

tengo esto leido de mi ADC de 10 bits

1.-0000000111
2.-0000000010
3.-0000000101
4.-0000001001

un ejemplo de una secuencia donde apenas lleno un nible

¿lo que puedo hacer es recortar mis 10 bits en 8 bits y hacer trampa rotando y rellenando los huecos con 1?

1.-00011111
2.-00001011
3.-00010111
4.-00100111

me parece una buena idea.

seria asi?
unsigned char valor;

while(1)
{
valor= ADC;
valor= valor<<2 | 00000011;
}

creo que hay que sugerir asi como yo que toque fondo haciendo porquerias

un tema que trate

si yo tambien cometo mis errores y me cuesta trabajo admitirlo
 
pero quedaria asi:

1.-00000010 2
2.-00000001 1
3.-00000011 3
4.-00000100 4
5.-00001011 11

si yo lo recorro 2 casillas se veria asi:

1.-00001000 8
2.-00000100 4
3.-00001100 12
4.-00010000 16
5.-00101100 44

es como si lo multiplicara 4

entonces me imagino que debo rotar y rellenar con 1
en cierto modo para lograr una multiplicacion dejen pienso mi cochino algoritmo
 
Es mejor con ceros porque es mas barato.

Si hubieras diseñado bien el circuito desde el comienzo, para la señal que ahora recibes 2 recibirias 8, o 16, o mas. El hecho de rotar a la izquierda multiplica por dos y llena los bits mas significativos.

Si tuvieras un amplificador como corresponde, en vez de recibir 2 recibirias 8 o 9 o 10 o cualquier otro numero en que incluso los bits menos significativos varian.

Como estas amplificando por SW, no puedes tener resolucion en los bits menos significativos. Eso es lo que decia antes, perdiste SNR y esa perdida es irrecuperable.
 
bueno gracias por sus consejos

creo que mi proyecto no se vera tan afectado total para el ojo palurdo es imperceptible
pero yo si lo noto.

es para unas luces RGB queria que bailaran con el sonido y si lo hace pero hay mucho blinking cuando multiplico, mas bien hago una relacion y pierde mucha velocidad el CPU.

pero apenas me di cuenta que al hacer los PCB no puse referencias y digo al demonio debe haber correccion por software, ya que recurro mas al software que al hardware y sobre todo no sabia como reparar mi error
 
Hola
bueno gracias por sus consejos

creo que mi proyecto no se vera tan afectado total para el ojo palurdo es imperceptible
pero yo si lo noto.

es para unas luces RGB queria que bailaran con el sonido y si lo hace pero hay mucho blinking cuando multiplico, mas bien hago una relacion y pierde mucha velocidad el CPU.

pero apenas me di cuenta que al hacer los PCB no puse referencias y digo al demonio debe haber correccion por software, ya que recurro mas al software que al hardware y sobre todo no sabia como reparar mi error
La pucha siempre te entiendo tarde​
Yo te hubiera dicho ., que no usaras el ADC​
Lo mejor que me resulto .,fue la interupcion externa​
Es mas simple ., y para mover cambios ., es mas rapido​
Pero bueeeee ., ya esta !!!​
 
Última edición:
Atrás
Arriba