port = CreateFile(
		string2LPCTSTR(this->portName),	//\\\\.\\COM4"
		GENERIC_READ | GENERIC_WRITE,
		0,								// exclusive access 
		NULL,							// default security attributes 
		OPEN_EXISTING,
		0,
		NULL
	);
	if (port == INVALID_HANDLE_VALUE)
		throw SerialPortNativeIOException("Port value is INVALID_HANDLE_VALUE");
	
	DCB portConfig;
	if (GetCommState(port, &portConfig) == 0){
		closeConnection();
		this->port=INVALID_HANDLE_VALUE;
		throw SerialPortNativeIOException("Error trying to get comm state");
	}

	setPortConfig(portConfig); //Esto simplemente asigna valores...

	if(SetCommState(port, &portConfig)==0){
		closeConnection();
		this->port=INVALID_HANDLE_VALUE;
		throw SerialPortNativeIOException("Error trying to set comm state");
	}
	
	setTimeoutConfig(); //Esto simplemente asigna valores...
	
	if(SetCommTimeouts(port, &timeoutConfig)==0){
		closeConnection();
		this->port=INVALID_HANDLE_VALUE;
		throw SerialPortNativeIOException("Error trying to set comm timeout config.");
	}
	this->connected=true;

...

std::string SerialPortNative::readExisting(){
	ulong readBytes=0;
	OVERLAPPED oR = {0};
	oR.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
	if(!ReadFile(this->port,this->buffer,READEXISTING_BUFFER_SIZE,&readBytes,&oR))
		if(GetLastError() != ERROR_IO_PENDING)
			throw SerialPortNativeIOException("Error reading from serial port");
	return string(this->buffer,0,readBytes);
}

#dentro de ModuloA.py

__INTERPRETER_VERSION = float(sys.version.split(" ")[0])
if(__INTERPRETER_VERSION >= 3):
    from abc import abstractclassmethod

class AAA(object):
....
     if(__INTERPRETER_VERSION < 3):
        @classmethod
        def createPacket(cls, bArray, escaped):
            raise NotImplementedError("This method is not implemented in this class. See inheritance.")
    else:
        @abstractclassmethod
        def createPacket(cls, bArray, escaped):
            pass

(HDC)deviceContext.ToPointer()

//Esta cabecera es para poder usar el método como callback del timer.
void Form1::showMyImage2(Object ^source, ElapsedEventArgs ^e){
try{
		int len = 0;
		unsigned char *c = this->getFrame2((String^)Form1::path + Convert::ToString(this->counter) + ".bmp", len);
		BitmapData ^bmpd = this->bmp->LockBits(Drawing::Rectangle(0, 0,
			this->width, this->height), ImageLockMode::ReadWrite,this->pixelFormat);
		bmpd->Scan0 = (IntPtr)c;
		this->bmp->UnlockBits(bmpd);
		this->picBox->Image = dynamic_cast<Image^>(this->bmp);
                //Esto es para ir cambiando del frame 0 al 1, al 2 ... etc.
		this->counter = (this->counter == 5 ? 0 : this->counter + 1);

	}
	catch (Exception ^e){
		Console::WriteLine(e->InnerException);
		Console::WriteLine(e->Message);
		Console::WriteLine(e->StackTrace);
	}
}

array<unsigned char>^ Form1::getFrame2(String ^path, int %len){
	FileStream ^fs = gcnew FileStream(path, FileMode::Open, FileAccess::Read);
	BinaryReader ^br = gcnew BinaryReader(fs);
	FileInfo ^aux = gcnew FileInfo(path);
	int nBytes = aux->Length;
	Console::WriteLine("long: {0}, int: {1}", nBytes, (int)nBytes);
	array<unsigned char> ^buffer = br->ReadBytes(nBytes);
	len = nBytes;
	pin_ptr<unsigned char> p = &buffer[0];
	unsigned char *p2 = p;
	return p2;
}

//Esta cabcera es por usar este método como callback de un timer.
void AbstractLiveView::updateFrame(Object ^source, EventArgs ^e){
	try{
		this->bmpData = this->bmp->LockBits(Drawing::Rectangle(0, 0, this->width, this->heigth),
			ImageLockMode::ReadWrite, this->pixelFormat);

                //Método abstracto implementado en LiveView (abajo)
		this->bmpData->Scan0 = this->getNextFrame(); 

		this->bmp->UnlockBits(this->bmpData);
		this->picBox->Image = dynamic_cast<Image^>(this->bmp);
		this->picBox->Update();
	}
	catch (Exception ^e){
		Console::WriteLine(e->Message);
		Console::WriteLine(e->StackTrace);
	}
}

void AbstractLiveView::startLiveView(int frequency){
	for (int i = 0; i <= 5; i++){
		this->updateFrame(nullptr,nullptr);
	}
}

//Obtiene el siguiente frame a dibujar (lo coge del disco duro)
IntPtr LiveView::getNextFrame(){
	pin_ptr<unsigned char> p = nullptr;
	try{
		String ^path = pathImage + Convert::ToString(this->counter) + ".bmp";
		FileStream ^fs = gcnew FileStream(path, FileMode::Open, FileAccess::Read);
		BinaryReader ^br = gcnew BinaryReader(fs);
		FileInfo ^aux = gcnew FileInfo(path);
		uint nBytes = aux->Length;
		array<unsigned char> ^buffer = br->ReadBytes(nBytes);
		p = &buffer[0];
		unsigned char *p2 = p;
		this->counter = (this->counter == 5 ? 0 : this->counter + 1);
		return (IntPtr)p;
	}
	catch (Exception ^e){
		Console::WriteLine(e->Message);
		Console::WriteLine(e->StackTrace);
		return (IntPtr)p;
	}

}

void fun(PictureBox pb){
   pb.Image = (Image)this.bitMap; //bitMap es un objeto Bitmap.
}