diff --git a/scopehal/RigolOscilloscope.cpp b/scopehal/RigolOscilloscope.cpp
index d1ad9f3..5c1aafd 100644
--- a/scopehal/RigolOscilloscope.cpp
+++ b/scopehal/RigolOscilloscope.cpp
@@ -69,8 +69,8 @@ RigolOscilloscope::RigolOscilloscope(SCPITransport* transport)
 	for(int i = 0; i < nchans; i++)
 	{
 		//Hardware name of the channel
-		string chname = string("CHAN1");
-		chname[4] += i;
+		string chname = string("CH1");
+		chname[2] += i;
 
 		//Color the channels based on Rigol's standard color sequence (yellow-cyan-red-blue)
 		string color = "#ffffff";
@@ -105,12 +105,12 @@ RigolOscilloscope::RigolOscilloscope(SCPITransport* transport)
 	m_channels.push_back(m_extTrigChannel);
 
 	//Configure acquisition modes
-	m_transport->SendCommand("WAV:FORM BYTE");
-	m_transport->SendCommand("WAV:MODE RAW");
+	m_transport->SendCommand(":WAV:FORM BYTE");
+	m_transport->SendCommand(":WAV:MODE RAW");
 	if(m_protocol == MSO5)
 		for(int i = 0; i < 4; i++)
 			m_transport->SendCommand(m_channels[i]->GetHwname() + ":VERN ON");
-	m_transport->SendCommand("TIM:VERN ON");
+	m_transport->SendCommand(":TIM:VERN ON");
 	FlushConfigCache();
 }
 
@@ -472,9 +472,9 @@ double RigolOscilloscope::GetChannelVoltageRange(size_t i)
 	lock_guard<recursive_mutex> lock2(m_mutex);
 
 	if(m_protocol == DS)
-		m_transport->SendCommand(m_channels[i]->GetHwname() + ":RANGE?");
+		m_transport->SendCommand(":" + m_channels[i]->GetHwname() + ":RANGE?");
 	else if(m_protocol == MSO5)
-		m_transport->SendCommand(m_channels[i]->GetHwname() + ":SCALE?");
+		m_transport->SendCommand(":" + m_channels[i]->GetHwname() + ":SCALE?");
 
 	string reply = m_transport->ReadReply();
 	double range;
@@ -523,7 +523,7 @@ double RigolOscilloscope::GetChannelOffset(size_t i)
 
 	lock_guard<recursive_mutex> lock2(m_mutex);
 
-	m_transport->SendCommand(m_channels[i]->GetHwname() + ":OFFS?");
+	m_transport->SendCommand(":" + m_channels[i]->GetHwname() + ":OFFS?");
 
 	string reply = m_transport->ReadReply();
 	double offset;
