Mensajes

[gcc -E archivo.c]

const declara un espacio estático de memoria dentro del programa, define es una directiva (macro) de preprocesador que lo que hace es sobreescribir el codigo antes de compilar...

ejemplo de define...

este programa

Código (c) [Seleccionar] Expandir

#define mult( f1, f2 ) ( f1 * f2 )
#define valor 50

int main(){

 int a = 1;
 int b = valor;

 int c = mult(a,b);

 return 0;
}

si estás en linux, puedes usar el comando gcc -E archivo.c para que en lugar de compilar, te muestre el archivo despues de ser pasado por el preprocesador, verás que se covierte en

Código (c) [Seleccionar] Expandir

int main(){

 int a = 1;
 int b = 50;

 int c = ( a * b );

 return 0;
}

y esto ultimo será lo que se compile

ahh perfecto, eso está mas claro!


el leer serial te puede dar algunos dolores de cabeza al principio porque es una conexión en stream

fijate este tema... es en C

el auto usa esto

Código (c) [Seleccionar] Expandir

#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>

int
set_interface_attribs (int fd, int speed, int parity)
{
       struct termios tty;
       memset (&tty, 0, sizeof tty);
       if (tcgetattr (fd, &tty) != 0)
       {
               error_message ("error %d from tcgetattr", errno);
               return -1;
       }

       cfsetospeed (&tty, speed);
       cfsetispeed (&tty, speed);

       tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8;     // 8-bit chars
       // disable IGNBRK for mismatched speed tests; otherwise receive break
       // as \000 chars
       tty.c_iflag &= ~IGNBRK;         // disable break processing
       tty.c_lflag = 0;                // no signaling chars, no echo,
                                       // no canonical processing
       tty.c_oflag = 0;                // no remapping, no delays
       tty.c_cc[VMIN]  = 0;            // read doesn't block
       tty.c_cc[VTIME] = 5;            // 0.5 seconds read timeout

       tty.c_iflag &= ~(IXON | IXOFF | IXANY); // shut off xon/xoff ctrl

       tty.c_cflag |= (CLOCAL | CREAD);// ignore modem controls,
                                       // enable reading
       tty.c_cflag &= ~(PARENB | PARODD);      // shut off parity
       tty.c_cflag |= parity;
       tty.c_cflag &= ~CSTOPB;
       tty.c_cflag &= ~CRTSCTS;

       if (tcsetattr (fd, TCSANOW, &tty) != 0)
       {
               error_message ("error %d from tcsetattr", errno);
               return -1;
       }
       return 0;
}

void
set_blocking (int fd, int should_block)
{
       struct termios tty;
       memset (&tty, 0, sizeof tty);
       if (tcgetattr (fd, &tty) != 0)
       {
               error_message ("error %d from tggetattr", errno);
               return;
       }

       tty.c_cc[VMIN]  = should_block ? 1 : 0;
       tty.c_cc[VTIME] = 5;            // 0.5 seconds read timeout

       if (tcsetattr (fd, TCSANOW, &tty) != 0)
               error_message ("error %d setting term attributes", errno);
}

y para usarlo

Código (c) [Seleccionar] Expandir

char *portname = "/dev/ttyUSB1";
int fd = open (portname, O_RDWR | O_NOCTTY | O_SYNC);
if (fd < 0)
{
       error_message ("error %d opening %s: %s", errno, portname, strerror (errno));
       return;
}

set_interface_attribs (fd, B115200, 0);  // set speed to 115,200 bps, 8n1 (no parity)
set_blocking (fd, 0);                // set no blocking

write (fd, "hello!\n", 7);           // send 7 character greeting

usleep ((7 + 25) * 100);             // sleep enough to transmit the 7 plus
                                    // receive 25:  approx 100 uS per char transmit
char buf [100];
int n = read (fd, buf, sizeof buf);  // read up to 100 characters if ready to read




aquí hay otra solución... una librería en C++ para leer serial

http://libserial.sourceforge.net/


