Quero ganhar!!!

Preciso me acalmar…
Deste jeito não vou durar muito.
É errado querer ganhar?
Estou com um dedo inchado, com dores no corpo, marcas que vieram vai saber de onde!?
Dei o sangue!
Queria muito isto.
Vi erros ridículos… Errei… Putz. Queria me matar!!!
Mas queria ganhar!!!
Dediquei-me, busquei, gritei… Desanimei.
Não disse para ninguém, mas desanimei.
Quando vi a distancia crescendo e o poder de reação sucumbindo em face a erros atrás de erros… Entreguei-me.
Não estava mais lá. Só o corpo… Entregue.
Abracei meus companheiros e apenas pensei… Não comentei, não julguei.
Vou continuar a ir, jogar… Dedicar-me.
Talvez ano que vem.
Vou começar a me preparar. Preciso ser menos nervoso.

[ ]´s
Francismar|Padawan

Bluetooth

Bluetooth é um padrão de comunicação por rádio de baixo consumo elétrico e curto ou curtíssimo alcance. Os dispositivos podem ser classificados, de acordo com a potência e alcance, em três níveis: classe 1 (100 mW, com alcance de até 100 m), classe 2 (2,5 mW e alcance até 10 m) e classe 3, (1 mW e alcance de 1 m, uma variante muito rara).

*Window$ xp*
Se vc quiser se divertir com BluetoothXXXX API não vá ficar desapontado como eu… Para mim foi complicado, se tiver mais sorte, compartilhe.
A API, infelizmente, é muito limitada. Se quiser procurar por dispositivos e relacioná-los para discagem, funcionarem como modem, está aí a solução. Se não… Winsock
Acessar um equipamento bluetooth utilizando Winsock é bem mais trabalhoso, mas pode fazer muito mais coisas.
Baseado nos samples MSDN style, dá para entender interação de dispositivos e serviços.
Funciona legal quando vc defini onde quer chegar.
Um conselho é olhar as especificações no site www.bluetooth.com. Nos documentos relacionados com Winsock, vai ver que é possivel registrar um profile e então apenas “escutar” e esperar conexões.

// blue.cpp : Defines the entry point for the console application.
//

#include <winsock2.h>
#include <Ws2bth.h>
#include <BluetoothAPIs.h>

#include <stdio.h>

#pragma comment(lib, “ws2_32.lib”)

#pragma comment(lib, “irprops.lib”)

TCHAR *GetLastErrorMessage(DWORD last_error)
{
static TCHAR errmsg[512];

if (!FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
0,
last_error,
0,
errmsg,
511,
NULL))
{
return (GetLastErrorMessage(GetLastError()));
}

return errmsg;
}

BOOL __stdcall callback(
ULONG uAttribId,
LPBYTE pValueStream,
ULONG cbStreamSize,
LPVOID pvParam)
{
// printf(“Callback %d\n”, uAttribId);

SDP_ELEMENT_DATA element;

if (ERROR_SUCCESS != BluetoothSdpGetElementData(pValueStream, cbStreamSize, &element))
{
printf(“%s\n”, GetLastErrorMessage(GetLastError()));
}

return true;
}

int main(int argc, char* argv[])
{
WORD wVersionRequested = 0×202;
WSADATA m_data;

if (0 == ::WSAStartup(wVersionRequested, &m_data))
{
SOCKET s = ::socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);

const DWORD lastError = ::GetLastError();

if (s == INVALID_SOCKET)
{
printf(“Failed to get bluetooth socket! %s\n”, GetLastErrorMessage(lastError));
exit(1);
}

WSAPROTOCOL_INFO protocolInfo;

int protocolInfoSize = sizeof(protocolInfo);

if (0 != getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFO, (char*)&protocolInfo, &protocolInfoSize))
{
exit(1);
}

WSAQUERYSET querySet;

memset(&querySet, 0, sizeof(querySet));

querySet.dwSize = sizeof(querySet);

querySet.dwNameSpace = NS_BTH;

HANDLE hLookup;
DWORD flags = LUP_RETURN_NAME | LUP_CONTAINERS | LUP_RETURN_ADDR | LUP_FLUSHCACHE | LUP_RETURN_TYPE | LUP_RETURN_BLOB | LUP_RES_SERVICE;

int result = WSALookupServiceBegin(&querySet, flags, &hLookup);

