Надо передать данные из одной формы в другую, возникает ошибка ("Необработанное исключение типа "System.NullReferenceException" в GeoForm.exe  Дополнительные сведения: Ссылка на объект не указывает на экземпляр объекта.")

public partial class Form1 : Form
    {
        MainForm mainForm;

        public Form1()
        {
            InitializeComponent();
        }

        public string Text1 { get; set; }
        public string Text2 { get; set; }
        public string Text3 { get; set; }
        public string Text4 { get; set; }

        private void textBox1_TextChanged(object sender, EventArgs e)
        {
            Text1 = textBox1.Text;
        }

        private void textBox2_TextChanged(object sender, EventArgs e)
        {
            Text2 = textBox2.Text;
        }

        private void textBox3_TextChanged(object sender, EventArgs e)
        {
            Text3 = textBox3.Text;
        }

        private void textBox4_TextChanged(object sender, EventArgs e)
        {
            Text4 = textBox4.Text;
        }
        private void button1_Click(object sender, EventArgs e)//ок
        {
            List<string> str = new List<string>();
            str.Add(Text1);
            str.Add(Text2);
            str.Add(Text3);
            str.Add(Text4);
            mainForm = new MainForm();
            MyEvent evnt = new MyEvent();
            evnt.OkEvent += new EventHandler<MyEventArgs>(mainForm.createProjectsForm1);
            evnt.OnOkEvent(str);
            Hide();
        }

        private void button2_Click(object sender, EventArgs e)//отмена
        {
            Text1 = "";
            Text2 = "";
            Text3 = "";
            Text4 = "";
            Hide();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Text1 = "";
            Text2 = "";
            Text3 = "";
            Text4 = "";
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            e.Cancel = true;
            Hide();
        }
    }
}

 static class Program
    {
        /// <summary>
        /// Главная точка входа для приложения.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Model model1 = new Model();
            MainForm view1 = new MainForm();
            Controller cnt1 = new Controller(view1, model1);
            Application.EnableVisualStyles();
            Application.Run(view1);
        }
    }

    public partial class MainForm : Form, IView, IModelObserver
    {
       IController controller;

       bool continueRecord = false;
       bool defaultPortConnect = false;
       LineItem currentCurve = null;
       PointPair firstPoint = null;
       bool openPort = false;
       bool startDrawing = false;
       int drawingPointCount = 0;

    public void setController(IController cont)
    {
        controller = cont;
    }

    Form Form1;

    public MainForm()
    {
        InitializeComponent();
        zedGraph.IsEnableZoom = flse;
        zedGraph.ContextMenuStrip.Dispose();
        DrawFirstList(zedGraph);
    }

    private void MainForm_Load(object sender, EventArgs e)
    {
        labelPressure.Text = "0,0";
        pictureBox2.Visible = true;
        btnRecord.Enabled = false;
        try
        {
            controller.GetDefaultPort();
        }
        catch
        {
            MessageBox.Show("COM-портов не обнаружено!", "Внимание!", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }
    private void toolStripMenuItem1_Click(object sender, EventArgs e)
    {
        string newNameStr;
        Form1.Input1(out newNameStr);
        Form1 = new Form1();
        Form1.Owner = this;
        Form1.Show();
    }

    public  void createProjectsForm1(object sender, MyEventArgs e)
    {
        controller.CreateProjects(e.textBox);// ошибка
    }

}

namespace GeoForm
{
    delegate void ModelHandler<IModel>(IModel sender, EventArgs e);
    delegate void ModelHandlerGetDefaultPort<IModel>(IModel sender, ModelEventGetDefaultPort e);
    delegate void ModelHandlerComConnect<IModel>(IModel sender, ModelEventComConnect e);
    delegate void ModelHandlerSaveReport<IModel>(IModel sender, ModelEventSaveReport e);
    delegate void ModelHandlerTimeRecord<IModel>(IModel sender, ModelEventTimeRecord e);
    delegate void ModelHandlerBeginRecord<IModel>(IModel sender, ModelEventBeginRecord e);
    delegate void ModelHandlerPortClosed<IModel>(IModel sender, ModelEventPortClosed e);
    delegate void ModelHandlerCreateProjects<IModel>(IModel sender, CreateProjectsEventArgs e);

    public class CreateProjectsEventArgs
    {
        List<string> text = new List<string>();
        List<double> value = new List<double>();
        List<double> dataTime = new List<double>();
        public CreateProjectsEventArgs(List<string> text, List<double> dataTime, List<double> value)
        {
            this.text = text;
            this.value = value;
            this.dataTime = dataTime;
        }
    }

    public class ModelEventPortClosed
    {
        public ModelEventPortClosed()
        { }
    }

    public class ModelEventGetDefaultPort
    {
        public string defaultPort;

        public ModelEventGetDefaultPort(string defaultPort)
        {
            this.defaultPort = defaultPort;
        }
    }

    public class ModelEventBeginRecord
    {
        public PointPair currentPoint;
        public Int32 currentCount;

        public ModelEventBeginRecord(PointPair currentPoint, Int32 currentCount)
        {
            this.currentPoint = currentPoint;
            this.currentCount = currentCount;
        }
    }

    public class ModelEventTimeRecord
    {
        public PointPair firstPoint;

        public ModelEventTimeRecord(PointPair firstPoint)
        {
            this.firstPoint = firstPoint;
        }
    }

    public class ModelEventSaveReport
    {
        public string ex = null;

        public ModelEventSaveReport()
        {

        }

        public ModelEventSaveReport(string ex)
        {
            this.ex = ex;
        }
    }

    public class ModelEventComConnect
    {
        public bool message;

        public ModelEventComConnect()
        { }

        public ModelEventComConnect(bool message)
        {
            this.message = message;
        }
    }

    public interface IModelObserver
    {
        void CreateProjectsObserver(IModel model, CreateProjectsEventArgs e);
        void StartMainObserver(IModel model, EventArgs e);
        void GetDefaultPortObserver(IModel model, ModelEventGetDefaultPort e);
        void ComConnectObserver(IModel model, ModelEventComConnect e);
        void SaveReportObserver(IModel model, ModelEventSaveReport e);
        void TimeRecordObserver(IModel model, ModelEventTimeRecord e);
        void BeginRecordObserver(IModel model, ModelEventBeginRecord e);
        void PortClosedObserver(IModel model, ModelEventPortClosed e);
    }

    public interface IModel
    {
        void CreateProjectsModel(List<string> text);
        void StartMainModel();
        void GetDefaultPortModel();
        void ComConnectModel(string comName, bool portOpen);
        void SaveReportModel(ZedGraphControl graph);
        void TimeRecord(bool startOrFinish);
        void BeginRecordModel();
        void FormClosingModel();
        void Attach(IModelObserver imo);
    }

    class Model : IModel
    {
        private event ModelHandlerCreateProjects<Model> createProjectsEvent;
        private event ModelHandler<Model> changed;
        private event ModelHandlerGetDefaultPort<Model> getDefaultPort;
        private event ModelHandlerComConnect<Model> comConnect;
        private event ModelHandlerSaveReport<Model> saveReport;
        private event ModelHandlerTimeRecord<Model> timeRecord;
        private event ModelHandlerBeginRecord<Model> beginRecord;
        private event ModelHandlerPortClosed<Model> portClosed;

        PointPair newPoint;
        Int32 pointCount;

        private SerialPort serial = new SerialPort();
        private List<Pack> queue = new List<Pack>();
        private List<byte> inPack = new List<byte>();

        private DateTime timeStart;
        private DateTime timeFinish;

        private bool continueRecord = false;
        bool onlyOnePoint = false;
        private double maxPressure = 0;

        public void Attach(IModelObserver imo) // подписка
        {
            createProjectsEvent += new ModelHandlerCreateProjects<Model>(imo.CreateProjectsObserver);
            changed += new ModelHandler<Model>(imo.StartMainObserver);
            getDefaultPort += new ModelHandlerGetDefaultPort<Model>(imo.GetDefaultPortObserver);
            comConnect += new ModelHandlerComConnect<Model>(imo.ComConnectObserver);
            saveReport += new ModelHandlerSaveReport<Model>(imo.SaveReportObserver);
            timeRecord += new ModelHandlerTimeRecord<Model>(imo.TimeRecordObserver);
            beginRecord += new ModelHandlerBeginRecord<Model>(imo.BeginRecordObserver);
            portClosed += new ModelHandlerPortClosed<Model>(imo.PortClosedObserver);
        }

        public void StartMainModel()
        {
            changed(this, new EventArgs());
        }

        public void GetDefaultPortModel()
        {
            string defaultPort = null;
            string[] portNames = SerialPort.GetPortNames();
            string[] directoryFiles = Directory.GetFiles(Directory.GetCurrentDirectory() + "\resources\");
            List<string> directoryList = new List<string>();
            List<string> readedStrings = new List<string>();
            List<string> portList = new List<string>();

            foreach (var name in portNames)
                portList.Add(name);

            foreach (var files in directoryFiles)
                directoryList.Add(files);

            if (directoryList.Exists(config => config == Directory.GetCurrentDirectory() + "\resources\" + "cfg.ini"))
            {
                StreamReader savedCatalog = new StreamReader(Directory.GetCurrentDirectory() + "\resources\" + "cfg.ini", Encoding.UTF8);
                while (savedCatalog.EndOfStream == false)
                {
                    readedStrings.Add(savedCatalog.ReadLine());
                }

                if (readedStrings.Count > 1)
                {
                    if (portList.Exists(name => name == readedStrings[1]))
                    {
                        defaultPort = portList.Find(port => port == readedStrings[1]);
                    }
                }
            }

            getDefaultPort(this, new ModelEventGetDefaultPort(defaultPort));
        }

        public void ComConnectModel(string comName, bool portOpen)
        {
            try
            {
                if (serial.IsOpen == true)
                    serial.Close();

                continueRecord = false;

                serial.PortName = comName;
                serial.BaudRate = 9600;
                serial.Parity = Parity.None;
                serial.DataBits = 8;
                serial.StopBits = StopBits.Two;
                serial.WriteTimeout = 50;
                serial.ReadTimeout = 50;
                serial.Open();
            }
            catch
            {
            }
            finally
            {
                bool connect = tryConnect();
                comConnect(this, new ModelEventComConnect(connect));
                if (connect == true)
                {
                    continueRecord = true;
                    string docPath = Environment.CurrentDirectory;
                    try
                    {
                        using (StreamWriter saveConfigFile = new StreamWriter(docPath + "\resources\" + "cfg.ini", false, Encoding.UTF8))
                        {
                            saveConfigFile.WriteLine("[COMPorts]");
                            saveConfigFile.WriteLine(comName);
                            saveConfigFile.Close();
                        }
                    }
                    catch { }

                }
                else
                    continueRecord = false;
            }
        }

        private bool tryConnect()
        {
            try
            {
                Pack testPack = new Pack();
                List<byte> test = new List<byte>();
                test.Add(0x00);
                test.Add(0x00);
                test.Add(0x00);
                test.Add(0x01);
                testPack.create(0x08, test.ToArray());
                serial.Write(testPack.getPackBytes(), 0, testPack.getPackBytes().Length);
                for (int i = 0; i < 8; i++)
                {
                    serial.ReadByte();
                }
                return true;
            }
            catch
            {
                return false;
            }
        }

        public void SaveReportModel(ZedGraphControl graph)
        {
            WordReport rep = new WordReport("", "",
                timeStart.ToString(),
                timeFinish.ToString(),
                timeFinish.Subtract(timeStart).ToString(),
                maxPressure.ToString());

            try
            {
                graph.GetImage().Save(Environment.CurrentDirectory + "\resources\" + "reportPicture.jpg");
                //("reportPicture.jpg");
                rep.createReport();
                rep.closeReport();

                saveReport(this, new ModelEventSaveReport());
            }
            catch(Exception ex)
            {
                if(rep.reportCreated == true)
                    rep.closeReport();
                saveReport(this, new ModelEventSaveReport(ex.ToString()));
            }
        }

        public void TimeRecord(bool startOrFinish)
        {
            //continueRecord = startOrFinish;

            if (startOrFinish == true)
            {
                if (!onlyOnePoint)
                {
                    timeStart = DateTime.Now;
                    timeRecord(this, new ModelEventTimeRecord(new PointPair { X = new XDate(timeStart), Y = 0 }));
                    onlyOnePoint = true;
                }
            }
            else
            {
                timeFinish = DateTime.Now;
            }
        }

        public void BeginRecordModel()
        {
            newPoint = new PointPair();
            Thread newThread = new Thread(new ThreadStart(IncrementPoints));
            newThread.Start();
        }

        private void IncrementPoints()
        {
            while (continueRecord)
            {
                if (serial.IsOpen)
                {
                    if (queue.Count > 0)
                    {
                        try
                        {
                            serial.Write(queue[0].getPackBytes(), 0, queue[0].getPackBytes().Length);
                        }
                        catch
                        {
                            serial.Close();
                            continueRecord = false;
                            portClosed(this, new ModelEventPortClosed());
                            break;
                        }
                    }
                    else
                    {
                        _takeLineState();
                    }

                    Thread.Sleep(200);

                    inPack.Clear();
                    byte b = new byte();
                    while (read_pack(ref b))
                    {
                        inPack.Add(b);
                    }

                    if (inPack.Count > 0)
                    {
                        double result = convertToDouble(inPack);
                        newPoint = new PointPair(new XDate(DateTime.Now), result/10);
                        pointCount++;

                        if (maxPressure < result)
                            maxPressure = result;

                        beginRecord(this, new ModelEventBeginRecord(newPoint, pointCount));
                    }
                }
                else
                {
                    if (serial.IsOpen)
                        serial.Close();

                    continueRecord = false;
                    portClosed(this, new ModelEventPortClosed());
                }
            }
        }

        private double convertToDouble(List<byte> pk)
        {
            byte[] a = new byte[2];
            a[0] = pk[4];
            a[1] = pk[3];
            double res = Convert.ToDouble(BitConverter.ToInt16(a,0));
            return res;
        }

        public void _takeLineState()
        {
            read_register(1);
        }

        public void read_register(ushort reg_number)
        {
            Pack p = new Pack();
            byte[] data = BitConverter.GetBytes(reg_number);
            List<byte> tmp = new List<byte>();
            tmp.Add(data[1]);
            tmp.Add(data[0]);
            tmp.Add(0x00);
            tmp.Add(0x01);
            p.create(0x03, tmp.ToArray());
            queue.Add(p);
        }

        private bool read_pack(ref byte b)
        {
            try
            {
                int val;// = serial.ReadByte();
                if (serial.IsOpen)
                {
                    val = serial.ReadByte();
                    if (val >= 0) b = (byte)val;
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch
            {
                return false;
            }
        }

        public void FormClosingModel()
        {
            continueRecord = false;
            if(serial.IsOpen)
                serial.Close();
        }

        SQLiteConnection connection;
        //public void SQLite(string[] text)
        public void CreateProjectsModel(List<string> text)
        {
            //conn = new SQLiteConnection("Data Source=" + text[0] + ".db; Version=3;");
            //try
            //{
            //    conn.Open();
            //}
            //catch (SQLiteException ex)
            //{
            //    Console.WriteLine(ex.Message);
            //}
            //if (conn.State == ConnectionState.Open)
            //{


            //}

            //const string dataBaseName = @"D:GeoFormdataBaseProjects.db";
            //connection = new SQLiteConnection(string.Format("Data Source={0};", dataBaseName));
            //connection.Open();
            //SQLiteCommand command = new SQLiteCommand("CREATE TABLE projects (id INTEGER PRIMARY KEY AUTOINCREMENT  NOT NULL, nameProduct TEXT  NOT NULL, number TEXT  NOT NULL, fioResponse INTEGER  NOT NULL);", connection);

            //SQLiteCommand command1 = new SQLiteCommand("INSERT INTO 'projects' ('id', 'nameProduct' , 'number','fioResponse') VALUES (1, 'yty',2,'ryt');", connection);

            //try
            //{
            //    command.ExecuteNonQuery();
            //}
            //finally
            //{
            //    connection.Close();
            //}
            List<string> str = new List<string>();
            str.Add("0");
            List<double> d1 = new List<double>();
            d1.Add(0);
            List<double> d2= new List<double>();
            d2.Add(0);

            createProjectsEvent(this, new CreateProjectsEventArgs(str,d1,d2));
        }
    }
}