Sony XPeria. BlueTooth. No se puede asociar vincular. PIN o contraseña incorrectos

He intentando asociar un SmartWatch Sony 3 con un Sony Xperia y me ha sucedido que a la hora de asociar el bluetooth me da un fallo de que no se puede asociar vincular debido a que el PIN o clave son incorrectas. Creo que esto puede suceder debido a que los dispositivos ( como el SmartWatch Sony 3) que permiten asociar sin preguntar la clave de forma explicita en verdad si que la piden solo que suelen ser del tipo 1111 o 0000 y si el dispositivo que se quiere asociar no prueba con esas claves simples entonces falla.

La forma en que he conseguido asociar los dos dispositivos es dandole la vuelta. Es decir, he asociado el SmartWatch Sony 3 con otro dispositivo que si que dejaba vincularse, una vez que el SmartWatch Sony 3 ya permitia usar sus funcionalidades he buscado el Sony Xperia y ha sido el SmartWatch Sony 3 el que se ha vinculado asociado al Sony Xperia.

Una vez conseguido esto ya estan vinculados asociados y ya se pueden usar conjuntamente.

Socket en C++. Visual Studio Express 2015

A continuación se muestra como crear un socket en c++.

Este codigo funciona correctamente en el Visual Studio Express 2015

Este codigo lo he sacado del https://msdn.microsoft.com

#include "stdafx.h"

#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif

#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <iphlpapi.h>
#include <stdio.h>

#pragma comment(lib, "Ws2_32.lib")

struct addrinfo *result = NULL, *ptr = NULL, hints;
#define DEFAULT_PORT "27015"
int main() {

ZeroMemory(&hints, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_flags = AI_PASSIVE;

WSADATA wsaData;
int iResult;

// Initialize Winsock
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != 0) {
printf("WSAStartup failed: %d\n", iResult);
return 1;
}


// Resolve the local address and port to be used by the server
 iResult = getaddrinfo(NULL, DEFAULT_PORT, &hints, &result);
if (iResult != 0) {
printf("getaddrinfo failed: %d\n", iResult);
WSACleanup();
return 1;
}

SOCKET  ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);

if (ListenSocket == INVALID_SOCKET) {
printf("Error at socket(): %ld\n", WSAGetLastError());
freeaddrinfo(result);
WSACleanup();
return 1;
}

iResult = bind(ListenSocket, result->ai_addr, (int)result->ai_addrlen);
if (iResult == SOCKET_ERROR) {
printf("bind failed with error: %d\n", WSAGetLastError());
freeaddrinfo(result);
closesocket(ListenSocket);
WSACleanup();
return 1;
}

freeaddrinfo(result);

if (listen(ListenSocket, SOMAXCONN) == SOCKET_ERROR) {
printf("Listen failed with error: %ld\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
}

SOCKET ClientSocket;


ClientSocket = INVALID_SOCKET;

// Accept a client socket
ClientSocket = accept(ListenSocket, NULL, NULL);
if (ClientSocket == INVALID_SOCKET) {
printf("accept failed: %d\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
}

closesocket(ListenSocket);

char recvbuf[512];
int  iSendResult;
int recvbuflen = 512;

// Receive until the peer shuts down the connection
do {

iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
if (iResult > 0) {
printf("Bytes received: %d\n", iResult);

// Echo the buffer back to the sender
iSendResult = send(ClientSocket, recvbuf, iResult, 0);
if (iSendResult == SOCKET_ERROR) {
printf("send failed: %d\n", WSAGetLastError());
closesocket(ClientSocket);
WSACleanup();
return 1;
}
printf("Bytes sent: %d\n", iSendResult);
}
else if (iResult == 0)
printf("Connection closing...\n");
else {
printf("recv failed: %d\n", WSAGetLastError());
closesocket(ClientSocket);
WSACleanup();
return 1;
}

} while (iResult > 0);


iResult = shutdown(ClientSocket, SD_SEND);
if (iResult == SOCKET_ERROR) {
printf("shutdown failed: %d\n", WSAGetLastError());
closesocket(ClientSocket);
WSACleanup();
return 1;
}
closesocket(ClientSocket);
WSACleanup();
return 0;
}

Incertidumbre de culminación de tareas

Cuando se le asigna una tarea a un programador para que la cumpla (en general voy a hablar de  tareas que lleva varios días culminarla pero también se puede aplicar a tareas pequeñas) hay varias metricas que se usan para evaluar el grado de avance o resultado si ya esta terminada:

• Grado de avance respecto a lo planificado.
• Calidad del desarrollo.
• % de pruebas superadas.
• Revisiones de código.
• etc...

Todas las metricas que se usen se pueden ser mejor o peores para conocer el estado del desarrollo y llevar  a la culminación de la tarea dependiendo de la incertidumbre de culminación de la tarea que presenta el desarrollador encargado de la tarea.

La incertidumbre de culminación de tareas es la probabilidad de que un programador haya implementado una tarea de acuerdo a como el responsable quiere que lo haga.

Cuando el responsable de una tarea piensa (diseña) la tarea no habria mejor persona para acometerla que esa misma persona (no lo va a hacer porque lo que tiene que hacer es diseñarla para que lo haga otros y esa persona pueda hacer otra cosa) y si esa persona acometiera la tarea es casi seguro que al hacerlo se encontrara con realidades (esto es mejor asi, esto asi no sale, etc..) que variarían la forma que tenia pensada en que se acomete la tarea y posiblemente hasta cambios de diseño. Con esta premisa, es lógico pensar que otra persona (un desarrollador) presenta una incertidumbre de culminación de tareas muy alto.

Para evitarlo, es básica la formación continua de los programadores y asegurarse de que comprenden el marco de trabajo que se usa para el desarrollo del proyecto. Pero es muy optimista pensar que con esto vale, se deben usar técnicas con mas supervisión como programación extrema. Quizas la mejor opción es seleccionar un dia al azar y pasar la mayor parte del dia sentado en el sitio del programador, hablar con el, ver como plantea las cosas, que esta haciendo, que es lo que ha entendido, etc.. La claves es asegurarse de que ha entendido el marco de trabajo y que va a culminar la tarea como espera el responsable que se va a resolver.