GENERADOR DIENTE SIERRA

INTRODUCCIÓN:

Una onda de sierra es un tipo de onda no sinusoide. Recibe su nombre porque su

forma se asemeja a la de los dientes de una sierra.
La convención de una onda de sierra es que esta se levanta en forma de rampa y
después baja rectamente. Sin embargo también existen ondas de sierra en donde
las ondas bajan de forma de rampa y después suben rectamente. Esta última
forma usualmente es llamada 'onda de sierra inversa'. En las señales de audio,
ambas direcciones de ondas de sierra suenan de la misma manera
El generador de diente de sierra es una herramienta de gran utilidad para probar
circuitos y equipos de audio, y, también, es muy útil como señal de base de tiempo
o barrido para muchos circuitos

Diferentes tipos de señales

GENERADOR DIENTE SIERRA:

El generador diente sierra se puede generar con diferentes tipos de componentes

como ser :

 Timer 555
 Amplificador operacional OPAM
 Tiristores
 Ardruino
 Pic
 Transistores

En nuestro para generar el diente sierra usaremos transistores de tipo NPN o de

tipo discreto

DIAGRAMA GENERAL

Al tratarse de dos señales sumadas se utilizara dos circuitos paralelos para dores
sumarlos y así generar nuestra señal , previamente a este paso se debe usar un
generador astable para poder excitar nuestro circuito ya que este tipo de
generador diente sierra se activa al ver una señal de flanco de subida de una
señal cuadrada, por lo cual lo excitaremos con una astable discreto ya que
contamos con dos señales de salida Q y Q negada lo cual servirá para excitar
nuestros dos circuitos paralelos paralelos y luego sumar estos
ELEMENTOS DEL GENERADOR DIENTE SIERRA

 Astable.- En electrónica, un astable es un circuito multivibrador que no

tiene ningún estado estable, lo que significa que posee dos estados "casi-
estables" entre los que conmuta, permaneciendo en cada uno de ellos un
tiempo determinado. La frecuencia de conmutación depende, en general,
de la carga y descarga de condensadores.

 Transistor npn BC 548.- El dispositivo viene integrado en un encapsulado

tipo TO-92. El orden de los pines mirando la parte plana del encapsulado
de izquierda a derecha colector, base, emisor.

 Diodo.- Dispositivo electrónico de dos electrodos por el que circula la

corriente en un solo sentido.
 Capacitores.- Es un dispositivo pasivo, utilizado
en electricidad y electrónica, capaz de almacenar energía sustentando
un campo eléctrico. Está formado por un par de superficies conductoras,
generalmente en forma de láminas o placas, en situación de influencia
total (esto es, que todas las líneas de campo eléctrico que parten de una
van a parar a la otra) separadas por un material dieléctrico o por el vacío.3
Las placas, sometidas a una diferencia de potencial, adquieren una
determinada carga eléctrica, positiva en una de ellas y negativa en la otra,
siendo nula la variación de carga total.

 Resistencia.- La resistencia de un conductor depende directamente de

dicho coeficiente, además es directamente proporcional a su longitud
(aumenta conforme es mayor su longitud) y es inversamente proporcional
a su sección transversal (disminuye conforme aumenta su grosor o
sección transversal).
DIAGRAMA DE BLOQUES

CIRCUITO
DIENTE
SIERRA

ASTABLE
SUMADOR

CIRCUITO
DIENTE
SIERRA

CALCULO Y FORMULAS

Vcc − Vd
𝐼=
𝑅
Vcc−0.7
𝐼= (1)
𝑅

I∗t
𝑉𝑐 = (2)
𝐶

Reemplazando 1 en 2

(Vcc−0.7)∗t
𝑉𝑐 = 𝐶𝑅
Si R pequeño, C e I serán grandes y en el retorno Q2 tendrá que tomar una
corriente de descarga grande. Un valor de R en kilohms da I en mA con el orden
correcto de magnitud, así que comience con un algo arbitrario de R=3.3 KΩ

Ri

Ahora C no debe sufrir ninguna descarga significativa durante el barrido hacia

delante por la resistencia de entrada Ri, del seguidor de emisor. por lo tanto , si
CRi = 25 T ms donde T es el tiempo de barrido hacia delante, entonces la
descarga no será mayor de 0,1

25 X 10−3
𝑅𝑖 >=
𝐶

Si Ri = ℎ𝑓𝑒 *Rc

ℎ𝑓𝑒 min =100

𝑅𝑖
Rc = ℎ𝑓𝑒

Cs = 100* C