if (0 == result)
{
while (0 == result)
{
BYTE buffer[1000];

DWORD bufferLength = sizeof(buffer);

WSAQUERYSET *pResults = (WSAQUERYSET*)&buffer;

result = WSALookupServiceNext(hLookup, flags, &bufferLength, pResults);

if (result != 0)
{
printf(“%s\n”, GetLastErrorMessage(GetLastError()));
printf(“%d\n”, bufferLength);
}
else
{
printf(“%s\n”, pResults->lpszServiceInstanceName);

CSADDR_INFO *pCSAddr = (CSADDR_INFO *)pResults->lpcsaBuffer;

BTH_DEVICE_INFO *pDeviceInfo = (BTH_DEVICE_INFO*)pResults->lpBlob;

WSAQUERYSET querySet2;

memset(&querySet2, 0, sizeof(querySet2));

querySet2.dwSize = sizeof(querySet2);

GUID protocol = L2CAP_PROTOCOL_UUID;

querySet2.lpServiceClassId = &protocol;

querySet2.dwNameSpace = NS_BTH;

char addressAsString[1000];

DWORD addressSize = sizeof(addressAsString);

addressSize = sizeof(addressAsString);

if (0 == WSAAddressToString(pCSAddr->LocalAddr.lpSockaddr, pCSAddr->LocalAddr.iSockaddrLength, &protocolInfo, addressAsString, &addressSize))
{
printf(“local address: %s\n”, addressAsString);
}

addressSize = sizeof(addressAsString);

if (0 == WSAAddressToString(pCSAddr->RemoteAddr.lpSockaddr, pCSAddr->RemoteAddr.iSockaddrLength, &protocolInfo, addressAsString, &addressSize))
{
printf(“device address: %s\n”, addressAsString);
}

querySet2.lpszContext = addressAsString;

HANDLE hLookup2;
DWORD flags = LUP_FLUSHCACHE |LUP_RETURN_NAME | LUP_RETURN_TYPE | LUP_RETURN_ADDR | LUP_RETURN_BLOB | LUP_RETURN_COMMENT;

int result = WSALookupServiceBegin(&querySet2, flags, &hLookup2);

if (0 == result)
{
while (0 == result)
{
BYTE buffer[2000];

DWORD bufferLength = sizeof(buffer);

WSAQUERYSET *pResults = (WSAQUERYSET*)&buffer;

result = WSALookupServiceNext(hLookup2, flags, &bufferLength, pResults);

if (result != 0)
{
printf(“%s\n”, GetLastErrorMessage(GetLastError()));
printf(“%d\n”, bufferLength);
}
else
{
printf(“%s\n”, pResults->lpszServiceInstanceName);
//printf(“%s\n”, pResults->lpszComment);

CSADDR_INFO *pCSAddr = (CSADDR_INFO *)pResults->lpcsaBuffer;

addressSize = sizeof(addressAsString);

if (0 == WSAAddressToString(pCSAddr->LocalAddr.lpSockaddr, pCSAddr->LocalAddr.iSockaddrLength, &protocolInfo, addressAsString, &addressSize))
{
printf(“local address: %s\n”, addressAsString);
}

addressSize = sizeof(addressAsString);

if (0 == WSAAddressToString(pCSAddr->RemoteAddr.lpSockaddr, pCSAddr->RemoteAddr.iSockaddrLength, &protocolInfo, addressAsString, &addressSize))
{
printf(“device address: %s\n”, addressAsString);
}

if (pResults->lpBlob)
{
const BLOB *pBlob = (BLOB*)pResults->lpBlob;

if (!BluetoothSdpEnumAttributes(pBlob->pBlobData, pBlob->cbSize, callback, 0))
{
printf(“BluetoothSdpEnumAttributes – %s\n”, GetLastErrorMessage(GetLastError()));
}

}

}
}

result = WSALookupServiceEnd(hLookup2);

}
else
{
printf(“%s\n”, GetLastErrorMessage(GetLastError()));
}

}
}

result = WSALookupServiceEnd(hLookup);
}
else
{
printf(“%s\n”, GetLastErrorMessage(GetLastError()));
}

WSACleanup();
}

HANDLE hRadio;
BLUETOOTH_FIND_RADIO_PARAMS btfrp = { sizeof(btfrp) };

HBLUETOOTH_RADIO_FIND hFind = BluetoothFindFirstRadio( &btfrp, &hRadio );

