void lpt_windows::dds_word(unsigned int w){ /* transmite un word en serie al dds */
unsigned char i,x;
for(i=0; i<=15; i++){
x=1; /* asume bit = 0 */
if(w&0x8000) x=3;
escritura(x); /* salida con fsync = 0 */
/* pulso de reloj */
x=x&2;
escritura(x);
x=x|1;
escritura(x);
w=w<<1; /* desplazar a la izquierda un bit */
}
escritura(7);
}
void ad_resetear_contador(ad_t ad){
assert(ad != NULL);
direccion(0x0b);
escritura(ad->conf | 0x80);
ad->conf = ad->conf&0x7F;
escritura(ad->conf);
}
void ad_set_modo_ad(ad_t ad){
assert(ad!= NULL);
ad->conf = ad->conf | 0x01;
direccion(0x0b);
escritura(ad->conf);
}
void ad_set_modo_pc(ad_t ad){
assert(ad!= NULL);
ad->conf = ad->conf & 0xFE;
direccion(0x0b);
escritura(ad->conf);
}
void run(std::string miDireccion, std::string direccionRemota)
{
Buffer buffer;
Envio escritura(direccionRemota, &buffer);
Recepcion lectura(miDireccion, &buffer);
std::thread tWrite(escritura);
std::thread tRead(lectura);
tWrite.join();
tRead.join();
}
void lpt_windows::setganancia(unsigned int ga, unsigned int gb)
{
/* clk = d0, rst/ = d1, dq = d2*/
unsigned int i, x, w;
ga = ga & 0xff;
gb = gb & 0xff;
w = (gb * 256) | ga;
x = 2; /* RST =1 (habilitar DS1267)*/
escritura(x);
/* transmite bit de stack =0*/
x = 3;
escritura(x);
x = 2;
escritura(x);
/* transmitir los 16 bits de ganacia*/
for(i=0; i<=15; i++)
{
x= 2; /* asume bit = 0 */
if(w&0x8000) x=6;
escritura(x); /* salida con fsync = 0 */
/* pulso de reloj */
x=x|1;
escritura(x);
x=x&06;
escritura(x);
w=w<<1; /* desplazar a la izquierda un bit */
}
escritura(2);
escritura(0);
}
int32_t hiloEjecucionCPU(t_HiloCPU* paramsCPU)
{
log_info(MemoriaLog,"Esperando pedidos de Cpu \n");
int32_t codigoOperacion;
codigoOperacion = recibirCodigoOperacion(paramsCPU->cpuSocket);
if(codigoOperacion==-1) {
log_error(MemoriaLog, RED"No se recibió correctamente el código de operación\n"RESET);
return EXIT_FAILURE;
}
while(codigoOperacion!=0) {
switch(codigoOperacion) {
case codigo_iniciar:
iniciar(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
case codigo_finalizar:
finalizar(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
case codigo_leer:
lectura(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
case codigo_escribir:
escritura(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
}
codigoOperacion = recibirCodigoOperacion(paramsCPU->cpuSocket);
if(codigoOperacion==-1) {
log_error(MemoriaLog, RED"No se recibió correctamente el código de operación\n"RESET);
return EXIT_FAILURE;
}
}
if(codigoOperacion==0){
log_info(MemoriaLog, "Se desconectó un CPU\n");
bool PorCerrado(sock_t* socket){
return socket->fd==0;
}
int32_t veces = list_count_satisfying(CPUsConectados,(void*)PorCerrado);
int32_t it;
for(it=0; it<veces; it++){
list_remove_and_destroy_by_condition(CPUsConectados, (void*)PorCerrado, (void*)clean_socket);
}
}
int main()
{
ArrayList* lista = al_newArrayList();
ArrayList* repetidos = al_newArrayList();
ArrayList* depurados = al_newArrayList();
int opcion;
char string[20];
do
{
printf("MENU:\n");
printf("1.-Parsear\n");
printf("2.-Completar\n");
printf("3.-Listar\n");
printf("4.-Guardar\n");
printf("5.-Salir\n");
scanf("%d", &opcion);
system("cls");
switch(opcion)
{
case 1:
lectura(lista);
imprimirTodos(lista);
break;
case 2:
completarLetra(lista);
imprimirTodos(lista);
break;
case 3:
printf("Ingrese una palabra: ");
fflush(stdin);
fgets(string, 20, stdin);
filtrarRepetidos(lista, repetidos, string);
repetidos->sort(repetidos, comparar, 1);
imprimirTodos(repetidos);
getchar();
filtrarDepurados(lista, depurados, string);
depurados->sort(depurados, comparar, 0);
imprimirTodos(depurados);
break;
case 4:
escritura(lista, "completo.csv");
escritura(repetidos, "repetidos.csv");
escritura(depurados, "depurados.csv");
break;
case 5:
printf("Programa finalizado\n");
break;
default:
printf("Opcion invalida\n");
break;
}
}
while(opcion != 5);
return 0;
}
void *threadEscritura(void *arg)
{
struct rusage *usage = (struct rusage *)arg;
escritura(usage);
pthread_exit(0);
}
ad_t ad_config (unsigned int mps, unsigned int kpc, unsigned int adqm){
bool result = false;
unsigned char N = 0;
ad_t ad = NULL;
ad = ad_create();
assert(ad!=NULL);
/* Modo PC para configurarlo */
ad_set_modo_pc(ad);
/* Configuracion de la cantidad de muestras por segundo. */
if(mps < 10000000 && mps > 39215){
N = 10000000/mps;
result = direccion(0x0c);
if(!result)
result = escritura(255-N);
if(!result)
result = direccion(0x0d);
if(!result)
result = escritura(0x00);
}else {
printf("Error en la cantidad de muestras por segundo\n");
return NULL;
}
assert(kpc==1 || kpc==2 || kpc==4 || kpc==8 || kpc==16 || kpc==32 || kpc==64);
/* modo continuo -> b1 = 1. Modo modulado -> b1 = 0 */
if(adqm == AD_MODO_CONTINUO){
ad->conf = ad->conf | 0x02;
ad->modo = AD_MODO_CONTINUO;
}
/* Kpc = tamano del buffer de adquisicion en Kb: */
if(kpc==64){
ad->conf = ad->conf|0x70;
}else if(kpc==32){
ad->conf = ad->conf|0x60;
}else if(kpc==16){
ad->conf = ad->conf|0x50;
}else if(kpc==8){
ad->conf = ad->conf|0x40;
}else if(kpc==4){
ad->conf = ad->conf|0x30;
}else if(kpc==2){
ad->conf = ad->conf|0x20;
}else if(kpc==1){
ad->conf = ad->conf|0x10;
}else if(kpc != 0){
result = 1;
}
ad->canala = calloc(kpc*1024, sizeof(int));
ad->canalb = calloc(kpc*1024, sizeof(int));
ad->kpc = kpc;
if(!result)
result = direccion(0x0b);
if(!result){
result = escritura(ad->conf);
}
ad_resetear_contador(ad);
ad_set_modo_ad(ad);
return ad;
}