@@ -551,7 +551,7 @@ Oscilloscope::TriggerMode RigolOscilloscope::PollTrigger()
 {
 	lock_guard<recursive_mutex> lock(m_mutex);
 
-	m_transport->SendCommand("TRIG:STAT?");
+	m_transport->SendCommand(":TRIG:STAT?");
 	string stat = m_transport->ReadReply();
 
 	if(stat == "TD")
@@ -617,10 +617,10 @@ bool RigolOscilloscope::AcquireData(bool toQueue)
 
 		//LogDebug("Channel %zu\n", i);
 
-		m_transport->SendCommand(string("WAV:SOUR ") + m_channels[i]->GetHwname());
+		m_transport->SendCommand(string(":WAV:SOUR ") + m_channels[i]->GetHwname());
 
 		//This is basically the same function as a LeCroy WAVEDESC, but much less detailed
-		m_transport->SendCommand("WAV:PRE?");
+		m_transport->SendCommand(":WAV:PRE?");
 		string reply = m_transport->ReadReply();
 		//LogDebug("Preamble = %s\n", reply.c_str());
 		sscanf(reply.c_str(),
@@ -652,16 +652,16 @@ bool RigolOscilloscope::AcquireData(bool toQueue)
 		{
 			//Ask for the data
 			char tmp[128];
-			snprintf(tmp, sizeof(tmp), "WAV:STAR %zu", npoint + 1);	   //ONE based indexing WTF
+			snprintf(tmp, sizeof(tmp), ":WAV:STAR %zu", npoint + 1);	   //ONE based indexing WTF
 			m_transport->SendCommand(tmp);
 			size_t end = npoint + maxpoints;
 			if(end > npoints)
 				end = npoints;
-			snprintf(tmp, sizeof(tmp), "WAV:STOP %zu", end);	//Here it is zero based, so it gets from 1-1000
+			snprintf(tmp, sizeof(tmp), ":WAV:STOP %zu", end);	//Here it is zero based, so it gets from 1-1000
 			m_transport->SendCommand(tmp);
 
 			//Ask for the data block
-			m_transport->SendCommand("WAV:DATA?");
+			m_transport->SendCommand(":WAV:DATA?");
 
 			//Read block header
 			unsigned char header[12] = {0};
@@ -726,7 +726,7 @@ bool RigolOscilloscope::AcquireData(bool toQueue)
 	if(!m_triggerOneShot)
 	{
 		if(m_protocol == DS)
-			m_transport->SendCommand("TRIG_MODE SINGLE");
+			m_transport->SendCommand(":TRIG_MODE SINGLE");
 		else if(m_protocol == MSO5)
 			m_transport->SendCommand("SING");
 		m_triggerArmed = true;
@@ -741,7 +741,7 @@ void RigolOscilloscope::Start()
 {
 	//LogDebug("Start single trigger\n");
 	lock_guard<recursive_mutex> lock(m_mutex);
-	m_transport->SendCommand("SING");
+	m_transport->SendCommand(":SING");
 	m_triggerArmed = true;
 	m_triggerOneShot = false;
 }
@@ -749,7 +749,7 @@ void RigolOscilloscope::Start()
 void RigolOscilloscope::StartSingleTrigger()
 {
 	lock_guard<recursive_mutex> lock(m_mutex);
-	m_transport->SendCommand("SING");
+	m_transport->SendCommand(":SING");
 	m_triggerArmed = true;
 	m_triggerOneShot = true;
 }
@@ -757,7 +757,7 @@ void RigolOscilloscope::StartSingleTrigger()
 void RigolOscilloscope::Stop()
 {
 	lock_guard<recursive_mutex> lock(m_mutex);
-	m_transport->SendCommand("STOP");
+	m_transport->SendCommand(":STOP");
 	m_triggerArmed = false;
 	m_triggerOneShot = true;
 }
@@ -781,7 +781,7 @@ size_t RigolOscilloscope::GetTriggerChannelIndex()
 	//This is nasty because there are separate commands to see what the trigger source is
 	//depending on what the trigger type is!!!
 	//FIXME: For now assume edge
-	m_transport->SendCommand("TRIG:EDGE:SOUR?");
+	m_transport->SendCommand(":TRIG:EDGE:SOUR?");
 	string ret = m_transport->ReadReply();
 	LogDebug("Trigger source: %s\n", ret.c_str());
 
@@ -802,7 +802,7 @@ size_t RigolOscilloscope::GetTriggerChannelIndex()
 void RigolOscilloscope::SetTriggerChannelIndex(size_t i)
 {
 	lock_guard<recursive_mutex> lock(m_mutex);
-	m_transport->SendCommand("TRIG:EDGE:SOUR " + m_channels[i]->GetHwname());
+	m_transport->SendCommand(":TRIG:EDGE:SOUR " + m_channels[i]->GetHwname());
 	m_triggerChannelValid = false;
 }
 
@@ -818,7 +818,7 @@ float RigolOscilloscope::GetTriggerVoltage()
 	//This is nasty because there are separate commands to see what the trigger source is
 	//depending on what the trigger type is!!!
 	//FIXME: For now assume edge
-	m_transport->SendCommand("TRIG:EDGE:LEV?");
+	m_transport->SendCommand(":TRIG:EDGE:LEV?");
 	string ret = m_transport->ReadReply();
 
 	double level;
@@ -832,7 +832,7 @@ void RigolOscilloscope::SetTriggerVoltage(float v)
 {
 	lock_guard<recursive_mutex> lock(m_mutex);
 	char buf[128];
-	snprintf(buf, sizeof(buf), "TRIG:EDGE:LEV %f", v);
+	snprintf(buf, sizeof(buf), ":TRIG:EDGE:LEV %f", v);
 	m_transport->SendCommand(buf);
 	m_triggerLevelValid = false;
 }
@@ -841,7 +841,7 @@ Oscilloscope::TriggerType RigolOscilloscope::GetTriggerType()
 {
 	if(m_triggerTypeValid)
 		return m_triggerType;
-	m_transport->SendCommand("TRIG:EDGE:SLOPE?");
+	m_transport->SendCommand(":TRIG:EDGE:SLOPE?");
 	string ret = m_transport->ReadReply();
 
 	if(ret == "POS")
@@ -859,13 +859,13 @@ void RigolOscilloscope::SetTriggerType(Oscilloscope::TriggerType type)
 	switch(type)
 	{
 		case Oscilloscope::TRIGGER_TYPE_RISING:
-			m_transport->SendCommand("TRIG:EDGE:SLOPE POS");
+			m_transport->SendCommand(":TRIG:EDGE:SLOPE POS");
 			break;
 		case Oscilloscope::TRIGGER_TYPE_FALLING:
-			m_transport->SendCommand("TRIG:EDGE:SLOPE NEG");
+			m_transport->SendCommand(":TRIG:EDGE:SLOPE NEG");
 			break;
 		case Oscilloscope::TRIGGER_TYPE_CHANGE:
-			m_transport->SendCommand("TRIG:EDGE:SLOPE RFAL");
+			m_transport->SendCommand(":TRIG:EDGE:SLOPE RFAL");
 			break;
 		default:
 			LogError("Invalid trigger type\n");
@@ -955,7 +955,7 @@ uint64_t RigolOscilloscope::GetSampleRate()
 
 	lock_guard<recursive_mutex> lock(m_mutex);
 
-	m_transport->SendCommand("ACQ:SRAT?");
+	m_transport->SendCommand(":ACQ:SRAT?");
 	string ret = m_transport->ReadReply();
 
 	uint64_t rate;
@@ -972,7 +972,7 @@ uint64_t RigolOscilloscope::GetSampleDepth()
 
 	lock_guard<recursive_mutex> lock(m_mutex);
 
-	m_transport->SendCommand("ACQ:MDEP?");
+	m_transport->SendCommand(":ACQ:MDEP?");
 	string ret = m_transport->ReadReply();
 
 	double depth;
@@ -990,26 +990,26 @@ void RigolOscilloscope::SetSampleDepth(uint64_t depth)
 		switch(depth)
 		{
 			case 1000:
-				m_transport->SendCommand("ACQ:MDEP 1k");
+				m_transport->SendCommand(":ACQ:MDEP 1k");
 				break;
 			case 10000:
-				m_transport->SendCommand("ACQ:MDEP 10k");
+				m_transport->SendCommand(":ACQ:MDEP 10k");
 				break;
 			case 100000:
-				m_transport->SendCommand("ACQ:MDEP 100k");
+				m_transport->SendCommand(":ACQ:MDEP 100k");
 				break;
 			case 1000000:
-				m_transport->SendCommand("ACQ:MDEP 1M");
+				m_transport->SendCommand(":ACQ:MDEP 1M");
 				break;
 			case 10000000:
-				m_transport->SendCommand("ACQ:MDEP 10M");
+				m_transport->SendCommand(":ACQ:MDEP 10M");
 				break;
 			case 25000000:
-				m_transport->SendCommand("ACQ:MDEP 25M");
+				m_transport->SendCommand(":ACQ:MDEP 25M");
 				break;
 			case 50000000:
 				if(m_opt200M)
-					m_transport->SendCommand("ACQ:MDEP 50M");
+					m_transport->SendCommand(":ACQ:MDEP 50M");
 				else
 					LogError("Invalid memory depth for channel: %lu\n", depth);
 				break;
@@ -1039,7 +1039,7 @@ void RigolOscilloscope::SetSampleRate(uint64_t rate)
 	m_mdepthValid = false;
 	double sampletime = GetSampleDepth() / (double)rate;
 	char buf[128];
-	snprintf(buf, sizeof(buf), "TIM:SCAL %f", sampletime / 10);
+	snprintf(buf, sizeof(buf), ":TIM:SCAL %f", sampletime / 10);
 	m_transport->SendCommand(buf);
 	m_srateValid = false;
 	m_mdepthValid = false;
@@ -1051,7 +1051,7 @@ void RigolOscilloscope::SetTriggerOffset(int64_t offset)
 
 	double offsetval = (double)offset / 1E12;
 	char buf[128];
-	snprintf(buf, sizeof(buf), "TIM:MAIN:OFFS %f", offsetval);
+	snprintf(buf, sizeof(buf), ":TIM:MAIN:OFFS %f", offsetval);
 	m_transport->SendCommand(buf);
 }
 
@@ -1062,7 +1062,7 @@ int64_t RigolOscilloscope::GetTriggerOffset()
 
 	lock_guard<recursive_mutex> lock(m_mutex);
 
-	m_transport->SendCommand("TIM:MAIN:OFFS?");
+	m_transport->SendCommand(":TIM:MAIN:OFFS?");
 	string ret = m_transport->ReadReply();
 
 	double offsetval;