𝑉𝑅𝐷 = Vgate - 𝑉𝐵𝐸

𝐼𝑐
𝐼𝐵 = ℎ
𝑓𝑒
 𝑣𝑅𝐷
𝑉𝑅𝐷 = 𝐼𝐵

Quedaría de la siguiente manera

PROGRAMACION DEL OSCILOSCOPIO EN ARDRUINO

Ardruino :

Arduino es una plataforma de prototipos electrónica de código abierto (open-

source) basada en hardware y software flexibles y fáciles de usar. Está pensado
para artistas, diseñadores, como hobby y para cualquiera interesado en crear
objetos o entornos interactivos.
Arduino puede sentirel entorno mediante la recepción de entradas desde una
variedad de sensores y puede afectar a su alrededor mediante el control de luces,
motores y otros artefactos. El microcontrolador de la placa se programa usando
el Arduino Programming Language (basado en Wiring) y el Arduino Development
Environment (basado en Processing). Los proyectos de Arduino pueden ser
autonomos o se pueden comunicar con software en ejecución en un
ordenador (por ejemplo con Flash, Processing, MaxMSP, etc.).
Las placas se pueden ensamblar a mano o encargarlas preensambladas; el
software se puede descargar gratuitamente. Los diseños de referencia del
hardware (archivos CAD) están disponibles bajo licencia open-source, por lo que
eres libre de adaptarlas a tus necesidades.
Arduino recibió una mención honoríca en la sección Digital Communities del Ars
Electronica Prix en 2006.

¿Por qué Arduino?

Hay muchos otros microcontroladores y plataformas microcontroladoras

disponibles para computación física. Parallax Basic Stamp, Netmedia’s BX-24,
Phidgets, MIT’s Handyboard, y muchas otras ofertas de funcionalidad similar.
Todas estas herramientas toman los desordenados detalles de la programación de
microcontrolador y la encierran en un paquete fácil de usar. Arduino también
simplifica el proceso de trabajo con microcontroladores, pero ofrece algunas
ventajas para profesores, estudiantes y aaficionados interesados sobre otros
sistemas:

Barato: Las placas Arduino son relativamente baratas comparadas con otras
plataformas microcontroladoras. La versión menos cara del modulo Arduino puede
ser ensamblada a mano, e incluso los módulos de Arduino preensamblados
cuestan menos de 50$.

Multiplataforma: El software de Arduino se ejecuta en sistemas operativos

Windows, Macintosh OSX y GNU/Linux. La mayoría de los sistemas
microcontroladores están limitados a Windows.

Entorno de programación simple y claro: El entorno de programación de Arduino

es fácil de usar para principiantes, pero sucientemente flexible para que usuarios
avanzados puedan aprovecharlo también. Para profesores, está
convenientemente basado en el entorno de programación Processing, de manera
que estudiantes aprendiendo a programar en ese entorno estarán familiarizados
con el aspecto y la imagen de Arduino.
Código abierto y software extensible: El software Arduino está publicado como
herramientas de código abierto, disponible para extensión por programadores
experimentados. El lenguaje puede ser expandido mediante librerias C++, y la
gente que quiera entender los detalles técnicos pueden hacer el salto desde
Arduino a la programación en lenguaje AVR C en el cual está basado. De forma
similar, puedes añadir código AVR-C directamente en tus programas Arduino si
quieres.

Código abierto y hardware extensible: El Arduino está basado en

microcontroladores ATMEGA8 y ATMEGA168 de Atmel. Los planos para los
módulos están publicados bajo licencia Creative Commons, por lo que
diseñadores experimentados de circuitos pueden hacer su propia versión del
módulo, extendiéndolo y mejorándolo. Incluso usuarios relativamente inexpertos
pueden construir la versión de la placa del módulo para entender como funciona y
ahorrar dinero.

Código

// defines for setting and clearing register bits

#ifndef cbi

#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))

#endif

#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))

#endif

//

// pins assignment

//

#define BUILTINLED 13

#define PWM_GENERATOR 11

#define ledPin 13 // LED connected to digital pin 13

//

// globals

//

unsigned char triggerVoltage = 0;

unsigned char lastADC = 0;

unsigned char triggered = 0;

unsigned int DataRemaining = 1500;

unsigned char channel=0;

unsigned char numChannels=1;

unsigned char channels[4];

//

// Commands

//

#define CMD_IDLE 0
#define CMD_RESET 175

#define CMD_PING '?'

#define CMD_READ_ADC_TRACE 170

#define CMD_READ_BIN_TRACE 171