if ( NULL != hFind )
{
printf(“hFind\n”);

do
{
//
// TODO: Do something with the radio handle.
//

BLUETOOTH_RADIO_INFO radioInfo;

radioInfo.dwSize = sizeof(radioInfo);

if (ERROR_SUCCESS == BluetoothGetRadioInfo(hRadio, &radioInfo))
{
wprintf(L”Raido: %s\n”, radioInfo.szName);
}

BLUETOOTH_DEVICE_INFO_STRUCT deviceInfo;

deviceInfo.dwSize = sizeof(deviceInfo);

BLUETOOTH_DEVICE_SEARCH_PARAMS deviceSearchParams;

memset(&deviceSearchParams, 0, sizeof(deviceSearchParams));

deviceSearchParams.dwSize = sizeof(deviceSearchParams);

//deviceSearchParams.fReturnAuthenticated = true;
deviceSearchParams.fReturnRemembered = true;
//deviceSearchParams.fReturnUnknown = true;
//deviceSearchParams.fReturnConnected = true;

deviceSearchParams.hRadio = hRadio;

HANDLE hDeviceFind = BluetoothFindFirstDevice(&deviceSearchParams, &deviceInfo);

if (NULL != hDeviceFind)
{
do
{
wprintf(L”Device: %s\n”, deviceInfo.szName);

//BluetoothDisplayDeviceProperties(0, &deviceInfo);
}
while(BluetoothFindNextDevice(hDeviceFind, &deviceInfo));

BluetoothFindDeviceClose(hDeviceFind);
}

if (BluetoothGetDeviceInfo(hRadio, &deviceInfo))
{
wprintf(L”+ Device: %s\n”, deviceInfo.szName);

// BluetoothUpdateDeviceRecord – change name

// BluetoothRemoveDevice

}

GUID guidServices[10];

DWORD numServices = sizeof(guidServices);

DWORD result = BluetoothEnumerateInstalledServices(hRadio, &deviceInfo, &numServices, guidServices);

CloseHandle( hRadio );
} while( BluetoothFindNextRadio( hFind, &hRadio ) );

BluetoothFindRadioClose( hFind );
}

return 0;
}

Testa aí, vê o que vira.

Indicação de literatura:

Descobrindo Bluetooth
Autor: Michael Miller
Editora: Campus
Nº de páginas: 304
Publicação: 10/2001
Idioma: Português

[ ]´s
Francismar|Padawan

PoE – Power over Ethernet

(tks Veiga)
Fornecer alimentação elétrica para equipamentos de rede, nem sempre é uma tarefa fácil. Muitas vezes, não contamos com uma rede elétrica ali do lado.
Desde Junho de 2003 que a norma IEEE 802.3af especifica a alimentação de equipamentos através do cabo Ethernet.
Segundo a norma 802.3af, o equipamento que injecta a electricidade no cabo – chamado de Power Sourcing Equipment (PSE) – tem de fornecer uma tensão constante de 48V e que venha de um comutador Ethernet especificamente concebido para esse fim.
O PSE verifica se os terminais podem receber esta alimentação, regula os parâmetros e estabelece a conexão em menos de 10ms. Além disso, a interrupção do fornecimento de energia, impede que os equipamentos sejam queimados por erro.
Ainda não conhecia.

[ ]´s
Francismar|Padawan

1ª KartRace dos amigos

Ontem fomos no GO KART, localizado no Novo Shopping-Rib.Preto, para uma corridinha.
Como ainda temos que ir para faculdade, saímos do trabalho direto para lá.
Foram os R$22,00/30min. (promoção) mais bem empregados dos ultimos meses.
Assinamos o termo (que lugar que não tem?) e fomos ver o vídeo.
Neste vídeo foi mostrado as regras, o que cada bandeira significa e como se comportar dentro kart.
Escolhemos o capacetes, kart e pau na máquina!
5 minutos para classificação no bom estilo SuperPole da F1.
Depois é formado o GRID e começa a emoção.
Pontos positivos: Os karts tem 200cc e seguram bem nas curvas.
Pontos negativos: acento liso que faz vc ficar deslizando de um lado para outro e direção bem dura.
Minha equipe falhou e acabei ficando na penultima posição. Meu kart começou a engasgar quando eu pisava fundo.
Jà meu amigo Daniel… Teve um dia de brasileiro na F1. Furou o pneu e a equipe demorou para preparar o carro reserva.
Vale a pena!!!
O Record da pista (volta mais rápida até hoje registrada) é de 23.180 s.

Classificação após 52 voltas:
Pos…Nr…Name………….Fastest in lap
1…..07…Bruno…………24.780….11
2…..10…Matheus……….26.950….43
3…..08…Wallace……….25.990….47
4…..04…Busquini………28.310….34
5…..02…Franz (Eu )…27.720….42
6…..05…Daniel………..26.380….20

[ ]´s
Francismar|Padawan

Endereço da placa ETH via Python

*linux*

import socket
import fcntl
import string
import sys
import exceptions

def getINTF():
f = open(“/proc/net/dev”)
ret = []
iflist = f.readlines()
f.close()
for line in iflist:
if ‘:’ not in line:
continue
words=string.split(line,’:')
ifname, rest = words[0],words[1:]
ifname = string.strip(ifname)
ret.append(ifname)
return ret

def hexy(n):
return “%02x” % (ord(n))

def getMAC(ifname):
SIOCGIFHWADDR = 0×8927 # magic number
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ifname = string.strip(ifname)
ifr = ifname + ”*(32-len(ifname))
try:
r= fcntl.ioctl(s.fileno(),SIOCGIFHWADDR,ifr)
addr = map(hexy,r[18:24])
ret = (‘:’.join(map(str, addr)))
except IOError, e:
ret = ”
return ret

list = getINTF()
for i in list:
print i, getIP(i), getMAC(i), getUP(i)