How to refactor this huge class?

I have this class that is modeling a sensor with just tons of code. The interface itself is about 70 properties/methods/events and the class is over 2kloc. I've identified an area that could be refactored:

public interface ISensor
{
    event EventHandler<SensorEventArgs> SensorStateChanged;

    // Tons of property getters for the sensor.

    // Refactor concrete Sensor class through these methods.
    void PowerOnNominal();    
    void PowerOffNominal();   
    void PowerOffSpecial();
    void PowerOnSpecial();        

    void OnSensorStateChanged();

    // Tons of methods.    
}

There are 4 PowerOn/PowerOff methods that take up about 800 lines of code. Basically, all they do is change different properties of the sensor at specific time intervals. The properties are used for other things such as simulations and pushing state to the UI.

It's of high probability that there will be other types of PowerOn/PowerOff/Restart simulations which change the Sensor state at different times and rates, so I can't easily combine those methods. What I'd like to do is create another interface like:

public interface IPowerOperations
{
    void PowerOff();
    void PowerOn();
    void Restart();
}

Then, create a separate class for each of the nominal/special power operations and let the sensor class use that depending on what case it is. The problem is that the concrete implementers of the IPowerOperations interface would need to be able to know and change almost all 70 properties on the Sensor class during PowerOn/Off. So basically, the components would need to be very tightly coupled, almost like it was still a part of the Sensor class itself.

Is there any way to go about refactoring this in a better manner?

I'd like to keep the ISensor properties as get only and only allow the IPowerOperations implementers access to the setters...maybe through a different ISensor interface that allows state changes. Is this a bad idea?