void StartAnalogRead(uint8_t pin)

// set the analog reference (high two bits of ADMUX) and select the

// channel (low 4 bits). this also sets ADLAR (left-adjust result)

// to 0 (the default).

ADMUX = (DEFAULT << 6) | (pin & 0x07);

ADMUX |= _BV(ADLAR);

#if defined(__AVR_ATmega1280__)

// the MUX5 bit of ADCSRB selects whether we're reading from channels

// 0 to 7 (MUX5 low) or 8 to 15 (MUX5 high).

ADCSRB = (ADCSRB & ~(1 << MUX5)) | (((pin >> 3) & 0x01) << MUX5);

#endif

// without a delay, we seem to read from the wrong channel

//delay(1);

// start the conversion

sbi(ADCSRA, ADSC);

}
uint8_t EndAnalogRead()

uint8_t low, high;

// ADSC is cleared when the conversion finishes

while (bit_is_set(ADCSRA, ADSC));

// we have to read ADCL first; doing so locks both ADCL

// and ADCH until ADCH is read. reading ADCL second would

// cause the results of each conversion to be discarded,

// as ADCL and ADCH would be locked when it completed.

uint8_t result = ADCH;

return result;

void setup()

// set prescale to 16

sbi(ADCSRA,ADPS2) ;

cbi(ADCSRA,ADPS1) ;

cbi(ADCSRA,ADPS0) ;

pinMode( PWM_GENERATOR, OUTPUT );

 analogWrite(PWM_GENERATOR, 128);

pinMode( 4, OUTPUT );

pinMode( 5, OUTPUT );

digitalWrite(4, HIGH);

digitalWrite(5, LOW);

//Serial.begin(115200);

Serial.begin(1000000);

for(int i=2;i<8;i++)

pinMode(i, INPUT); // sets the digital pin 7 as input

digitalWrite(i, LOW);

// Serial.begin(1000000);

// Serial.begin(153600);

// Serial.begin(9600);

unsigned char command = 0;

void ProcessSerialCommand( byte in )

{
if ( in == CMD_PING )

Serial.write( 79 ) ;

Serial.write( 67 ) ;

Serial.write( triggerVoltage ) ;

Serial.write( DataRemaining>>8 ) ;

Serial.write( DataRemaining&0xff ) ;

for (int i=0;i<2;i++)

Serial.write( triggerVoltage ) ;

else if ( in == CMD_RESET )

command = CMD_IDLE;

Serial.write( "OK" ) ;

digitalWrite(ledPin, LOW);

else if ( in == CMD_READ_ADC_TRACE )

while( Serial.available() < 9);

triggerVoltage = Serial.read();

DataRemaining = Serial.read()<<8;

DataRemaining |= Serial.read();
 numChannels = Serial.read();

for (int i=0;i<4;i++)

channels[i] = Serial.read();

analogWrite(PWM_GENERATOR, Serial.read());

Serial.write( 85 );

triggered = 0;

//get a fresher value for lastADC

channel = 0;

StartAnalogRead(channels[channel]);

lastADC = EndAnalogRead();

digitalWrite(ledPin, HIGH);

command = CMD_READ_ADC_TRACE;

else if ( in == CMD_READ_BIN_TRACE )

while( Serial.available() < 3);

triggerVoltage = Serial.read();
 DataRemaining = Serial.read()<<8;

DataRemaining |= Serial.read();

analogWrite(9, 64);

analogWrite(10, 128);

analogWrite(11, 192);

triggered = 0;

digitalWrite(ledPin, HIGH);

command = CMD_READ_BIN_TRACE;

Serial.write( 85 );

void loop()

if (Serial.available() > 0)

ProcessSerialCommand( Serial.read() );

if ( command == CMD_READ_ADC_TRACE )

unsigned char v = EndAnalogRead();

 if ( triggered == 0 )

if ( ((v >= triggerVoltage) && ( lastADC < triggerVoltage )) || (triggerVoltage ==

0) )

triggered = 1;

digitalWrite(ledPin, LOW);

else

lastADC = v;

StartAnalogRead(channels[channel]);

return;

channel++;

if ( channel == numChannels )

channel=0;

DataRemaining--;

if ( DataRemaining == 0 )

command = CMD_IDLE;
 }

Serial.write(v);

StartAnalogRead(channels[channel]);

else if ( command == CMD_READ_BIN_TRACE )

unsigned char v = PIND>>2; // remove tx/rx lines

Serial.write(v);

DataRemaining--;

if ( DataRemaining == 0 )

command = CMD_IDLE;