aquí un ejemplo de uso en
lectura
https://github.com/crayzeewulf/libserial/blob/master/examples/read_port.cpp
un ejemplo de uso de escritura
https://github.com/crayzeewulf/libserial/blob/master/examples/write_port.cpp












asegurate de tener permisos de lectura y escritura agregando tu usuario al respectivo grupo del puerto serial usb (usualmente dialout)

si tienes un arduino uno, el ya tiene conexión usb, y por medio de el se comunica en protocolo serial... con buscar en google "ejemplos arduino serial" tienes bastante para probar...

sobre el led con el lm35, es simplemente un analogRead a tu respectivo puerto conectado y comparar con tu umbral, si es mayor cambias el puerto del led a encendido

lee el material sobre lo basico de arduino, esto que propones es literalmente explicación de entrada... y si te trancas en algo o tienes una duda puntual, hazla en este mismo tema

te recomiendo esta lista de videos... informática desde como empezó en papel y toooooodo lo relacionado a las computadoras en muchos aspectos...

la lista:
https://www.youtube.com/watch?v=tpIctyqH29Q&index=1&list=PL8dPuuaLjXtNlUrzyH5r6jN9ulIgZBpdo


el video
[youtube=640,360]https://www.youtube.com/watch?v=tpIctyqH29Q[/youtube]

olvidalo... podrías buscar usar algún programa que te permita mantener una particion cifrada en tu sd... eso si, esto tendrá una carga constante en ram y procesador, lo que se traducirá en lentitud del equipo y reducción del tiempo de la batería

el flood si es mitigable... pero la saturación de red no...

te explico...

el flood se basa en usar paquetes específicos para atacar un servidor (por ejemplo un servidor http) tal que se envían muchas peticiones en busca de saturar la ram o el procesador con paquetes en espera... eso con simplemente bloquear las ip basta...

sin embargo saturación es más como si tu contrincante para evitar que compren en tu tienda manda a mil personas a preguntar a tu puerta... tu puedes prohibirles el paso a tu tienda (tu pc bloqueando el protocolo) pero igual en tu puerta se acumularán bloqueando el paso de clientes legitimos (desde el internet hasta tu modem) es como si tu mismo descargaras un archivo muy pesado a maxima velocidad, tu red se satura por eso mismo... y eso es lo que indicas que es

me han tirado ya veces la conexion mandandome paquetes desde conexiones mas rapidas que la mia

esto no es por ping (icmp)... si lo haces por ping, el atacante se satura más rápido que el atacado (eso se hacía en los años 90 con "el ping de la muerte") pero hoy dia se hace con cualquier paquete con doble objetivo, que sea saturación e inundación (flood a cualquier protocolo)


tu opción es ocultarte tras un servidor que pueda soportar un ataque de saturación (un vpn que seguro tendrá una conexión de 500mbps o más y si tiene problema hará balanceo)

Si se puede bloquear y no afecta

Sin embargo no es la única forma de detectar un equipo (especialmente si se está comunicando en internet a un lugar puntual) el ataque de denegación por saturación de banda, lamentablemente no es mitigable desde el equipo afectado, puedes usar un vpn para evitar el ataque, a cambio de un aumento en la latencia

Hola!

a los dns:
si usas los dns de google, tu pc para obtener la ip del dominio preguntará a google por ellos... listo, fin del proceso... esto sucederá una vez cada algunos minutos...

sobre el tiempo de respuesta, es una mezcla de factores... si, teoricamente entre más lejos, más tardará el paquete... pero tambien influirá la calidad de los equipos del isp y la carga de tu red...

Caché del navegador? Cada vez que recargas limpias el caché?

En chrome la manera simple es recargar presionando ctrl+f5

Has intentado algún tutorial?

Si tienes datos en el disco a particionar es delicado porque puedes perderlos, asegura los datos, crea las particiones con el Linux en live usando gparted y listo...

Que tal si en lugar de usar kali, usas un Linux estable y seguro?