summaryrefslogtreecommitdiff
path: root/src/qhyccd
diff options
context:
space:
mode:
Diffstat (limited to 'src/qhyccd')
-rw-r--r--src/qhyccd/QHYCCDCam.rs3
-rw-r--r--src/qhyccd/mod.rs200
2 files changed, 173 insertions, 30 deletions
diff --git a/src/qhyccd/QHYCCDCam.rs b/src/qhyccd/QHYCCDCam.rs
index 960993e..b5911c1 100644
--- a/src/qhyccd/QHYCCDCam.rs
+++ b/src/qhyccd/QHYCCDCam.rs
@@ -1,7 +1,7 @@
use std::os;
#[repr(u32)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
pub enum QHYResult {
QHYCCD_SUCCESS = 0,
QHYCCD_READ_DIRECTLY = 0x2001,
@@ -118,6 +118,7 @@ extern "C" {
bpp: *mut os::raw::c_int) -> os::raw::c_int;
pub fn CancelQHYCCDExposingAndReadout(handle: *mut os::raw::c_void) -> os::raw::c_int;
pub fn ControlQHYCCDTemp(handle: *mut os::raw::c_void, target: os::raw::c_double) -> os::raw::c_int;
+ pub fn SetQHYCCDLogLevel(log_level: os::raw::c_char);
pub fn SetQHYCCDDebayerOnOff(handle: *mut os::raw::c_void, onoff: os::raw::c_int) -> os::raw::c_int;
pub fn SetQHYCCDBinMode(handle: *mut os::raw::c_void, wbin: os::raw::c_int, hbin: os::raw::c_int) -> os::raw::c_int;
pub fn SetQHYCCDBitsMode(handle: *mut os::raw::c_void, bits: os::raw::c_int) -> os::raw::c_int;
diff --git a/src/qhyccd/mod.rs b/src/qhyccd/mod.rs
index 2de1b52..b50ba3a 100644
--- a/src/qhyccd/mod.rs
+++ b/src/qhyccd/mod.rs
@@ -14,8 +14,14 @@ use std::path::Path;
use png::HasParameters;
+unsafe impl Send for Camera { }
#[derive(Debug)]
pub struct Camera {
+ imagew: u32,
+ imageh: u32,
+ bpp: u8,
+ channels: u8,
+ bin: u8,
handle: *mut os::raw::c_void
}
@@ -39,6 +45,21 @@ fn check(result: os::raw::c_int) -> Result<()> {
static mut INITIALIZED: bool = false;
+fn fix_channels(dataslice: &mut [u8]) {
+ for i in 0..(dataslice.len() / 6) {
+ let (b_low, b_high) = (dataslice[i * 6], dataslice[i * 6 + 1]);
+ let tmp2 = dataslice[i * 6 + 1];
+ dataslice[i * 6 + 1] = dataslice[i * 6 + 4];
+ dataslice[i * 6] = dataslice[i * 6 + 5];
+ dataslice[i * 6 + 4] = b_high;
+ dataslice[i * 6 + 5] = b_low;
+
+ let g_low = dataslice[i * 6 + 2];
+ dataslice[i * 6 + 2] = dataslice[i * 6 + 3];
+ dataslice[i * 6 + 3] = g_low;
+ }
+}
+
pub fn acquire(camera_idx: i32) -> Result<Camera> {
unsafe {
if !INITIALIZED {
@@ -62,16 +83,24 @@ pub fn acquire(camera_idx: i32) -> Result<Camera> {
println!("Failed to open the device");
return Err(CameraError::QHYError);
}
- check(QHYCCDCam::SetQHYCCDStreamMode(handle, 1))?; // 0 means single frame mode...
+ check(QHYCCDCam::SetQHYCCDStreamMode(handle, 0))?; // 0 means single frame mode...
check(QHYCCDCam::InitQHYCCD(handle))?;
check(QHYCCDCam::CancelQHYCCDExposingAndReadout(handle))?;
Ok(Camera {
+ imagew: 0,
+ imageh: 0,
+ bpp: 16,
+ bin: 1,
+ channels: 3,
handle: handle
})
}
}
impl Camera {
+ pub fn image_buf_size(&self) -> usize {
+ (self.imagew as usize) * (self.imageh as usize) * (self.bpp as usize / 8) * (self.channels as usize)
+ }
pub fn set_exposure_ms(&self, ms: u32) -> Result<()> {
self.set_param(Control::Exposure, (ms as f64) * 1000.0)
}
@@ -135,32 +164,42 @@ impl Camera {
check(QHYCCDCam::CloseQHYCCD(self.handle))
}
}
- pub fn set_defaults(&self) -> Result<()> {
+ pub fn set_defaults(&mut self) -> Result<()> {
unsafe {
println!("Hey wait gotta get dimensions first");
let ((chipw, chiph), (imagew, imageh), (pixelw, pixelh), bpp) = self.get_dimensions()?;
match QHYCCDCam::IsQHYCCDControlAvailable(self.handle, Control::Color as i32) {
1 | 2 | 3 | 4 => {
check(QHYCCDCam::SetQHYCCDDebayerOnOff(self.handle, 1))?;
- self.set_param(Control::CONTROL_WBR, 20.0)?;
- self.set_param(Control::CONTROL_WBG, 20.0)?;
- self.set_param(Control::CONTROL_WBB, 20.0)?;
+ self.set_param(Control::CONTROL_WBR, 1000.0)?;
+ self.set_param(Control::CONTROL_WBG, 1000.0)?;
+ self.set_param(Control::CONTROL_WBB, 1000.0)?;
},
a @ _ => {
println!("unexpected response when querying color setting: {}", a);
return Err(CameraError::QHYError)
}
}
- check(QHYCCDCam::SetQHYCCDResolution(self.handle, 0, 0, imagew, imageh))?;
- check(QHYCCDCam::SetQHYCCDBinMode(self.handle, 1, 1))?;
+ self.set_roi(0, 0, imagew, imageh)?;
+ self.set_bin_mode(1)?;
if self.has_param(Control::TransferBit) {
check(QHYCCDCam::SetQHYCCDBitsMode(self.handle, 16))?;
+ self.bpp = 16;
}
Ok(())
}
}
- pub fn set_bin_mode(&self, bin: u8) -> Result<()> {
+ pub fn set_roi(&mut self, x: u32, y: u32, w: u32, h: u32) -> Result<()> {
+ unsafe {
+ check(QHYCCDCam::SetQHYCCDResolution(self.handle, x, y, w, h));
+ self.imageh = h;
+ self.imagew = w;
+ Ok(())
+ }
+ }
+
+ pub fn set_bin_mode(&mut self, bin: u8) -> Result<()> {
match bin {
1 => if !self.has_param(Control::Bin1x1Mode) { return Err(CameraError::InvalidControl); }
2 => if !self.has_param(Control::Bin2x2Mode) { return Err(CameraError::InvalidControl); }
@@ -169,7 +208,9 @@ impl Camera {
_ => { return Err(CameraError::InvalidControl); }
}
unsafe {
- check(QHYCCDCam::SetQHYCCDBinMode(self.handle, bin as i32, bin as i32))
+ check(QHYCCDCam::SetQHYCCDBinMode(self.handle, bin as i32, bin as i32))?;
+ self.bin = bin;
+ Ok(())
}
}
@@ -197,6 +238,74 @@ impl Camera {
Ok(())
}
+ pub fn take_image_live(&self, path: &str) -> Result<()> {
+ unsafe {
+ let exposure_duration = self.get_param(Control::Exposure);
+ let exposure_ms = exposure_duration / 1000.0;
+ println!("Exposure duration: {}", exposure_ms);
+
+ let mut bufsize: usize = self.image_buf_size();
+ println!("Ok, we'll need {} bytes...", bufsize);
+
+ let data_layout = Layout::from_size_align(bufsize as usize, 8).unwrap();
+ let data = alloc(data_layout);
+
+ check(QHYCCDCam::BeginQHYCCDLive(self.handle))?;
+
+ loop {
+// println!("Getting data...");
+
+ let mut imagew: i32 = self.imagew as i32;
+ let mut imageh: i32 = self.imageh as i32;
+ let mut bpp: i32 = self.bpp as i32;
+ let mut channels: i32 = self.channels as i32;
+
+// println!("w {} h {} bpp {} channels {}", imagew, imageh, bpp, channels);
+ match check(QHYCCDCam::GetQHYCCDLiveFrame(self.handle, &mut imagew, &mut imageh, &mut bpp, &mut channels, data)) {
+ Ok(()) => {
+ println!("Ok, guess we got it?");
+
+ let mut dataslice: &mut [u8] =
+ unsafe {
+ std::slice::from_raw_parts_mut(
+ data,
+ bufsize as usize
+ )
+ };
+
+ //fix_channels(dataslice);
+
+ let dest = Path::new(path);
+ let file = File::create(dest).unwrap();
+ let ref mut w = BufWriter::new(file);
+ let mut encoder = png::Encoder::new(w, imagew as u32, imageh as u32);
+ encoder.set(png::ColorType::RGB).set(png::BitDepth::Eight);
+ // crazy theory, endianness might be wrong...
+ // so flip the bytes first
+
+ let mut writer = encoder.write_header().unwrap();
+
+ writer.write_image_data(dataslice).unwrap();
+
+ println!("NEXT!");
+
+ QHYResult::QHYCCD_SUCCESS
+ },
+ Err(CameraError::QHYError) => {
+// println!("Error in live capture: {:?}. sleeping..", CameraError::QHYError);
+ println!("Still waiting...");
+ std::thread::sleep(std::time::Duration::from_millis(100));
+ QHYResult::QHYCCD_ERROR
+ }
+ Err(_) => { unreachable!(); }
+ };
+ }
+
+ dealloc(data as *mut u8, data_layout);
+ Ok(())
+ }
+ }
+
pub fn take_image(&self, path: &str) -> Result<()> {
unsafe {
let exposure_duration = self.get_param(Control::Exposure);
@@ -210,7 +319,10 @@ impl Camera {
},
QHYResult::QHYCCD_READ_DIRECTLY => {
println!("Exp complete, example sleeps so i'll sleep too");
- std::thread::sleep(std::time::Duration::from_millis(1000));
+// std::thread::sleep(std::time::Duration::from_millis(1000));
+ },
+ QHYResult::QHYCCD_DELAY_200MS => {
+ println!("Sleeping 200ms...");
},
a @ _ =>{
println!("exp err: {:?}", a);
@@ -218,8 +330,35 @@ impl Camera {
}
}
- let bufsize = QHYCCDCam::GetQHYCCDMemLength(self.handle);
+ let mut chipw: f64 = 0.0;
+ let mut chiph: f64 = 0.0;
+ let mut imagew: i32 = 0;
+ let mut imageh: i32 = 0;
+ let mut pixelw: f64 = 0.0;
+ let mut pixelh: f64 = 0.0;
+ let mut bpp: i32 = 0;
+ check(QHYCCDCam::GetQHYCCDChipInfo(
+ self.handle,
+ &mut chipw as *mut os::raw::c_double,
+ &mut chiph as *mut os::raw::c_double,
+ &mut imagew as *mut os::raw::c_int,
+ &mut imageh as *mut os::raw::c_int,
+ &mut pixelw as *mut os::raw::c_double,
+ &mut pixelh as *mut os::raw::c_double,
+ &mut bpp as *mut os::raw::c_int))?;
+ let mut channels: i32 = 3;
+
+ let mut bufsize = self.image_buf_size();
println!("Ok, we'll need {} bytes...", bufsize);
+ println!("but you claim to want {} bytes...", QHYCCDCam::GetQHYCCDMemLength(self.handle));
+ /*
+ if self.bin != 1 {
+ println!("Correcting for binning...");
+ bufsize /= self.bin as i32;
+ bufsize /= self.bin as i32;
+ println!("you're getting {} bytes!", bufsize);
+ }
+ */
let data_layout = Layout::from_size_align(bufsize as usize, 8).unwrap();
let data = alloc(data_layout);
@@ -227,15 +366,16 @@ impl Camera {
while counter > 0 {
println!("I think there's about {}ms remaining", counter);
+ println!("You think there's about {}ms remaining", self.get_exposure_remaining());
std::thread::sleep(std::time::Duration::from_millis(500));
println!("Camera temp is currently: {}", self.get_param(Control::CurTemp));
counter -= 500;
}
- let mut castediw = 0i32;
- let mut castedih = 0i32;
- let mut castedbpp = 0i32;
- let mut channels = 0;
+ let mut castediw = self.imagew as i32;
+ let mut castedih = self.imageh as i32;
+ let mut castedbpp = self.bpp as i32;
+ let mut channels = self.channels as i32;
println!("Getting data...");
check(QHYCCDCam::GetQHYCCDSingleFrame(self.handle, &mut castediw, &mut castedih, &mut castedbpp, &mut channels, data))?;
println!("Ok, guess we got it?");
@@ -257,21 +397,23 @@ impl Camera {
bufsize as usize
)
};
- for i in 0..(dataslice.len() / 6) {
- let (b_low, b_high) = (dataslice[i * 6], dataslice[i * 6 + 1]);
- let tmp2 = dataslice[i * 6 + 1];
- dataslice[i * 6 + 1] = dataslice[i * 6 + 4];
- dataslice[i * 6] = dataslice[i * 6 + 5];
- dataslice[i * 6 + 4] = b_high;
- dataslice[i * 6 + 5] = b_low;
-
- let g_low = dataslice[i * 6 + 2];
- dataslice[i * 6 + 2] = dataslice[i * 6 + 3];
- dataslice[i * 6 + 3] = g_low;
- }
- println!("the amount of data mod 6: {}", dataslice.len() % 6);
+
+ fix_channels(dataslice);
+
let mut writer = encoder.write_header().unwrap();
- writer.write_image_data(dataslice).unwrap();
+
+ if self.bin != 1 {
+ let scale = self.bin as usize * self.bin as usize;
+ let mut cherrypicked = vec![0; bufsize as usize / scale];
+ for i in 0..cherrypicked.len() / 6 {
+ for j in 0..6 {
+ cherrypicked[i * 6 + j] = dataslice[i * 6 * scale + j];
+ }
+ }
+ writer.write_image_data(&cherrypicked).unwrap();
+ } else {
+ writer.write_image_data(dataslice).unwrap();
+ }
dealloc(data as *mut u8, data_layout);
Ok(())
}
generated by cgit v1.1 at 2024-11-01 06:20:49 +0000